@karibulab/wsdl2tsx 0.7.0 → 0.10.0

package/README.md

@@ -11,7 +11,7 @@ npm install -g @karibulab/wsdl2tsx
 O usar directamente con `npx`:
 
 ```bash
-npx @karibulab/wsdl2tsx <wsdl-url> <directorio-salida>
+npx @karibulab/wsdl2tsx <wsdl-url> <directorio-salida> [--operation=<nombre>]
 ```
 
 ## Uso
@@ -19,27 +19,42 @@ npx @karibulab/wsdl2tsx <wsdl-url> <directorio-salida>
 ### Desde línea de comandos
 
 ```bash
-wsdl2tsx <ruta-wsdl> <directorio-salida>
+wsdl2tsx <ruta-wsdl> <directorio-salida> [--operation=<nombre>]
 ```
 
-**Ejemplo:**
+**Ejemplos:**
 
 ```bash
+# Generar todas las operaciones
 wsdl2tsx http://ejemplo.com/servicio?wsdl ./output
 ```
 
+```bash
+# Generar solo una operación específica
+wsdl2tsx http://ejemplo.com/servicio?wsdl ./output --operation=ConsultaCodigoPlan
+```
+
+```bash
+# Con flag corto
+wsdl2tsx http://ejemplo.com/servicio?wsdl ./output -o ConsultaCodigoPlan
+```
+
 ### Parámetros
 
 - `<ruta-wsdl>`: URL o ruta local al archivo WSDL
 - `<directorio-salida>`: Directorio donde se generarán los archivos TSX
+- `--operation=<nombre>` o `-o <nombre>` (opcional): Especifica el nombre de la operación a generar. Si no se especifica, se generan todas las operaciones con input definido. El nombre debe coincidir exactamente con el nombre de la operación en el WSDL (no es case-sensitive).
 
 ## Características
 
 - ✅ Genera componentes TypeScript/TSX tipados desde WSDL
+- ✅ **Soporta múltiples operaciones**: Genera un archivo TSX por cada operación del WSDL
+- ✅ **Filtrado por operación**: Permite generar solo una operación específica con `--operation` o `-o`
 - ✅ Respeta `elementFormDefault` para manejo correcto de namespaces
 - ✅ Genera interfaces TypeScript para todos los tipos complejos
 - ✅ Soporta múltiples schemas y namespaces
 - ✅ Maneja imports y referencias entre schemas
+- ✅ Omite automáticamente operaciones sin input (notificaciones, solo-output)
 - ✅ Genera código compatible con el runtime `@karibulab/wsdl2tsx-runtime`
 
 ## Ejemplo de salida
@@ -85,9 +100,15 @@ npm run build:cli
 
 # Ejecutar localmente
 cd packages/cli
