@techspokes/typescript-wsdl-client 0.6.3 → 0.7.1

package/dist/util/tools.d.ts

@@ -1,20 +1,113 @@
+/**
+ * Utility Functions for TypeScript WSDL Client Generator
+ *
+ * This module provides a collection of helper functions used throughout the codebase
+ * for common tasks such as:
+ *
+ * - XML node processing and traversal
+ * - Name formatting and conversion between different cases
+ * - QName (qualified name) resolution with namespace handling
+ * - Array normalization and manipulation
+ * - Client name derivation from various sources
+ *
+ * These utilities create a consistent approach to handling common operations across
+ * the different modules of the generator.
+ */
 import type { CompiledCatalog } from "../compiler/schemaCompiler.js";
-/** Normalize a possibly-single value into an array. */
+/**
+ * Normalizes a possibly-single value into an array
+ *
+ * XML parsers often return single items directly and multiple items as arrays.
+ * This function ensures consistent array treatment regardless of the input.
+ *
+ * @template T - Type of the array elements
+ * @param {T|T[]|undefined|null} x - Value to normalize
+ * @returns {T[]} - Array containing the value(s) or empty array if null/undefined
+ */
 export declare function normalizeArray<T>(x: T | T[] | undefined | null): T[];
-/** Collect direct children whose LOCAL name matches (prefix-agnostic). */
+/**
+ * Collects direct children whose local name matches (prefix-agnostic)
+ *
+ * XML namespaces can cause the same element to appear with different prefixes.
+ * This function finds elements by their local name, ignoring namespace prefixes.
+ *
+ * @param {any} node - Parent XML node to search within
+ * @param {string} local - Local name to match (without namespace prefix)
+ * @returns {any[]} - Array of matching child nodes
+ */
 export declare function getChildrenWithLocalName(node: any, local: string): any[];
-/** Return the first direct child whose LOCAL name matches (prefix-agnostic). */
+/**
+ * Returns the first direct child whose local name matches (prefix-agnostic)
+ *
+ * Similar to getChildrenWithLocalName but returns only the first matching node.
+ * Useful for elements that should appear only once in a valid document.
+ *
+ * @param {any} node - Parent XML node to search within
+ * @param {string} local - Local name to match (without namespace prefix)
+ * @returns {any|undefined} - First matching child node or undefined if none found
+ */
 export declare function getFirstWithLocalName(node: any, local: string): any | undefined;
-/** Simple PascalCase helper used across emitters/parsers. */
+/**
+ * Converts a string to PascalCase format for TypeScript type names
+ *
+ * This function handles various input formats and produces valid TypeScript identifiers:
+ * - Converts separators (spaces, dashes, dots, etc.) to camelCase boundaries
+ * - Preserves underscores as literal characters
+ * - Removes invalid identifier characters
+ * - Ensures the result is a valid TypeScript identifier (not starting with numbers)
+ * - Avoids collision with TypeScript reserved keywords
+ *
+ * @param {string} s - Input string to convert to PascalCase
+ * @returns {string} - Valid TypeScript identifier in PascalCase
+ */
 export declare function pascal(s: string): string;
+/**
+ * Resolves a qualified name (QName) to its namespace and local parts
+ *
+ * XML uses qualified names (prefix:localName) to reference elements in namespaces.
+ * This function resolves the prefix to its full namespace URI using the provided prefixes map.
+ *
+ * @param {string} qname - Qualified name (e.g., "xs:string" or "myPrefix:elementName")
+ * @param {string} defaultNS - Default namespace to use if no prefix is present
+ * @param {Record<string, string>} prefixes - Map of namespace prefixes to full URIs
+ * @returns {{ns: string, local: string}} - Object containing namespace URI and local name
+ */
 export declare function resolveQName(qname: string, defaultNS: string, prefixes: Record<string, string>): {
     ns: string;
     local: string;
 };
-/** Derive a SOAP client class name from CompilerOptions and compiled catalog. */
+/**
+ * Derives a SOAP client class name from various sources
+ *
+ * This function uses a hierarchy of sources to determine an appropriate class name:
+ * 1. Explicit override from compiler options (highest priority)
+ * 2. Service name from the WSDL document
+ * 3. WSDL filename without extension
+ * 4. Default fallback name ("GeneratedSOAPClient")
+ *
+ * @param {CompiledCatalog} compiled - The compiled WSDL catalog
+ * @returns {string} - Appropriate class name for the generated SOAP client
+ */
 export declare function deriveClientName(compiled: CompiledCatalog): string;
