@karibulab/wsdl2tsx 0.17.2 → 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
@@ -23775,18 +23796,22 @@ function extractAllTagsForXmlBody(typeObject, namespacesTypeMapping, baseNamespa
         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) {
@@ -23800,10 +23825,32 @@ function extractAllTagsForXmlBody(typeObject, namespacesTypeMapping, baseNamespa
                 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}"`);
             }
           }
+          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,13 +23859,27 @@ 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);
       debugContext("extractAllTagsForXmlBody", `Registrando namespace del elemento: "${namespacePrefix}" -> "${namespace}"`);
     }
-    debugContext("extractAllTagsForXmlBody", `Agregando tag "${tagLocalName}" al namespace "${namespacePrefix}" (namespace del elemento: "${namespace}")`);
+    debugContext("extractAllTagsForXmlBody", `Agregando tag "${tagLocalName}" al namespace "${namespacePrefix}" (namespace: "${namespace}")`);
     result.push(tagLocalName);
     if (!tagsByNamespace.has(namespace)) {
       tagsByNamespace.set(namespace, []);
@@ -23899,208 +23960,6 @@ function flattenKeysWithNamespace(typeObject, currentNamespace, currentNamespace
   return result;
 }
 
-// src/codegen/namespaces.ts
-function extractAllNamespaceMappings(baseTypeName, baseTypeObject, schemaObject, allComplexTypes) {
-  const tagsMapping = {};
-  const prefixesMapping = {};
-  const typesMapping = {};
-  if (!baseTypeObject || typeof baseTypeObject !== "object") {
-    throw new Error(`El objeto de tipo ${baseTypeName} es inv\xE1lido o est\xE1 vac\xEDo`);
-  }
-  const baseNamespace = baseTypeObject[NAMESPACE_KEY];
-  if (!baseNamespace) {
-    throw new Error(`El tipo ${baseTypeName} no tiene la propiedad $namespace definida`);
-  }
-  const baseIsQualified = baseTypeObject.$qualified === true;
-  const existingPrefixesSet = /* @__PURE__ */ new Set();
-  const baseNamespacePrefix = extractNamespacePrefix(baseNamespace, existingPrefixesSet);
-  existingPrefixesSet.add(baseNamespacePrefix);
-  const baseTypeLocalName = extractLocalName(baseTypeName);
-  if (baseIsQualified) {
-    tagsMapping[baseNamespacePrefix] = [baseTypeLocalName];
-    prefixesMapping[baseNamespacePrefix] = baseNamespace;
-  }
-  typesMapping[baseTypeName] = {
-    uri: baseNamespace,
-    prefix: baseNamespacePrefix
-  };
-  const keys = getFilteredKeys(baseTypeObject);
-  for (const key of keys) {
-    const element = baseTypeObject[key];
-    const tagLocalName = extractLocalName(key);
-    let elementIsQualified = false;
-    let elementNamespace;
-    if (typeof element === "object" && element !== null) {
-      elementIsQualified = element.$qualified === true;
-      elementNamespace = element.$namespace;
-    }
-    const namespace = elementNamespace || baseNamespace;
-    const tagNames = elementIsQualified ? [tagLocalName] : [];
-    if (typeof element === "object" && element !== null && typeof element.type === "object") {
-      const nestedTags = extractNestedTags(element.type);
-      tagNames.push(...nestedTags);
-    }
-    let namespacePrefix = extractNamespacePrefix(namespace, existingPrefixesSet);
-    if (prefixesMapping[namespacePrefix] && prefixesMapping[namespacePrefix] !== namespace) {
-      namespacePrefix = extractNamespacePrefix(namespace, existingPrefixesSet);
-    }
-    existingPrefixesSet.add(namespacePrefix);
-    if (tagNames.length > 0) {
-      if (tagsMapping[namespacePrefix] === void 0) {
-        tagsMapping[namespacePrefix] = tagNames;
-      } else {
-        tagsMapping[namespacePrefix].push(...tagNames);
-      }
-      if (prefixesMapping[namespacePrefix] === void 0) {
-        prefixesMapping[namespacePrefix] = namespace;
-      }
-    }
-  }
-  const flatKeys = flattenKeysWithNamespace(baseTypeObject, baseNamespace, baseNamespacePrefix);
-  for (const item of flatKeys) {
-    typesMapping[item.name] = {
-      uri: item.uri,
-      prefix: item.prefix
-    };
-  }
-  const xmlBodyResult = extractAllTagsForXmlBody(
-    baseTypeObject,
-    typesMapping,
-    baseNamespacePrefix,
-    baseNamespace,
-    /* @__PURE__ */ new Set(),
-    schemaObject,
-    allComplexTypes
-  );
-  for (const [prefix, uri] of xmlBodyResult.namespaces) {
-    let finalPrefix;
-    for (const [p, u] of Object.entries(prefixesMapping)) {
-      if (u === uri) {
-        finalPrefix = p;
-        break;
-      }
-    }
-    if (!finalPrefix || prefixesMapping[prefix] && prefixesMapping[prefix] !== uri) {
-      finalPrefix = extractNamespacePrefix(uri, existingPrefixesSet);
-      existingPrefixesSet.add(finalPrefix);
-      if (prefixesMapping[prefix] && prefixesMapping[prefix] !== uri) {
-        debugContext("extractAllNamespaceMappings", `Colisi\xF3n de prefijo detectada para "${prefix}", usando prefijo \xFAnico: "${finalPrefix}"`);
-      }
-    }
-    if (!prefixesMapping[finalPrefix]) {
-      prefixesMapping[finalPrefix] = uri;
-      debugContext("extractAllNamespaceMappings", `Agregando namespace adicional al prefixesMapping: "${finalPrefix}" -> "${uri}"`);
-    }
-    if (!tagsMapping[finalPrefix]) {
-      tagsMapping[finalPrefix] = [];
-    }
-  }
-  const allTagsAdded = /* @__PURE__ */ new Set();
-  for (const [nsUri, tags] of xmlBodyResult.tagsByNamespace) {
-    let finalPrefix;
-    for (const [p, u] of Object.entries(prefixesMapping)) {
-      if (u === nsUri) {
-        finalPrefix = p;
-        break;
-      }
-    }
-    if (!finalPrefix) {
-      finalPrefix = extractNamespacePrefix(nsUri, existingPrefixesSet);
-      existingPrefixesSet.add(finalPrefix);
-    }
-    if (!tagsMapping[finalPrefix]) {
-      tagsMapping[finalPrefix] = [];
-    }
-    const existingTags = new Set(tagsMapping[finalPrefix] || []);
-    const tagsToAdd = [];
-    for (const tag of tags) {
-      if (!existingTags.has(tag) && !allTagsAdded.has(tag)) {
-        tagsToAdd.push(tag);
-        allTagsAdded.add(tag);
-      }
-    }
-    if (tagsToAdd.length > 0) {
-      tagsMapping[finalPrefix].push(...tagsToAdd);
-      debugContext("extractAllNamespaceMappings", `Agregando ${tagsToAdd.length} tag(s) al namespace "${finalPrefix}" (${nsUri}): ${tagsToAdd.join(", ")}`);
-    }
-  }
-  const baseNamespaceTags = xmlBodyResult.tagsByNamespace.get(baseNamespace);
-  if (baseNamespaceTags && baseNamespaceTags.length > 0) {
-    if (tagsMapping[baseNamespacePrefix] === void 0) {
-      tagsMapping[baseNamespacePrefix] = [];
-      prefixesMapping[baseNamespacePrefix] = baseNamespace;
-    }
-    const existingTags = new Set(tagsMapping[baseNamespacePrefix] || []);
-    for (const tag of baseNamespaceTags) {
-      if (!existingTags.has(tag)) {
-        tagsMapping[baseNamespacePrefix].push(tag);
-        existingTags.add(tag);
-      }
-    }
-    debugContext("extractAllNamespaceMappings", `Agregando ${baseNamespaceTags.length} tag(s) al namespace base "${baseNamespacePrefix}"`);
-  }
-  return {
-    tagsMapping,
-    prefixesMapping,
-    typesMapping
-  };
-}
-function getNamespacePrefix(namespacesTypeMapping, baseNamespacePrefix, key, parentKey, elementObject, prefixesMapping) {
-  if (elementObject && typeof elementObject === "object") {
-    const elemNs = elementObject.$namespace;
-    if (typeof elemNs === "string") {
-      debugContext("getNamespacePrefix", `Elemento "${key}" tiene namespace: "${elemNs}"`);
-      if (prefixesMapping) {
-        for (const [prefix, uri] of Object.entries(prefixesMapping)) {
-          if (uri === elemNs) {
-            debugContext("getNamespacePrefix", `Encontrado prefijo "${prefix}" para namespace "${elemNs}"`);
-            return prefix;
-          }
-        }
-        debugContext("getNamespacePrefix", `No se encontr\xF3 prefijo en prefixesMapping para "${elemNs}", usando extractNamespacePrefix`);
-      }
-      const extractedPrefix = extractNamespacePrefix(elemNs);
-      debugContext("getNamespacePrefix", `Usando prefijo extra\xEDdo: "${extractedPrefix}" para namespace "${elemNs}"`);
-      return extractedPrefix;
-    } else {
-      if ("type" in elementObject && typeof elementObject.type === "object" && elementObject.type !== null) {
-        const typeNs = elementObject.type.$namespace;
-        if (typeof typeNs === "string") {
-          debugContext("getNamespacePrefix", `Elemento "${key}" no tiene $namespace, pero su tipo tiene: "${typeNs}"`);
-          if (prefixesMapping) {
-            for (const [prefix, uri] of Object.entries(prefixesMapping)) {
-              if (uri === typeNs) {
-                debugContext("getNamespacePrefix", `Encontrado prefijo "${prefix}" para namespace del tipo "${typeNs}"`);
-                return prefix;
-              }
-            }
-          }
-          const extractedPrefix = extractNamespacePrefix(typeNs);
-          debugContext("getNamespacePrefix", `Usando prefijo extra\xEDdo del tipo: "${extractedPrefix}" para namespace "${typeNs}"`);
-          return extractedPrefix;
-        }
-      }
-    }
-  }
-  if (parentKey !== null) {
-    return namespacesTypeMapping[parentKey]?.prefix ?? baseNamespacePrefix;
-  }
-  return namespacesTypeMapping[key]?.prefix ?? baseNamespacePrefix;
-}
-function shouldHavePrefix(elementObject) {
-  if (!elementObject || typeof elementObject !== "object") return false;
-  if ("$qualified" in elementObject && typeof elementObject.$qualified === "boolean") {
-    return elementObject.$qualified;
-  }
-  if ("type" in elementObject && typeof elementObject.type === "object" && elementObject.type !== null) {
-    const typeObj = elementObject.type;
-    if ("$qualified" in typeObj && typeof typeObj.$qualified === "boolean") {
-      return typeObj.$qualified;
-    }
-  }
-  return false;
-}
-
 // src/codegen/xml-generator/type-resolution.ts
 function resolveReferencedType(typeValue, schemaObject, allComplexTypes) {
   let referencedElement = schemaObject?.[typeValue];
@@ -24161,7 +24020,7 @@ function resolveNestedType(nestedTypeValue, schemaObject, allComplexTypes) {
 }
 
 // src/codegen/xml-generator/xml-property.ts
-function generateXmlPropertyCode(namespacesTypeMapping, baseNamespacePrefix, key, elementObject, parentKey = null, propertyPath = "", parentIsQualified = true, prefixesMapping, schemaObject, allComplexTypes) {
+function generateXmlPropertyCode(namespacesTypeMapping, baseNamespacePrefix, key, elementObject, parentKey = null, propertyPath = "", parentIsQualified = true, prefixesMapping, schemaObject, allComplexTypes, tagUsageCollector) {
   const namespacePrefix = getNamespacePrefix(
     namespacesTypeMapping,
     baseNamespacePrefix,
@@ -24175,12 +24034,73 @@ function generateXmlPropertyCode(namespacesTypeMapping, baseNamespacePrefix, key
   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);
@@ -24215,14 +24135,15 @@ function generateXmlPropertyCode(namespacesTypeMapping, baseNamespacePrefix, key
                 isQualified,
                 prefixesMapping,
                 schemaObject,
-                allComplexTypes
+                allComplexTypes,
+                tagUsageCollector
               );
             }
             return "";
           }).filter(Boolean).join("\n");
-          return `${openTag}
+          return `${wrapperOpenTag}
     ${nestedProperties}
-    ${closeTag}`;
+    ${wrapperCloseTag}`;
         }
       }
       const referencedKeys = getFilteredKeys(finalReferencedElement);