-node dist/cli.js <wsdl-url> <output-dir>
+node dist/cli.js <wsdl-url> <output-dir> [--operation=<nombre>]
 ```
 
+### Notas sobre operaciones
+
+- **Operaciones sin input**: Las operaciones que no tienen un nodo `input` definido (como notificaciones o operaciones solo-output) se omiten automáticamente con una advertencia.
+- **Múltiples operaciones**: Por defecto, el CLI procesa todas las operaciones válidas y genera un archivo por cada una.
+- **Filtrado**: Usa `--operation` o `-o` para generar solo una operación específica, útil cuando trabajas con WSDL grandes.
+
 ## Licencia
 
 ISC

package/dist/cli.js

@@ -16721,7 +16721,7 @@ var require_lib = __commonJS({
   }
 });
 
-// src/wsdl.ts
+// src/wsdl/loader.ts
 var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
 
@@ -21788,7 +21788,7 @@ var XMLParser = class {
   }
 };
 
-// src/wsdl.ts
+// src/wsdl/loader.ts
 var loadXml = async (xmlPath) => {
   let xmlContentString;
   if (xmlPath.match(/^http(s)?:\/\//)) {
@@ -21844,15 +21844,155 @@ var loadXsd = async (wsdlFile, xsdPath) => {
   const wsdlDir = import_path.default.dirname(wsdlFile);
   return await loadXml(import_path.default.resolve(wsdlDir, xsdPath));
 };
-var fillObject = (object, namespaces, complexTypes) => {
-  for (const item of Object.keys(object)) {
-    const value = object[item];
-    if (complexTypes !== void 0 && complexTypes[value.type] !== void 0) {
-      object[item] = fillObject(complexTypes[value.type], namespaces, complexTypes);
+
+// src/wsdl/node-extractors.ts
+var getSequenceNode = (node) => {
+  if (!node || typeof node !== "object") {
+    return void 0;
+  }
+  const sequenceField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?sequence/));
+  return sequenceField ? node[sequenceField] : void 0;
+};
+var getChoiceNode = (node) => {
+  if (!node || typeof node !== "object") {
+    return void 0;
+  }
+  const choiceField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?choice/));
+  return choiceField ? node[choiceField] : void 0;
+};
+var getAllNode = (node) => {
+  if (!node || typeof node !== "object") {
+    return void 0;
+  }
+  const allField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?all/));
+  return allField ? node[allField] : void 0;
+};
+var getGroupNode = (node) => {
+  if (!node || typeof node !== "object") {
+    return void 0;
+  }
+  const groupField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?group/));
+  return groupField ? node[groupField] : void 0;
+};
+var getSimpleContentNode = (node) => {
+  if (!node || typeof node !== "object") {
+    return void 0;
+  }
+  const simpleContentField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?simpleContent/));
+  return simpleContentField ? node[simpleContentField] : void 0;
+};
+var getComplexContentNode = (node) => {
+  if (!node || typeof node !== "object") {
+    return void 0;
+  }
+  const complexContentField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?complexContent/));
+  return complexContentField ? node[complexContentField] : void 0;
+};
+var getExtensionNode = (node) => {
+  if (!node || typeof node !== "object") {
+    return void 0;
+  }
+  const extensionField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?extension/));
+  return extensionField ? node[extensionField] : void 0;
+};
+var getRestrictionNode = (node) => {
+  if (!node || typeof node !== "object") {
+    return void 0;
+  }
+  const restrictionField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?restriction/));
+  return restrictionField ? node[restrictionField] : void 0;
+};
+var getAttributeNode = (node) => {
+  const attributeField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?attribute/));
+  return node[attributeField];
+};
+var getSchemaNode = (node) => {
+  const schemaField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?schema/));
+  return node[schemaField];
+};
+var getAllSchemaNodes = (node) => {
+  const schemas = [];
+  for (const key of Object.keys(node)) {
+    if (key.match(/([a-zA-z0-9]*:)?schema/)) {
+      const schemaValue = node[key];
+      if (Array.isArray(schemaValue)) {
+        schemas.push(...schemaValue);
+      } else if (schemaValue !== void 0) {
+        schemas.push(schemaValue);
+      }
     }
   }
-  return object;
+  return schemas;
+};
+var getElementNode = (node) => {
+  if (Array.isArray(node)) {
+    const elementNodes = [];
+    for (const item of node) {
+      const elementNode = getElementNode(item);
+      if (elementNode !== void 0) {
+        elementNodes.push(elementNode);
+      }
+    }
+    return elementNodes;
+  }
+  const elementField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?element/));
+  return node[elementField];
+};
+var getComplexTypeNode = (node) => {
+  const complexTypeField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?complexType/));
+  return node[complexTypeField];
+};
+var getDefinitionsNode = (node) => {
+  const definitionsField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?definitions/));
+  return node[definitionsField];
+};
+var getTypesNode = (node) => {
+  const typesField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?types/));
+  return node[typesField];
+};
+var getImportNode = (node) => {
+  const importField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?import/));
+  return node[importField];
+};
+var getMessageNode = (node) => {
+  const messageField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?message/));
+  const messageValue = node[messageField];
+  return Array.isArray(messageValue) ? messageValue : [messageValue];
 };
+var getPortTypeNode = (node) => {
+  const portTypeField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?portType/));
+  return node[portTypeField];
+};
+var getOperationNodes = (node) => {
+  const operationField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?operation/));
+  if (!operationField) return [];
+  const operationValue = node[operationField];
+  return Array.isArray(operationValue) ? operationValue : operationValue ? [operationValue] : [];
+};
+var getInputNode = (node) => {
+  const inputField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?input/));
+  return node[inputField];
+};
+var getPartNode = (node) => {
+  const partField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?part/));
+  return node[partField];
+};
+var getNamespacesFromNode = (node) => {
+  const namespaces = /* @__PURE__ */ new Map();
+  if (node.targetNamespace !== void 0) {
+    namespaces.set("targetNamespace", node.targetNamespace);
+  }
+  for (const key of Object.keys(node)) {
+    const match = key.match(/xmlns:([a-zA-z0-9]*)/);
+    if (match !== null) {
+      const value = node[key];
+      namespaces.set(match[1], value);
+    }
+  }
+  return namespaces;
+};
+
+// src/wsdl/processors.ts
 var processSingleElement = (node, namespaces, complexTypes, targetNamespace, isQualified = false) => {
   if (node.type === void 0) {
     return "xsd:anyType";
@@ -21892,6 +22032,15 @@ var processSingleElement = (node, namespaces, complexTypes, targetNamespace, isQ
     return namespace + ":" + node.type;
   }
 };
+var fillObject = (object, namespaces, complexTypes) => {
+  for (const item of Object.keys(object)) {
+    const value = object[item];
+    if (complexTypes !== void 0 && complexTypes[value.type] !== void 0) {
+      object[item] = fillObject(complexTypes[value.type], namespaces, complexTypes);
+    }
+  }
+  return object;
+};
 var processElementsToObject = (elementNode, namespaces, complexTypes, targetNamespace, isQualified = false) => {
   if (elementNode === void 0) {
     const object = {};
@@ -22100,102 +22249,6 @@ var complexContentToObject = (node, namespaces, complexTypes, targetNamespace, i
   }
   return object;
 };
-var getSequenceNode = (node) => {
-  if (!node || typeof node !== "object") {
-    return void 0;
-  }
-  const sequenceField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?sequence/));
-  return sequenceField ? node[sequenceField] : void 0;
-};
-var getChoiceNode = (node) => {
-  if (!node || typeof node !== "object") {
-    return void 0;
-  }
-  const choiceField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?choice/));
-  return choiceField ? node[choiceField] : void 0;
-};
-var getAllNode = (node) => {
-  if (!node || typeof node !== "object") {
-    return void 0;
-  }
-  const allField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?all/));
-  return allField ? node[allField] : void 0;
-};
-var getGroupNode = (node) => {
-  if (!node || typeof node !== "object") {
-    return void 0;
-  }
-  const groupField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?group/));
-  return groupField ? node[groupField] : void 0;
-};
-var getSimpleContentNode = (node) => {
-  if (!node || typeof node !== "object") {
-    return void 0;
-  }
-  const simpleContentField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?simpleContent/));
-  return simpleContentField ? node[simpleContentField] : void 0;
-};
-var getComplexContentNode = (node) => {
-  if (!node || typeof node !== "object") {
-    return void 0;
-  }
-  const complexContentField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?complexContent/));
-  return complexContentField ? node[complexContentField] : void 0;
-};
-var getExtensionNode = (node) => {
-  if (!node || typeof node !== "object") {
-    return void 0;
-  }
-  const extensionField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?extension/));
-  return extensionField ? node[extensionField] : void 0;
-};
-var getRestrictionNode = (node) => {
-  if (!node || typeof node !== "object") {
-    return void 0;
-  }
-  const restrictionField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?restriction/));
-  return restrictionField ? node[restrictionField] : void 0;
-};
-var getAttributeNode = (node) => {
-  const attributeField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?attribute/));
-  return node[attributeField];
-};
-var getSchemaNode = (node) => {
-  const schemaField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?schema/));
-  return node[schemaField];
-};
-var getAllSchemaNodes = (node) => {
-  const schemas = [];
-  for (const key of Object.keys(node)) {
-    if (key.match(/([a-zA-z0-9]*:)?schema/)) {
-      const schemaValue = node[key];
-      if (Array.isArray(schemaValue)) {
-        schemas.push(...schemaValue);
-      } else if (schemaValue !== void 0) {
-        schemas.push(schemaValue);
-      }
-    }
-  }
-  return schemas;
-};
-var getElementNode = (node) => {
-  if (Array.isArray(node)) {
-    const elementNodes = [];
-    for (const item of node) {
-      const elementNode = getElementNode(item);
-      if (elementNode !== void 0) {
-        elementNodes.push(elementNode);
-      }
-    }
-    return elementNodes;
-  }
-  const elementField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?element/));
-  return node[elementField];
-};
-var getComplexTypeNode = (node) => {
-  const complexTypeField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?complexType/));
-  return node[complexTypeField];
-};
 var complexTypeToObject = (node, namespaces, complexTypes, targetNamespace, isQualified = false) => {
   if (!node) {
     const object = {};
@@ -22299,6 +22352,8 @@ var complexTypeToObject = (node, namespaces, complexTypes, targetNamespace, isQu
     throw new Error("No se encontr\xF3 nodo sequence, choice, all, group, simpleContent o complexContent");
   }
 };
+
+// src/wsdl/complex-types.ts
 var complexTypesFromSchema = async (wsdlFile, node, namespaces) => {
   const targetNamespace = node.targetNamespace;
   const isQualified = node.elementFormDefault === "qualified";
@@ -22457,54 +22512,19 @@ var schemaToObject = (node, namespaces, complexTypes) => {
   object["$qualified"] = isQualified;
   return object;
 };
-var getDefinitionsNode = (node) => {
-  const definitionsField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?definitions/));
-  return node[definitionsField];
-};
-var getTypesNode = (node) => {
-  const typesField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?types/));
-  return node[typesField];
-};
-var getImportNode = (node) => {
-  const importField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?import/));
-  return node[importField];
-};
-var getMessageNode = (node) => {
-  const messageField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?message/));
-  const messageValue = node[messageField];
-  return Array.isArray(messageValue) ? messageValue : [messageValue];
-};
-var getPortTypeNode = (node) => {
-  const portTypeField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?portType/));
-  return node[portTypeField];
-};
-var getOperationNode = (node) => {
-  const operationField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?operation/));
-  return node[operationField];
-};
-var getInputNode = (node) => {
-  const inputField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?input/));
-  return node[inputField];
-};
-var getPartNode = (node) => {
-  const partField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?part/));
-  return node[partField];
+
+// src/wsdl/operations.ts
+var getOperationName = (operationNode) => {
+  return operationNode.name || "UnknownOperation";
 };
-var getRequestTypeFromDefinitions = (definitionsNode, schemaObject) => {
-  const portTypeNode = getPortTypeNode(definitionsNode);
-  if (!portTypeNode) {
-    throw new Error("No se encontr\xF3 el nodo portType en las definiciones del WSDL");
-  }
-  const operationNode = getOperationNode(portTypeNode);
-  if (!operationNode) {
-    throw new Error("No se encontr\xF3 el nodo operation en el portType");
-  }
+var getRequestTypeFromOperation = (operationNode, definitionsNode, schemaObject) => {
+  const operationName = getOperationName(operationNode);
   const inputNode = getInputNode(operationNode);
   if (!inputNode) {
-    throw new Error("No se encontr\xF3 el nodo input en la operaci\xF3n");
+    return null;
   }
   if (!inputNode.message) {
-    throw new Error("El nodo input no tiene el atributo message definido");
+    throw new Error(`El nodo input de la operaci\xF3n '${operationName}' no tiene el atributo message definido`);
   }
   const messageNode = getMessageNode(definitionsNode);
   if (!messageNode || messageNode.length === 0) {
@@ -22516,10 +22536,10 @@ var getRequestTypeFromDefinitions = (definitionsNode, schemaObject) => {
   }
   const partNode = getPartNode(inputMessageNode);
   if (!partNode) {
-    throw new Error("No se encontr\xF3 el nodo part en el mensaje de entrada");
+    throw new Error(`No se encontr\xF3 el nodo part en el mensaje de entrada de la operaci\xF3n '${operationName}'`);
   }
   if (!partNode.element) {
-    throw new Error("El nodo part no tiene el atributo element definido");
+    throw new Error(`El nodo part de la operaci\xF3n '${operationName}' no tiene el atributo element definido`);
   }
   const definitionsNamespaces = getNamespacesFromNode(definitionsNode);
   let elementName = partNode.element;
@@ -22538,35 +22558,13 @@ var getRequestTypeFromDefinitions = (definitionsNode, schemaObject) => {
   if (!requestType) {
     const availableTypes = Object.keys(schemaObject).filter((k) => k !== "$namespace").join(", ");
     throw new Error(
-      `No se encontr\xF3 el tipo de solicitud '${partNode.element}' (resuelto: '${resolvedElementName}') en el schema. Tipos disponibles: ${availableTypes || "ninguno"}`
+      `No se encontr\xF3 el tipo de solicitud '${partNode.element}' (resuelto: '${resolvedElementName}') para la operaci\xF3n '${operationName}'. Tipos disponibles: ${availableTypes || "ninguno"}`
     );
   }
-  return requestType;
-};
-var getNamespacesFromNode = (node) => {
-  const namespaces = /* @__PURE__ */ new Map();
-  if (node.targetNamespace !== void 0) {
-    namespaces.set("targetNamespace", node.targetNamespace);
-  }
-  for (const key of Object.keys(node)) {
-    const match = key.match(/xmlns:([a-zA-z0-9]*)/);
-    if (match !== null) {
-      const value = node[key];
-      namespaces.set(match[1], value);
-    }
-  }
-  return namespaces;
-};
-
-// src/util.ts
-var toPascalCase = (str) => {
-  return str.charAt(0).toUpperCase() + str.slice(1);
-};
-var toCamelCase2 = (str) => {
-  return str.charAt(0).toLowerCase() + str.slice(1);
+  return { operationName, requestType };
 };
 
-// src/template.ts
+// src/codegen/constants.ts
 var XML_SCHEMA_TYPES = {
   "string": "string",
   "int": "number",
@@ -22587,6 +22585,16 @@ var XML_SCHEMA_TYPES = {
 var NAMESPACE_KEY = "$namespace";
 var XML_SCHEMA_URI = "http://www.w3.org/2001/XMLSchema";
 var DEFAULT_OCCURS = "1";
+
+// src/util.ts
+var toPascalCase = (str) => {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+};
+var toCamelCase2 = (str) => {
+  return str.charAt(0).toLowerCase() + str.slice(1);
+};
+
+// src/codegen/utils.ts
 var namespacePrefixCache = /* @__PURE__ */ new Map();
 var stringSplitCache = /* @__PURE__ */ new Map();
 var filteredKeysCache = /* @__PURE__ */ new WeakMap();
@@ -22674,6 +22682,8 @@ function extractNamespacePrefix(namespace) {
   namespacePrefixCache.set(namespace, prefix);
   return prefix;
 }
+
+// src/codegen/namespaces.ts
 function extractAllNamespaceMappings(baseTypeName, baseTypeObject) {
   const tagsMapping = {};
   const prefixesMapping = {};
@@ -22812,6 +22822,8 @@ function shouldHavePrefix(elementObject) {
   }
   return false;
 }
+
+// src/codegen/xml-generator.ts
 function generateXmlPropertyCode(namespacesTypeMapping, baseNamespacePrefix, key, elementObject, parentKey = null, propertyPath = "", parentIsQualified = true) {
   const namespacePrefix = getNamespacePrefix(
     namespacesTypeMapping,
@@ -22896,13 +22908,12 @@ function generateXmlPropertyCode(namespacesTypeMapping, baseNamespacePrefix, key
 function generateXmlBodyCode(baseNamespacePrefix, namespacesTypeMapping, baseTypeName, baseTypeObject, propsInterfaceName) {
   const keys = getFilteredKeys(baseTypeObject);
   const baseTypeLocalName = extractLocalName(baseTypeName);
-  const initialPropertyPath = propsInterfaceName ? toCamelCase2(propsInterfaceName) : "";
   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 = initialPropertyPath && keyCamelCase === initialPropertyPath ? initialPropertyPath : initialPropertyPath ? `${initialPropertyPath}.${keyCamelCase}` : keyCamelCase;
+      const propertyPath = keyCamelCase;
       return generateXmlPropertyCode(
         namespacesTypeMapping,
         baseNamespacePrefix,
@@ -22920,6 +22931,8 @@ function generateXmlBodyCode(baseNamespacePrefix, namespacesTypeMapping, baseTyp
     ${properties}
 </${baseNamespacePrefix}.${baseTypeLocalName}>`;
 }