-/** Explode a PascalCase string into its constituent segments. */
+/**
+ * Explodes a PascalCase string into its constituent segments
+ *
+ * This function breaks a PascalCase identifier into individual words
+ * by inserting underscores at camelCase transitions and then splitting.
+ *
+ * @param {string} s - PascalCase string to explode
+ * @returns {string[]} - Array of individual segments
+ */
 export declare function explodePascal(s: string): string[];
-/** Convert a PascalCase string to snake_case (lowercase + underscores). */
+/**
+ * Convert a PascalCase string to snake_case (lowercase + underscores).
+ *
+ * This function takes a PascalCase string, explodes it into its component segments,
+ * converts each segment to lowercase, and joins them with underscores to form a
+ * snake_case string.
+ *
+ * @param {string} s - PascalCase string to convert
+ * @returns {string} - snake_case version of the input string
+ */
 export declare function pascalToSnakeCase(s: string): string;
 //# sourceMappingURL=tools.d.ts.map

package/dist/util/tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../src/util/tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAErE,uDAAuD;AACvD,wBAAgB,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,SAAS,GAAG,IAAI,GAAG,CAAC,EAAE,CAGpE;AAED,0EAA0E;AAC1E,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,GAAG,GAAG,EAAE,CASxE;AAED,gFAAgF;AAChF,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,GAAG,GAAG,GAAG,SAAS,CAK/E;AAED,6DAA6D;AAC7D,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CA6BxC;AAED,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC/B;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAS/B;AAED,iFAAiF;AACjF,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,eAAe,GACxB,MAAM,CAWR;AAED,iEAAiE;AACjE,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAMjD;AAED,2EAA2E;AAC3E,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAInD"}
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../src/util/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,+BAA+B,CAAC;AAEnE;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,SAAS,GAAG,IAAI,GAAG,CAAC,EAAE,CAGpE;AAED;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,GAAG,GAAG,EAAE,CASxE;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,GAAG,GAAG,GAAG,SAAS,CAK/E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CA6BxC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC/B;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAS/B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,eAAe,GACxB,MAAM,CAWR;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAMjD;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAInD"}

package/dist/util/tools.js

@@ -1,10 +1,28 @@
-/** Normalize a possibly-single value into an array. */
+/**
+ * Normalizes a possibly-single value into an array
+ *
+ * XML parsers often return single items directly and multiple items as arrays.
+ * This function ensures consistent array treatment regardless of the input.
+ *
+ * @template T - Type of the array elements
+ * @param {T|T[]|undefined|null} x - Value to normalize
+ * @returns {T[]} - Array containing the value(s) or empty array if null/undefined
+ */
 export function normalizeArray(x) {
     if (x == null)
         return [];
     return Array.isArray(x) ? x : [x];
 }