@@ -24251,14 +24172,15 @@ function generateXmlPropertyCode(namespacesTypeMapping, baseNamespacePrefix, key
               isQualified,
               prefixesMapping,
               schemaObject,
-              allComplexTypes
+              allComplexTypes,
+              tagUsageCollector
             );
           }
           return "";
         }).filter(Boolean).join("\n");
-        return `${openTag}
+        return `${wrapperOpenTag}
     ${nestedProperties}
-    ${closeTag}`;
+    ${wrapperCloseTag}`;
       }
     }
   }
@@ -24325,7 +24247,8 @@ function generateXmlPropertyCode(namespacesTypeMapping, baseNamespacePrefix, key
             isQualified,
             prefixesMapping,
             schemaObject,
-            allComplexTypes
+            allComplexTypes,
+            tagUsageCollector
           );
         }
         return "";
@@ -24339,7 +24262,7 @@ function generateXmlPropertyCode(namespacesTypeMapping, baseNamespacePrefix, key
 }
 
 // src/codegen/xml-generator/xml-body.ts
-function generateXmlBodyCode(baseNamespacePrefix, namespacesTypeMapping, baseTypeName, baseTypeObject, propsInterfaceName, schemaObject, allComplexTypes, prefixesMapping) {
+function generateXmlBodyCode(baseNamespacePrefix, namespacesTypeMapping, baseTypeName, baseTypeObject, propsInterfaceName, schemaObject, allComplexTypes, prefixesMapping, tagUsageCollector) {
   const keys = getFilteredKeys(baseTypeObject);
   const baseTypeLocalName = extractLocalName(baseTypeName);
   if (keys.length === 1) {
@@ -24350,7 +24273,7 @@ function generateXmlBodyCode(baseNamespacePrefix, namespacesTypeMapping, baseTyp
       if (typeof typeValue === "object" && typeValue !== null) {
         const typeKeys = getFilteredKeys(typeValue);
         if (typeKeys.length > 0) {
-          return generateXmlBodyCode(baseNamespacePrefix, namespacesTypeMapping, baseTypeName, typeValue, propsInterfaceName, schemaObject, allComplexTypes, prefixesMapping);
+          return generateXmlBodyCode(baseNamespacePrefix, namespacesTypeMapping, baseTypeName, typeValue, propsInterfaceName, schemaObject, allComplexTypes, prefixesMapping, tagUsageCollector);
         }
       }
     }
@@ -24372,16 +24295,242 @@ function generateXmlBodyCode(baseNamespacePrefix, namespacesTypeMapping, baseTyp
         // El padre (root element) siempre es qualified
         prefixesMapping,
         schemaObject,
-        allComplexTypes
+        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 = {};
+  const prefixesMapping = {};
+  const typesMapping = {};
+  if (!baseTypeObject || typeof baseTypeObject !== "object") {
+    throw new Error(`El objeto de tipo ${baseTypeName} es inv\xE1lido o est\xE1 vac\xEDo`);
+  }
+  const baseNamespace = baseTypeObject[NAMESPACE_KEY];
+  if (!baseNamespace) {
+    throw new Error(`El tipo ${baseTypeName} no tiene la propiedad $namespace definida`);
+  }
+  const baseIsQualified = baseTypeObject.$qualified === true;
+  const existingPrefixesSet = /* @__PURE__ */ new Set();
+  const baseNamespacePrefix = extractNamespacePrefix(baseNamespace, existingPrefixesSet);
+  existingPrefixesSet.add(baseNamespacePrefix);
+  const baseTypeLocalName = extractLocalName(baseTypeName);
+  if (baseIsQualified) {
+    tagsMapping[baseNamespacePrefix] = [baseTypeLocalName];
+    prefixesMapping[baseNamespacePrefix] = baseNamespace;
+  }
+  typesMapping[baseTypeName] = {
+    uri: baseNamespace,
+    prefix: baseNamespacePrefix
+  };
+  const keys = getFilteredKeys(baseTypeObject);
+  for (const key of keys) {
+    const element = baseTypeObject[key];
+    const tagLocalName = extractLocalName(key);
+    let elementIsQualified = false;
+    let elementNamespace;
+    if (typeof element === "object" && element !== null) {
+      elementIsQualified = element.$qualified === true;
+      elementNamespace = element.$namespace;
+    }
+    const namespace = elementNamespace || baseNamespace;
+    const tagNames = elementIsQualified ? [tagLocalName] : [];
+    if (typeof element === "object" && element !== null && typeof element.type === "object") {
+      const nestedTags = extractNestedTags(element.type);
+      tagNames.push(...nestedTags);
+    }
+    let namespacePrefix = extractNamespacePrefix(namespace, existingPrefixesSet);
+    if (prefixesMapping[namespacePrefix] && prefixesMapping[namespacePrefix] !== namespace) {
+      namespacePrefix = extractNamespacePrefix(namespace, existingPrefixesSet);
+    }
+    existingPrefixesSet.add(namespacePrefix);
+    if (tagNames.length > 0) {
+      if (tagsMapping[namespacePrefix] === void 0) {
+        tagsMapping[namespacePrefix] = tagNames;
+      } else {
+        tagsMapping[namespacePrefix].push(...tagNames);
+      }
+      if (prefixesMapping[namespacePrefix] === void 0) {
+        prefixesMapping[namespacePrefix] = namespace;
+      }
+    }
+  }
+  const flatKeys = flattenKeysWithNamespace(baseTypeObject, baseNamespace, baseNamespacePrefix);
+  for (const item of flatKeys) {
+    typesMapping[item.name] = {
+      uri: item.uri,
+      prefix: item.prefix
+    };
+  }
+  const xmlBodyResult = extractAllTagsForXmlBody(
+    baseTypeObject,
+    typesMapping,
+    baseNamespacePrefix,
+    baseNamespace,
+    /* @__PURE__ */ new Set(),
+    schemaObject,
+    allComplexTypes
+  );
+  for (const [prefix, uri] of xmlBodyResult.namespaces) {
+    let finalPrefix;
+    for (const [p, u] of Object.entries(prefixesMapping)) {
+      if (u === uri) {
+        finalPrefix = p;
+        break;
+      }
+    }
+    if (!finalPrefix || prefixesMapping[prefix] && prefixesMapping[prefix] !== uri) {
+      finalPrefix = extractNamespacePrefix(uri, existingPrefixesSet);
+      existingPrefixesSet.add(finalPrefix);
+      if (prefixesMapping[prefix] && prefixesMapping[prefix] !== uri) {
+        debugContext("extractAllNamespaceMappings", `Colisi\xF3n de prefijo detectada para "${prefix}", usando prefijo \xFAnico: "${finalPrefix}"`);
+      }
+    }
+    if (!prefixesMapping[finalPrefix]) {
+      prefixesMapping[finalPrefix] = uri;
+      debugContext("extractAllNamespaceMappings", `Agregando namespace adicional al prefixesMapping: "${finalPrefix}" -> "${uri}"`);
+    }
+    if (!tagsMapping[finalPrefix]) {
+      tagsMapping[finalPrefix] = [];
+    }
+  }
+  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 (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}"`);
+      }
+    }
+    tagToPrefixMap.set(tag, prefix);
+    if (!prefixToTags.has(prefix)) {
+      prefixToTags.set(prefix, /* @__PURE__ */ new Set());
+    }
+    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(", ")}`);
+    }
+  }
+  for (const [prefix, namespaceUri] of tagUsageCollector.prefixToNamespace) {
+    if (!prefixesMapping[prefix]) {
+      prefixesMapping[prefix] = namespaceUri;
+      debugContext("extractAllNamespaceMappings", `Registrando namespace para prefijo "${prefix}": "${namespaceUri}"`);
+    }
+  }
+  for (const prefix of Object.keys(prefixesMapping)) {
+    if (!newTagsMapping[prefix]) {
+      newTagsMapping[prefix] = [];
+    }
+  }
+  Object.assign(tagsMapping, newTagsMapping);
+  return {
+    tagsMapping,
+    prefixesMapping,
+    typesMapping
+  };
+}
+function getNamespacePrefix(namespacesTypeMapping, baseNamespacePrefix, key, parentKey, elementObject, prefixesMapping) {
+  if (elementObject && typeof elementObject === "object") {
+    const elemNs = elementObject.$namespace;
+    if (typeof elemNs === "string") {
+      debugContext("getNamespacePrefix", `Elemento "${key}" tiene namespace: "${elemNs}"`);
+      if (prefixesMapping) {
+        for (const [prefix, uri] of Object.entries(prefixesMapping)) {
+          if (uri === elemNs) {
+            debugContext("getNamespacePrefix", `Encontrado prefijo "${prefix}" para namespace "${elemNs}"`);
+            return prefix;
+          }
+        }
+        debugContext("getNamespacePrefix", `No se encontr\xF3 prefijo en prefixesMapping para "${elemNs}", usando extractNamespacePrefix`);
+      }
+      const extractedPrefix = extractNamespacePrefix(elemNs);
+      debugContext("getNamespacePrefix", `Usando prefijo extra\xEDdo: "${extractedPrefix}" para namespace "${elemNs}"`);
+      return extractedPrefix;
+    } else {
+      if ("type" in elementObject && typeof elementObject.type === "object" && elementObject.type !== null) {
+        const typeNs = elementObject.type.$namespace;
+        if (typeof typeNs === "string") {
+          debugContext("getNamespacePrefix", `Elemento "${key}" no tiene $namespace, pero su tipo tiene: "${typeNs}"`);
+          if (prefixesMapping) {
+            for (const [prefix, uri] of Object.entries(prefixesMapping)) {
+              if (uri === typeNs) {
+                debugContext("getNamespacePrefix", `Encontrado prefijo "${prefix}" para namespace del tipo "${typeNs}"`);
+                return prefix;
+              }
+            }
+          }
+          const extractedPrefix = extractNamespacePrefix(typeNs);
+          debugContext("getNamespacePrefix", `Usando prefijo extra\xEDdo del tipo: "${extractedPrefix}" para namespace "${typeNs}"`);
+          return extractedPrefix;
+        }
+      }
+    }
+  }
+  if (parentKey !== null) {
+    return namespacesTypeMapping[parentKey]?.prefix ?? baseNamespacePrefix;
+  }
+  return namespacesTypeMapping[key]?.prefix ?? baseNamespacePrefix;
+}
+function shouldHavePrefix(elementObject) {
+  if (!elementObject || typeof elementObject !== "object") return false;
+  if ("$qualified" in elementObject && typeof elementObject.$qualified === "boolean") {
+    return elementObject.$qualified;
+  }
+  if ("type" in elementObject && typeof elementObject.type === "object" && elementObject.type !== null) {
+    const typeObj = elementObject.type;
+    if ("$qualified" in typeObj && typeof typeObj.$qualified === "boolean") {
+      return typeObj.$qualified;
+    }
+  }
+  return false;
+}
+
 // src/codegen/data-preparer/simple-types.ts
 function prepareSimpleTypesData(typeObject, xmlSchemaUri) {
   return Object.keys(typeObject).filter((key) => {
@@ -24647,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.2",
+  "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.2",
+    "@karibulab/wsdl2tsx-runtime": "0.20.0",
     "axios": "^1.7.9",
     "fast-xml-parser": "5.3.3",
     "handlebars": "4.7.8"