+
+// src/codegen/data-preparer.ts
 function prepareSimpleTypesData(typeObject, xmlSchemaUri) {
   return Object.keys(typeObject).filter((key) => {
     if (key === NAMESPACE_KEY) return false;
@@ -23042,14 +23055,12 @@ function extractNestedComplexTypes(typeObject, namespaceKey, xmlSchemaUri, visit
   }
   return result;
 }
-function prepareInterfacesData(requestTypeObject, namespaceKey, xmlSchemaUri, allTypesForInterfaces) {
+function prepareInterfacesData(requestTypeObject, namespaceKey, xmlSchemaUri, allTypesForInterfaces, simpleTypeNames) {
   const visited = /* @__PURE__ */ new Set();
   const interfaces = [];
   const allKeys = Object.keys(requestTypeObject).filter((k) => k !== namespaceKey);
   const extractionVisited = /* @__PURE__ */ new Set();
   const allComplexTypes = extractNestedComplexTypes(requestTypeObject, namespaceKey, xmlSchemaUri, extractionVisited);
-  if (allComplexTypes.length > 0) {
-  }
   const topLevelKeys = Object.keys(requestTypeObject).filter((key) => {
     if (key === namespaceKey) return false;
     const typeDef = requestTypeObject[key];
@@ -23062,17 +23073,21 @@ function prepareInterfacesData(requestTypeObject, namespaceKey, xmlSchemaUri, al
     }
     return false;
   });
-  if (topLevelKeys.length > 0) {
-  }
   for (const key of topLevelKeys) {
     const localName = extractLocalName(key);
     const interfaceName = toPascalCase(localName);
+    if (simpleTypeNames && simpleTypeNames.has(interfaceName)) {
+      continue;
+    }
     if (!visited.has(interfaceName) && !interfaces.some((i) => i.name === interfaceName)) {
       visited.add(interfaceName);
       interfaces.push(prepareInterfaceData(interfaceName, requestTypeObject[key], allTypesForInterfaces));
     }
   }
   for (const { interfaceName, typeObject } of allComplexTypes) {
+    if (simpleTypeNames && simpleTypeNames.has(interfaceName)) {
+      continue;
+    }
     if (!visited.has(interfaceName) && !interfaces.some((i) => i.name === interfaceName)) {
       visited.add(interfaceName);
       interfaces.push(prepareInterfaceData(interfaceName, { type: typeObject }, allTypesForInterfaces));
@@ -23099,6 +23114,9 @@ function prepareInterfacesData(requestTypeObject, namespaceKey, xmlSchemaUri, al
   for (const key of remainingKeys) {
     const localName = extractLocalName(key);
     const interfaceName = toPascalCase(localName);
+    if (simpleTypeNames && simpleTypeNames.has(interfaceName)) {
+      continue;
+    }
     if (!visited.has(interfaceName) && !interfaces.some((i) => i.name === interfaceName)) {
       visited.add(interfaceName);
       const typeDef = requestTypeObject[key];
@@ -23121,6 +23139,9 @@ function prepareInterfacesData(requestTypeObject, namespaceKey, xmlSchemaUri, al
     for (const key of missingKeys) {
       const localName = extractLocalName(key);
       const interfaceName = toPascalCase(localName);
+      if (simpleTypeNames && simpleTypeNames.has(interfaceName)) {
+        continue;
+      }
       if (!visited.has(interfaceName) && !interfaces.some((i) => i.name === interfaceName)) {
         visited.add(interfaceName);
         const typeDef = allTypesForInterfaces[key];
@@ -23141,8 +23162,6 @@ function prepareInterfacesData(requestTypeObject, namespaceKey, xmlSchemaUri, al
       }
     }
   }
-  if (interfaces.length > 0) {
-  }
   return interfaces;
 }
 function resolveTypeName(referencedType, propName2, allTypesForInterfaces) {
@@ -23185,7 +23204,6 @@ function resolveTypeName(referencedType, propName2, allTypesForInterfaces) {
     if (matchingTypeKey) {
       const resolvedName = toPascalCase(extractLocalName(matchingTypeKey));
       return resolvedName;
-    } else {
     }
   }
   const fallbackName = toPascalCase(propName2);
@@ -23194,8 +23212,12 @@ function resolveTypeName(referencedType, propName2, allTypesForInterfaces) {
 function prepareTemplateData(requestType, requestTypeObject, namespacesTagsMapping, namespacesPrefixMapping, namespacesTypeMapping, soapNamespaceURI, baseNamespacePrefix, allTypesForInterfaces) {
   const simpleTypes = prepareSimpleTypesData(requestTypeObject, XML_SCHEMA_URI);
   const propsInterface = preparePropsInterfaceData(requestType, requestTypeObject, allTypesForInterfaces);
-  const typesForInterfaces = allTypesForInterfaces || requestTypeObject;
-  const interfaces = prepareInterfacesData(typesForInterfaces, NAMESPACE_KEY, XML_SCHEMA_URI, allTypesForInterfaces);
+  const typesForInterfaces = requestTypeObject;
+  const simpleTypeNames = new Set(simpleTypes.map((st) => {
+    const localName = extractLocalName(st.name);
+    return toPascalCase(localName);
+  }));
+  const interfaces = prepareInterfacesData(typesForInterfaces, NAMESPACE_KEY, XML_SCHEMA_URI, allTypesForInterfaces, simpleTypeNames);
   const mainPropName = propsInterface.properties.length > 0 ? propsInterface.properties[0].name : void 0;
   const xmlBody = generateXmlBodyCode(baseNamespacePrefix, namespacesTypeMapping, requestType, requestTypeObject, mainPropName);
   const requestTypeLocalName = extractLocalName(requestType);
@@ -23329,7 +23351,7 @@ function compileTemplate(templateData) {
   }
   return compiledTemplate(templateData);
 }
-async function generateTsxFromWsdl(wsdlPath, outDir) {
+async function generateTsxFromWsdl(wsdlPath, outDir, operationName) {
   const wsdlRoot = await loadXml(wsdlPath);
   const definitionsNode = getDefinitionsNode(wsdlRoot);
   if (!definitionsNode) {
@@ -23411,101 +23433,193 @@ Schema [${i}] (targetNamespace: ${schemaNode.targetNamespace || "no definido"}):
     }
     throw new Error(errorMsg);
   }
-  const requestType = getRequestTypeFromDefinitions(definitionsNode, schemaObject);
-  if (!requestType) {
-    throw new Error("No se pudo determinar el tipo de solicitud desde las definiciones del WSDL");
-  }
-  const requestTypeObject = schemaObject[requestType];
-  if (!requestTypeObject) {
-    throw new Error(`No se encontr\xF3 el objeto de tipo ${requestType} en el schema`);
-  }
-  if (!requestTypeObject["$namespace"] && schemaObject["$namespace"]) {
-    requestTypeObject["$namespace"] = schemaObject["$namespace"];
-  }
-  if (!requestTypeObject["$namespace"]) {
-    throw new Error(`El tipo ${requestType} no tiene namespace definido`);
-  }
-  if (Object.keys(allComplexTypes).length > 0) {
-  }
-  const allTypesForInterfaces = { ...requestTypeObject };
-  const findReferencedTypes = (obj, found = /* @__PURE__ */ new Set(), depth = 0) => {
-    const indent = "  ".repeat(depth);
-    for (const [key, value] of Object.entries(obj)) {
-      if (key === "$namespace" || key === "$base") continue;
-      if (typeof value === "object" && value !== null && "type" in value) {
-        const typeValue = value.type;
-        if (typeof typeValue === "string") {
-          const matchingType = Object.keys(allComplexTypes).find(
-            (k) => k === typeValue || k.endsWith(":" + typeValue.split(":").pop()) || k.split(":").pop() === typeValue.split(":").pop()
-          );
-          if (matchingType && !found.has(matchingType)) {
-            found.add(matchingType);
-            if (allComplexTypes[matchingType]) {
-              findReferencedTypes(allComplexTypes[matchingType], found, depth + 1);
+  const portTypeNode = getPortTypeNode(definitionsNode);
+  if (!portTypeNode) {
+    throw new Error("No se encontr\xF3 el nodo portType en las definiciones del WSDL");
+  }
+  const operationNodes = getOperationNodes(portTypeNode);
+  if (operationNodes.length === 0) {
+    throw new Error("No se encontraron operaciones en el portType");
+  }
+  const operationsToProcess = operationName ? operationNodes.filter((op) => {
+    const opName = getOperationName(op);
+    return opName === operationName || opName.toLowerCase() === operationName.toLowerCase();
+  }) : operationNodes;
+  if (operationName && operationsToProcess.length === 0) {
+    const availableOps = operationNodes.map((op) => getOperationName(op)).join(", ");
+    throw new Error(
+      `No se encontr\xF3 la operaci\xF3n '${operationName}'. Operaciones disponibles: ${availableOps || "ninguna"}`
+    );
+  }
+  const processOperation = (operationNode) => {
+    const operationInfo = getRequestTypeFromOperation(operationNode, definitionsNode, schemaObject);
+    if (!operationInfo) {
+      const opName2 = getOperationName(operationNode);
+      console.warn(`\u26A0\uFE0F  Operaci\xF3n '${opName2}' no tiene input, se omite`);
+      return;
+    }
+    const { operationName: opName, requestType } = operationInfo;
+    const requestTypeObject = schemaObject[requestType];
+    if (!requestTypeObject) {
+      throw new Error(`No se encontr\xF3 el objeto de tipo ${requestType} en el schema para la operaci\xF3n '${opName}'`);
+    }
+    if (!requestTypeObject["$namespace"] && schemaObject["$namespace"]) {
+      requestTypeObject["$namespace"] = schemaObject["$namespace"];
+    }
+    if (!requestTypeObject["$namespace"]) {
+      throw new Error(`El tipo ${requestType} no tiene namespace definido para la operaci\xF3n '${opName}'`);
+    }
+    const allTypesForInterfaces = { ...requestTypeObject };
+    const findReferencedTypes = (obj, found = /* @__PURE__ */ new Set(), depth = 0) => {
+      for (const [key, value] of Object.entries(obj)) {
+        if (key === "$namespace" || key === "$base") continue;
+        if (typeof value === "object" && value !== null && "type" in value) {
+          const typeValue = value.type;
+          if (typeof typeValue === "string") {
+            const matchingType = Object.keys(allComplexTypes).find(
+              (k) => k === typeValue || k.endsWith(":" + typeValue.split(":").pop()) || k.split(":").pop() === typeValue.split(":").pop()
+            );
+            if (matchingType && !found.has(matchingType)) {
+              found.add(matchingType);
+              if (allComplexTypes[matchingType]) {
+                findReferencedTypes(allComplexTypes[matchingType], found, depth + 1);
+              }
+            } else if (matchingType && found.has(matchingType)) {
             }
-          } else if (matchingType && found.has(matchingType)) {
+          } else if (typeof typeValue === "object" && typeValue !== null) {
+            findReferencedTypes(typeValue, found, depth + 1);
           }
-        } else if (typeof typeValue === "object" && typeValue !== null) {
-          findReferencedTypes(typeValue, found, depth + 1);
         }
       }
+      return found;
+    };
+    const referencedTypeNames = findReferencedTypes(requestTypeObject);
+    for (const typeName of referencedTypeNames) {
+      if (!allTypesForInterfaces[typeName] && allComplexTypes[typeName]) {
+        allTypesForInterfaces[typeName] = allComplexTypes[typeName];
+      }
     }
-    return found;
+    const responseTypeName = `${opName}Response`;
+    const responseTypeKeys = Object.keys(allComplexTypes).filter((k) => {
+      const localName = extractLocalName(k);
+      return localName === responseTypeName || localName.toLowerCase() === responseTypeName.toLowerCase();
+    });
+    for (const responseTypeKey of responseTypeKeys) {
+      if (!allTypesForInterfaces[responseTypeKey] && allComplexTypes[responseTypeKey]) {
+        allTypesForInterfaces[responseTypeKey] = allComplexTypes[responseTypeKey];
+      }
+    }
+    const namespaceMappings = extractAllNamespaceMappings(requestType, requestTypeObject);
+    const namespacesTagsMapping = namespaceMappings.tagsMapping;
+    const namespacesPrefixMapping = namespaceMappings.prefixesMapping;
+    const namespacesTypeMapping = namespaceMappings.typesMapping;
+    const baseNamespacePrefix = namespacesTypeMapping[requestType].prefix;
+    const templateData = prepareTemplateData(
+      requestType,
+      requestTypeObject,
+      // Usar requestTypeObject original para propsInterface
+      namespacesTagsMapping,
+      namespacesPrefixMapping,
+      namespacesTypeMapping,
+      soapNamespaceURI,
+      baseNamespacePrefix,
+      allTypesForInterfaces
+      // Pasar allTypesForInterfaces como parámetro adicional para interfaces
+    );
+    const generatedCode = compileTemplate(templateData);
+    const typeNameForFile = opName;
+    if (!import_fs2.default.existsSync(outDir)) {
+      import_fs2.default.mkdirSync(outDir, { recursive: true });
+    }
+    const outputPath = import_path2.default.join(outDir, `${typeNameForFile}.tsx`);
+    import_fs2.default.writeFileSync(outputPath, generatedCode);
+    console.log(`\u2705 Archivo ${typeNameForFile}.tsx generado correctamente en ${outDir}`);
   };
-  const referencedTypeNames = findReferencedTypes(requestTypeObject);
-  if (referencedTypeNames.size > 0) {
-  }
-  for (const typeName of referencedTypeNames) {
-    if (!allTypesForInterfaces[typeName] && allComplexTypes[typeName]) {
-      allTypesForInterfaces[typeName] = allComplexTypes[typeName];
-    }
-  }
-  for (const [typeName, typeDef] of Object.entries(allComplexTypes)) {
-    if (!allTypesForInterfaces[typeName]) {
-      allTypesForInterfaces[typeName] = typeDef;
-    }
-  }
-  const namespaceMappings = extractAllNamespaceMappings(requestType, requestTypeObject);
-  const namespacesTagsMapping = namespaceMappings.tagsMapping;
-  const namespacesPrefixMapping = namespaceMappings.prefixesMapping;
-  const namespacesTypeMapping = namespaceMappings.typesMapping;
-  const baseNamespacePrefix = namespacesTypeMapping[requestType].prefix;
-  const templateData = prepareTemplateData(
-    requestType,
-    requestTypeObject,
-    // Usar requestTypeObject original para propsInterface
-    namespacesTagsMapping,
-    namespacesPrefixMapping,
-    namespacesTypeMapping,
-    soapNamespaceURI,
-    baseNamespacePrefix,
-    allTypesForInterfaces
-    // Pasar allTypesForInterfaces como parámetro adicional para interfaces
-  );
-  if (templateData.interfaces.length > 0) {
+  let generatedCount = 0;
+  for (const operationNode of operationsToProcess) {
+    try {
+      processOperation(operationNode);
+      generatedCount++;
+    } catch (error) {
+      const opName = getOperationName(operationNode);
+      console.error(`\u274C Error al procesar operaci\xF3n '${opName}':`, error.message);
+      if (operationName) {
+        throw error;
+      }
+    }
   }
-  const generatedCode = compileTemplate(templateData);
-  const typeNameForFile = requestType.includes(":") ? requestType.split(":").pop() : requestType;
-  if (!import_fs2.default.existsSync(outDir)) {
-    import_fs2.default.mkdirSync(outDir, { recursive: true });
+  if (generatedCount === 0) {
+    throw new Error("No se gener\xF3 ning\xFAn archivo. Verifica que las operaciones tengan input definido.");
   }
-  const outputPath = import_path2.default.join(outDir, `${typeNameForFile}.tsx`);
-  import_fs2.default.writeFileSync(outputPath, generatedCode);
-  console.log(`Archivo ${typeNameForFile}.tsx generado correctamente en ${outDir}`);
+  console.log(`
+\u2728 Proceso completado: ${generatedCount} archivo(s) generado(s)`);
 }
 
 // src/cli.ts
 console.log("wsdl2tsx CLI - Generador de c\xF3digo TSX desde WSDL");
-var WSDL_PATH = process.argv[2];
-var OUT_DIR = process.argv[3];
-if (!WSDL_PATH || !OUT_DIR) {
-  console.error("Uso: tsx cli/generate-tsx.ts <ruta-wsdl> <directorio-salida>");
-  process.exit(1);
+function parseArgs() {
+  const args = process.argv.slice(2);
+  let wsdlPath;
+  let outDir;
+  let operationName;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--operation" || arg === "-o") {
+      if (i + 1 < args.length && !args[i + 1].startsWith("-")) {
+        const value = args[i + 1];
+        if (!value || value.trim() === "") {
+          throw new Error(`El flag ${arg} requiere un valor no vac\xEDo`);
+        }
+        operationName = value;
+        i++;
+      } else {
+        throw new Error(`El flag ${arg} requiere un valor`);
+      }
+    } else if (arg.startsWith("--operation=")) {
+      const value = arg.split("=")[1];
+      if (!value || value.trim() === "") {
+        throw new Error("El flag --operation requiere un valor no vac\xEDo");
+      }
+      operationName = value;
+    } else if (arg.startsWith("-o=")) {
+      const value = arg.split("=")[1];
+      if (!value || value.trim() === "") {
+        throw new Error("El flag -o requiere un valor no vac\xEDo");
+      }
+      operationName = value;
+    } else if (!wsdlPath) {
+      wsdlPath = arg;
+    } else if (!outDir) {
+      outDir = arg;
+    } else {
+      if (!operationName) {
+        operationName = arg;
+      }
+    }
+  }
+  return { wsdlPath, outDir, operationName };
 }
-generateTsxFromWsdl(WSDL_PATH, OUT_DIR).catch((error) => {
-  console.error("Error al generar TSX:", error);
+try {
+  const { wsdlPath, outDir, operationName } = parseArgs();
+  if (!wsdlPath || !outDir) {
+    console.error("Uso: wsdl2tsx <ruta-wsdl> <directorio-salida> [--operation=<nombre>]");
+    console.error("  --operation, -o: Especifica el nombre de la operaci\xF3n a generar");
+    console.error("  Si no se especifica --operation, se generan todas las operaciones");
+    console.error("");
+    console.error("Ejemplos:");
+    console.error("  wsdl2tsx wsdl.xml output/");
+    console.error("  wsdl2tsx wsdl.xml output/ --operation=Add");
+    console.error("  wsdl2tsx wsdl.xml output/ -o Add");
+    process.exit(1);
+  }
+  generateTsxFromWsdl(wsdlPath, outDir, operationName).catch((error) => {
+    console.error("Error al generar TSX:", error);
+    process.exit(1);
+  });
+} catch (error) {
+  console.error("Error al parsear argumentos:", error.message);
   process.exit(1);
-});
+}
 /*! Bundled license information:
 
 mime-db/index.js:

package/package.json

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