-/** Collect direct children whose LOCAL name matches (prefix-agnostic). */
+/**
+ * Collects direct children whose local name matches (prefix-agnostic)
+ *
+ * XML namespaces can cause the same element to appear with different prefixes.
+ * This function finds elements by their local name, ignoring namespace prefixes.
+ *
+ * @param {any} node - Parent XML node to search within
+ * @param {string} local - Local name to match (without namespace prefix)
+ * @returns {any[]} - Array of matching child nodes
+ */
 export function getChildrenWithLocalName(node, local) {
     const out = [];
     for (const [k, v] of Object.entries(node || {})) {
@@ -15,7 +33,16 @@ export function getChildrenWithLocalName(node, local) {
     }
     return out;
 }
-/** Return the first direct child whose LOCAL name matches (prefix-agnostic). */
+/**
+ * Returns the first direct child whose local name matches (prefix-agnostic)
+ *
+ * Similar to getChildrenWithLocalName but returns only the first matching node.
+ * Useful for elements that should appear only once in a valid document.
+ *
+ * @param {any} node - Parent XML node to search within
+ * @param {string} local - Local name to match (without namespace prefix)
+ * @returns {any|undefined} - First matching child node or undefined if none found
+ */
 export function getFirstWithLocalName(node, local) {
     for (const [k, v] of Object.entries(node || {})) {
         if (k === local || k.endsWith(`:${local}`))
@@ -23,7 +50,19 @@ export function getFirstWithLocalName(node, local) {
     }
     return undefined;
 }
-/** Simple PascalCase helper used across emitters/parsers. */
+/**
+ * Converts a string to PascalCase format for TypeScript type names
+ *
+ * This function handles various input formats and produces valid TypeScript identifiers:
+ * - Converts separators (spaces, dashes, dots, etc.) to camelCase boundaries
+ * - Preserves underscores as literal characters
+ * - Removes invalid identifier characters
+ * - Ensures the result is a valid TypeScript identifier (not starting with numbers)
+ * - Avoids collision with TypeScript reserved keywords
+ *
+ * @param {string} s - Input string to convert to PascalCase
+ * @returns {string} - Valid TypeScript identifier in PascalCase
+ */
 export function pascal(s) {
     const raw = String(s ?? "");
     // Split on underscores to preserve them literally
@@ -55,6 +94,17 @@ export function pascal(s) {
     }
     return out;
 }
+/**
+ * Resolves a qualified name (QName) to its namespace and local parts
+ *
+ * XML uses qualified names (prefix:localName) to reference elements in namespaces.
+ * This function resolves the prefix to its full namespace URI using the provided prefixes map.
+ *
+ * @param {string} qname - Qualified name (e.g., "xs:string" or "myPrefix:elementName")
+ * @param {string} defaultNS - Default namespace to use if no prefix is present
+ * @param {Record<string, string>} prefixes - Map of namespace prefixes to full URIs
+ * @returns {{ns: string, local: string}} - Object containing namespace URI and local name
+ */
 export function resolveQName(qname, defaultNS, prefixes) {
     if (!qname)
         return { ns: defaultNS, local: "" };
@@ -66,7 +116,18 @@ export function resolveQName(qname, defaultNS, prefixes) {
     }
     return { ns: defaultNS, local: qname };
 }
-/** Derive a SOAP client class name from CompilerOptions and compiled catalog. */
+/**
+ * Derives a SOAP client class name from various sources
+ *
+ * This function uses a hierarchy of sources to determine an appropriate class name:
+ * 1. Explicit override from compiler options (highest priority)
+ * 2. Service name from the WSDL document
+ * 3. WSDL filename without extension
+ * 4. Default fallback name ("GeneratedSOAPClient")
+ *
+ * @param {CompiledCatalog} compiled - The compiled WSDL catalog
+ * @returns {string} - Appropriate class name for the generated SOAP client
+ */
 export function deriveClientName(compiled) {
     const overrideName = (compiled.options.clientName || "").trim();
     const svcName = compiled.serviceName ? pascal(compiled.serviceName) : "";
@@ -79,7 +140,15 @@ export function deriveClientName(compiled) {
     return overrideName
         || ((svcName || fileBase) ? `${svcName || fileBase}` : "GeneratedSOAPClient");
 }
-/** Explode a PascalCase string into its constituent segments. */
+/**
+ * Explodes a PascalCase string into its constituent segments
+ *
+ * This function breaks a PascalCase identifier into individual words
+ * by inserting underscores at camelCase transitions and then splitting.
+ *
+ * @param {string} s - PascalCase string to explode
+ * @returns {string[]} - Array of individual segments
+ */
 export function explodePascal(s) {
     // insert underscores between camel‐transitions
     const withUnderscores = String(s)
@@ -87,7 +156,16 @@ export function explodePascal(s) {
         .replace(/([A-Z])([A-Z][a-z])/g, '$1_$2');
     return withUnderscores.split('_').filter(Boolean);
 }
-/** Convert a PascalCase string to snake_case (lowercase + underscores). */
+/**
+ * Convert a PascalCase string to snake_case (lowercase + underscores).
+ *
+ * This function takes a PascalCase string, explodes it into its component segments,
+ * converts each segment to lowercase, and joins them with underscores to form a
+ * snake_case string.
+ *
+ * @param {string} s - PascalCase string to convert
+ * @returns {string} - snake_case version of the input string
+ */
 export function pascalToSnakeCase(s) {
     return explodePascal(s)
         .map(seg => seg.toLowerCase())

package/dist/xsd/primitives.d.ts

@@ -1,8 +1,41 @@
+/**
+ * XSD to TypeScript Primitive Type Mapping
+ *
+ * This module defines how XML Schema (XSD) primitive types are mapped to TypeScript types.
+ * It provides a configurable mapping system with safe defaults that prioritizes
+ * data integrity over convenience:
+ *
+ * Key design decisions:
+ * - 64-bit integers (long/unsignedLong) default to string to prevent overflow in JavaScript number
+ * - Arbitrary-precision decimal types default to string to prevent loss of precision
+ * - Date/time types default to string (no automatic Date parsing/conversion)
+ * - Configurable options allow users to override defaults when appropriate for their use case
+ */
+/**
+ * Configuration options for XSD primitive type mapping
+ *
+ * @interface PrimitiveOptions
+ * @property {string} [int64As] - How to map xs:long/xs:unsignedLong (default: "string")
+ * @property {string} [bigIntegerAs] - How to map xs:integer family (default: "string")
+ * @property {string} [decimalAs] - How to map xs:decimal (default: "string")
+ * @property {string} [dateAs] - How to map xs:date/xs:time family (default: "string")
+ */
 export type PrimitiveOptions = {
     int64As?: "string" | "number" | "bigint";
     bigIntegerAs?: "string" | "number";
     decimalAs?: "string" | "number";
     dateAs?: "string" | "Date";
 };
+/**
+ * Maps an XSD QName to the corresponding TypeScript primitive type
+ *
+ * This function is the main entry point for determining the TypeScript type
+ * corresponding to an XSD primitive type. It uses the local part of the QName
+ * and the configured mapping options to return the correct TypeScript type.
+ *
+ * @param {string} xsdQName - The XSD QName to map (e.g., "xs:int")
+ * @param {PrimitiveOptions} [options] - Optional custom mapping options
+ * @returns {string} - The corresponding TypeScript primitive type
+ */
 export declare function xsdToTsPrimitive(xsdQName: string, options?: PrimitiveOptions): string;
 //# sourceMappingURL=primitives.d.ts.map

package/dist/xsd/primitives.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"primitives.d.ts","sourceRoot":"","sources":["../../src/xsd/primitives.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,gBAAgB,GAAG;IAC3B,OAAO,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACzC,YAAY,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;IACnC,SAAS,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAChC,MAAM,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAC;CAC9B,CAAC;AA+EF,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAwCrF"}
+{"version":3,"file":"primitives.d.ts","sourceRoot":"","sources":["../../src/xsd/primitives.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACzC,YAAY,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;IACnC,SAAS,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAChC,MAAM,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAC;CAC5B,CAAC;AAgHF;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAyCrF"}

package/dist/xsd/primitives.js

@@ -1,15 +1,39 @@
-// Centralized XSD → TypeScript primitive mapping with safe defaults.
-// Rationale:
-// - 64-bit integers (long/unsignedLong) can overflow JS number → default to string
-// - Arbitrary-precision decimal (money) may lose precision in JS number → default to string
-// - Dates/times stay as string by default (no runtime Date parsing in a generator)
+/**
+ * XSD to TypeScript Primitive Type Mapping
+ *
+ * This module defines how XML Schema (XSD) primitive types are mapped to TypeScript types.
+ * It provides a configurable mapping system with safe defaults that prioritizes
+ * data integrity over convenience:
+ *
+ * Key design decisions:
+ * - 64-bit integers (long/unsignedLong) default to string to prevent overflow in JavaScript number
+ * - Arbitrary-precision decimal types default to string to prevent loss of precision
+ * - Date/time types default to string (no automatic Date parsing/conversion)
+ * - Configurable options allow users to override defaults when appropriate for their use case
+ */
+/**
+ * Default primitive mapping options that prioritize data integrity over convenience
+ *
+ * These defaults ensure that no data is lost in the TypeScript representation, even
+ * for edge cases like very large integers or high-precision decimals.
+ */
 const DEFAULTS = {
     int64As: "string",
     bigIntegerAs: "string",
     decimalAs: "string",
     dateAs: "string",
 };
-// Helper to choose ts type for integer families depending on magnitude
+/**
+ * Determines the appropriate TypeScript type for XSD integer families
+ *
+ * This function categorizes integer types by their potential size range:
+ * - 64-bit or arbitrary-precision integers use the configured type (default: string)
+ * - 32-bit or smaller integers use the native number type
+ *
+ * @param {string} local - Local name of the XSD type (e.g., "int", "long", "integer")
+ * @param {Required<PrimitiveOptions>} opts - Primitive mapping options
+ * @returns {string} - Appropriate TypeScript type for the integer type
+ */
 function intFamily(local, opts) {
     // 64-bit or unbounded families → configurable
     const int64 = new Set(["long", "unsignedLong"]);
@@ -34,14 +58,28 @@ function intFamily(local, opts) {
         return "number";
     return "number";
 }
+/**
+ * Determines the appropriate TypeScript type for XSD decimal types
+ *
+ * @param {string} local - Local name of the XSD type (e.g., "decimal")
+ * @param {Required<PrimitiveOptions>} opts - Primitive mapping options
+ * @returns {string} - Appropriate TypeScript type for the decimal type
+ */
 function decimalFamily(local, opts) {
     // xs:decimal and derived decimals (if any) → configurable
     if (local === "decimal")
         return opts.decimalAs;
     return "number";
 }
+/**
+ * Determines the appropriate TypeScript type for XSD date/time types
+ *
+ * @param {string} local - Local name of the XSD type (e.g., "date", "dateTime")
+ * @param {Required<PrimitiveOptions>} opts - Primitive mapping options
+ * @returns {string} - Appropriate TypeScript type for the date/time type
+ */
 function dateFamily(local, opts) {
-    // You can choose "Date", but generator won’t parse at runtime; it’s just type-level.
+    // You can choose "Date", but generator won't parse at runtime; it's just type-level.
     const s = opts.dateAs;
     switch (local) {
         case "date":
@@ -61,6 +99,9 @@ function dateFamily(local, opts) {
             return "string";
     }
 }
+/**
+ * Set of XSD types that map to string in TypeScript
+ */
 const STRING_LIKE = new Set([
     "string",
     "normalizedString",
@@ -77,6 +118,17 @@ const STRING_LIKE = new Set([
     "hexBinary",
     "base64Binary", // could be "string" or a branded type
 ]);
+/**
+ * Maps an XSD QName to the corresponding TypeScript primitive type
+ *
+ * This function is the main entry point for determining the TypeScript type
+ * corresponding to an XSD primitive type. It uses the local part of the QName
+ * and the configured mapping options to return the correct TypeScript type.
+ *
+ * @param {string} xsdQName - The XSD QName to map (e.g., "xs:int")
+ * @param {PrimitiveOptions} [options] - Optional custom mapping options
+ * @returns {string} - The corresponding TypeScript primitive type
+ */
 export function xsdToTsPrimitive(xsdQName, options) {
     const opts = { ...DEFAULTS, ...(options || {}) };
     // Expect formats like "xs:int". Fall back to string if unknown.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@techspokes/typescript-wsdl-client",
-  "version": "0.6.3",
+  "version": "0.7.1",
   "description": "TypeScript WSDL → SOAP client generator with full xs:attribute support, complex types, sequences, inheritance, and namespace-collision merging.",
   "keywords": [
     "wsdl",
@@ -47,6 +47,7 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "clean": "rimraf dist",
+    "clean:tmp": "rimraf tmp",
     "dev": "tsx src/cli.ts",
     "watch": "tsx watch src/cli.ts",
     "typecheck": "tsc --noEmit",
@@ -54,9 +55,11 @@
     "test": "exit 0",
     "smoke": "tsx src/cli.ts --help",
     "smoke:gen": "rimraf tmp && tsx src/cli.ts --wsdl examples/minimal/weather.wsdl --out tmp && tsc -p tsconfig.smoke.json",
-    "ci": "npm run build && npm run typecheck && npm run smoke && npm run smoke:gen"
+    "smoke:pipeline": "tsx src/cli.ts pipeline --wsdl examples/minimal/weather.wsdl --out tmp --clean --format both --tag-style service --openapi-out tmp/openapi --servers https://example.com/api",
+    "ci": "npm run build && npm run typecheck && npm run smoke && npm run smoke:gen && npm run smoke:pipeline"
   },
   "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
     "@types/node": "^24.3.0",
     "@types/yargs": "^17.0.33",
     "rimraf": "^6.0.0",
@@ -64,7 +67,9 @@
     "typescript": "^5.6.3"
   },
   "dependencies": {
+    "@apidevtools/swagger-parser": "^10.0.3",
     "fast-xml-parser": "^5.2.5",
+    "js-yaml": "^4.1.0",
     "soap": "^1.3.0",
     "yargs": "^18.0.0"
   },