@techspokes/typescript-wsdl-client 0.1.8 → 0.2.0

package/README.md

@@ -23,7 +23,7 @@ Reads WSDL/XSD (with imports) and emits a small, typed client you can compile in
 * Deterministic metadata (`ATTR_SPEC`, `PROP_META`) for clean JSON ⇄ SOAP mapping
 * ESM **and** CommonJS friendly output
 
-Vendor: **[TechSpokes](https://www.techspokes.com)** · Contact: **[contact@techspokes.com](mailto:contact@techspokes.com)**
+Vendor: **[TechSpokes](https://www.techspokes.com)** · Contact: **[contact page](https://www.techspokes.com/contact/)"**
 Maintainer: **Serge Liatko** ([@sergeliatko](https://github.com/sergeliatko)) · GitHub org: [@techspokes](https://github.com/techspokes)
 
 ---
@@ -76,37 +76,53 @@ console.log(rs);
 wsdl-tsc --wsdl <path-or-url> --out <dir> [options]
 ```
 
+### Local development
+
+By default, `npx wsdl-tsc` invokes the published npm version. To run the CLI from your local source (with your latest changes), use one of these approaches:
+
+```bash
+# Directly via tsx (requires tsx in devDependencies)
+npx tsx src/cli.ts --wsdl <path-or-url> --out <dir> [options]
+
+# Via npm script
+git clone ... then:
+npm install
+git checkout <branch>
+npm run dev -- --wsdl <path-or-url> --out <dir> [options]
+
+# Using npm link to symlink your working copy
+npm link
+wsdl-tsc --wsdl <path-or-url> --out <dir> [options]
+```
+
 **Required**
 
 * `--wsdl` — WSDL path or URL
 * `--out` — output directory (created if missing)
 
-**Useful options**
+**Options**
 
-* `--imports js|ts|bare` (default: `js`)
-  How intra-generated imports are written:
-
-    * `js` → `./file.js` (best for ESM/NodeNext apps)
-    * `ts` → `./file.ts` (use with `allowImportingTsExtensions`)
-    * `bare` → `./file` (nice for CommonJS builds)
-* `--ops-ts` (default: `true`)
-  Emit `operations.ts` instead of JSON.
+| Flag                | Type      | Choices                        | Default      | Description                                                      |
+|---------------------|-----------|--------------------------------|--------------|------------------------------------------------------------------|
+| `--imports`         | string    | js, ts, bare                   | js           | Intra-generated import specifiers: '.js', '.ts', or bare         |
+| `--ops-ts`          | boolean   | true, false                    | true         | Emit `operations.ts` instead of JSON                             |
+| `--attributes-key`  | string    | any                            | $attributes  | Key used by runtime marshaller for XML attributes                |
+| `--int64-as`        | string    | string, number, bigint         | string       | How to map xs:long/xs:unsignedLong                               |
+| `--bigint-as`       | string    | string, number                 | string       | How to map xs:integer family (positive/nonNegative/etc.)         |
+| `--decimal-as`      | string    | string, number                 | string       | How to map xs:decimal (money/precision)                          |
+| `--date-as`         | string    | string, Date                   | string       | How to map date/time/duration types                              |
 
 **Primitive mapping (safe defaults)**
 
-* `--int64-as string|number|bigint` (default `string`) — `xs:long`, `xs:unsignedLong`
-* `--bigint-as string|number` (default `string`) — `xs:integer` family
-* `--decimal-as string|number` (default `string`) — `xs:decimal` (money/precision)
-* `--date-as string|Date` (default `string`) — `xs:date`, `xs:dateTime`, `xs:time`, `g*`, durations
-
-**Other**
+Defaults are **string-first** to avoid precision & timezone surprises:
 
-* `--attributes-key <string>` (default: `$attributes`)
-  The key used by the runtime marshaller when serializing attributes.
+* `xs:decimal` → `string` (money/precision safe)
+* 64-bit integers → `string` (you can opt into `bigint` or `number`)
+* dates/times → `string` (transport-friendly, no implicit tz conversion)
 
----
+Override these defaults using the CLI flags above as needed for your use case.
 
-## What gets generated
+# What gets generated
 
 ```
 <out>/

package/dist/cli.js

@@ -78,6 +78,10 @@ const compiled = compileCatalog(catalog, {
         dateAs: argv["date-as"],
     },
 });
+// Report counts of types and operations for user visibility
+console.log(`Schemas discovered: ${catalog.schemas.length}`);
+console.log(`Compiled types: ${compiled.types.length}`);
+console.log(`Operations: ${compiled.operations.length}`);
 // Emit files
 const importExt = argv.imports === "js" ? ".js" : argv.imports === "ts" ? ".ts" : "";
 emitTypes(path.join(outDir, "types.ts"), compiled);

package/dist/compiler/schemaCompiler.d.ts

@@ -46,5 +46,15 @@ export type CompiledCatalog = {
     }>;
     wsdlTargetNS: string;
 };
+/**
+ * Compile a WSDL catalog into an internal representation (CompiledCatalog).
+ * Steps:
+ * 1. Collect and index complexType, simpleType, and element definitions across all schemas.
+ * 2. Recursively compile each named type to a TS interface or alias, handling inheritance,
+ *    inline definitions, and XSD primitives.
+ * 3. Build metadata maps for runtime marshalling (attributes, children, nillable, occurrence).
+ * 4. Extract WSDL operations: pick the appropriate SOAP binding (v1.1 or v1.2), resolve its
+ *    portType reference, then enumerate operations and their soapAction URIs.
+ */
 export declare function compileCatalog(cat: WsdlCatalog, _opts: CompilerOptions): CompiledCatalog;
 //# sourceMappingURL=schemaCompiler.d.ts.map

package/dist/compiler/schemaCompiler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemaCompiler.d.ts","sourceRoot":"","sources":["../../src/compiler/schemaCompiler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAU3D,MAAM,MAAM,KAAK,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAElD,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,KAAK,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,GAAG,CAAC,EAAE,UAAU,GAAG,UAAU,CAAC;QAC9B,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC,CAAC;IACH,KAAK,EAAE,KAAK,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,GAAG,WAAW,CAAC;QAC1B,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC,CAAC;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,IAAI,EAAE;QACJ,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;QACnC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;QAClD,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;KAC/C,CAAC;IACF,UAAU,EAAE,KAAK,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC;QACb,UAAU,EAAE,MAAM,CAAC;QACnB,YAAY,CAAC,EAAE,KAAK,CAAC;QACrB,aAAa,CAAC,EAAE,KAAK,CAAC;KACvB,CAAC,CAAC;IACH,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAoBF,wBAAgB,cAAc,CAAC,GAAG,EAAE,WAAW,EAAE,KAAK,EAAE,eAAe,GAAG,eAAe,CA+XxF"}
+{"version":3,"file":"schemaCompiler.d.ts","sourceRoot":"","sources":["../../src/compiler/schemaCompiler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAU3D,MAAM,MAAM,KAAK,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAElD,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,KAAK,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,GAAG,CAAC,EAAE,UAAU,GAAG,UAAU,CAAC;QAC9B,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC,CAAC;IACH,KAAK,EAAE,KAAK,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,GAAG,WAAW,CAAC;QAC1B,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC,CAAC;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,IAAI,EAAE;QACJ,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;QACnC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;QAClD,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;KAC/C,CAAC;IACF,UAAU,EAAE,KAAK,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC;QACb,UAAU,EAAE,MAAM,CAAC;QACnB,YAAY,CAAC,EAAE,KAAK,CAAC;QACrB,aAAa,CAAC,EAAE,KAAK,CAAC;KACvB,CAAC,CAAC;IACH,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAsBF;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,WAAW,EAAE,KAAK,EAAE,eAAe,GAAG,eAAe,CA+exF"}

package/dist/compiler/schemaCompiler.js

@@ -8,10 +8,21 @@ function qkey(q) {
 function makeInlineTypeName(parentTypeName, propName, _max) {
     const base = pascal(parentTypeName || "AnonParent");
     const prop = pascal(propName || "");
-    if (prop)
+    if (prop) {
         return prop;
+    }
     return `${base}Anon`;
 }
+/**
+ * Compile a WSDL catalog into an internal representation (CompiledCatalog).
+ * Steps:
+ * 1. Collect and index complexType, simpleType, and element definitions across all schemas.
+ * 2. Recursively compile each named type to a TS interface or alias, handling inheritance,
+ *    inline definitions, and XSD primitives.
+ * 3. Build metadata maps for runtime marshalling (attributes, children, nillable, occurrence).
+ * 4. Extract WSDL operations: pick the appropriate SOAP binding (v1.1 or v1.2), resolve its
+ *    portType reference, then enumerate operations and their soapAction URIs.
+ */
 export function compileCatalog(cat, _opts) {
     // symbol tables discovered across all schemas
     const complexTypes = new Map();
@@ -19,20 +30,25 @@ export function compileCatalog(cat, _opts) {
     const elements = new Map();
     for (const s of cat.schemas) {
         const tns = s.targetNS;
+        // merge WSDL-level prefixes with schema-level (schema wins)
+        const mergedPrefixes = { ...cat.prefixMap, ...s.prefixes };
         for (const n of getChildrenWithLocalName(s.xml, "complexType")) {
             const name = n["@_name"];
-            if (name)
-                complexTypes.set(qkey({ ns: tns, local: name }), { node: n, tns, prefixes: s.prefixes });
+            if (name) {
+                complexTypes.set(qkey({ ns: tns, local: name }), { node: n, tns, prefixes: mergedPrefixes });
+            }
         }
         for (const n of getChildrenWithLocalName(s.xml, "simpleType")) {
             const name = n["@_name"];
-            if (name)
-                simpleTypes.set(qkey({ ns: tns, local: name }), { node: n, tns, prefixes: s.prefixes });
+            if (name) {
+                simpleTypes.set(qkey({ ns: tns, local: name }), { node: n, tns, prefixes: mergedPrefixes });
+            }
         }
         for (const n of getChildrenWithLocalName(s.xml, "element")) {
             const name = n["@_name"];
-            if (name)
-                elements.set(qkey({ ns: tns, local: name }), { node: n, tns, prefixes: s.prefixes });
+            if (name) {
+                elements.set(qkey({ ns: tns, local: name }), { node: n, tns, prefixes: mergedPrefixes });
+            }
         }
     }
     // outputs & state
@@ -72,8 +88,9 @@ export function compileCatalog(cat, _opts) {
     function getOrCompileAlias(name, sNode, schemaNS, prefixes) {
         const key = `${schemaNS}|${name}`;
         const present = aliasMap.get(key);
-        if (present)
+        if (present) {
             return present;
+        }
         const { tsType, declared, jsdoc } = compileSimpleTypeNode(sNode, schemaNS, prefixes);
         const alias = { name: pascal(name), ns: schemaNS, tsType, declared, jsdoc };
         aliasMap.set(key, alias);
@@ -81,8 +98,9 @@ export function compileCatalog(cat, _opts) {
     }
     /** Resolve a QName reference to a TS type; compile targets if needed. */
     function resolveTypeRef(q, schemaNS, prefixes) {
-        if (!q.ns)
+        if (!q.ns) {
             q = resolveQName(q.local, schemaNS, prefixes);
+        }
         if (q.ns === XS) {
             const label = `xs:${q.local}`;
             return { tsType: xsdToTsPrimitive(label, _opts?.primitive), declared: label };
@@ -109,16 +127,20 @@ export function compileCatalog(cat, _opts) {
         const outName = pascal(name);
         const key = `${schemaNS}|${outName}`;
         const present = compiledMap.get(key);
-        if (present)
+        if (present) {
             return present;
+        }
         if (inProgress.has(key)) {
             // minimal cycle break
             return { name: outName, ns: schemaNS, attrs: [], elems: [] };
         }
         inProgress.add(key);
+        // mergeAttrs: combine base attributes with local ones, overriding duplicates by name
         const mergeAttrs = (into, list) => {
+            // build index of existing attribute names
             const idx = new Map();
             into.forEach((a, i) => idx.set(a.name, i));
+            // for each new attr, add or override existing
             for (const a of list) {
                 const pos = idx.get(a.name);
                 if (pos == null) {
@@ -126,10 +148,11 @@ export function compileCatalog(cat, _opts) {
                     into.push(a);
                 }
                 else {
-                    into[pos] = a; // override
+                    into[pos] = a; // override existing attribute details
                 }
             }
         };
+        // mergeElems: combine base elements (particles) with local ones, preserving unique names and overriding duplicates
         const mergeElems = (into, list) => {
             const idx = new Map();
             into.forEach((e, i) => idx.set(e.name, i));
@@ -140,41 +163,39 @@ export function compileCatalog(cat, _opts) {
                     into.push(e);
                 }
                 else {
-                    into[pos] = e; // override
+                    into[pos] = e; // override existing element details
                 }
             }
         };
+        // collectAttributes: read all <attribute> children, handle inline simpleType vs named type references
+        // maps each attribute to a TS type, tracks required vs optional via @use, and records the original declared XSD type
         const collectAttributes = (node) => {
             const out = [];
             const attrs = getChildrenWithLocalName(node, "attribute");
             for (const a of attrs) {
                 const an = a["@_name"];
-                if (!an)
+                if (!an) {
                     continue;
+                }
                 const inlineSimple = getFirstWithLocalName(a, "simpleType");
                 if (inlineSimple) {
+                    // inline enumeration or restriction inside attribute
                     const r = compileSimpleTypeNode(inlineSimple, schemaNS, prefixes);
-                    out.push({
-                        name: an,
-                        tsType: r.tsType,
-                        use: a["@_use"] === "required" ? "required" : "optional",
-                        declaredType: r.declared,
-                    });
+                    out.push({ name: an, tsType: r.tsType, use: a["@_use"] === "required" ? "required" : "optional", declaredType: r.declared });
                 }
                 else {
+                    // named type or default xs:string
                     const t = a["@_type"];
                     const q = t ? resolveQName(t, schemaNS, prefixes) : { ns: XS, local: "string" };
                     const r = resolveTypeRef(q, schemaNS, prefixes);
-                    out.push({
-                        name: an,
-                        tsType: r.tsType,
-                        use: a["@_use"] === "required" ? "required" : "optional",
-                        declaredType: r.declared,
-                    });
+                    out.push({ name: an, tsType: r.tsType, use: a["@_use"] === "required" ? "required" : "optional", declaredType: r.declared });
                 }
             }
             return out;
         };
+        // collectParticles: parse compositor elements (sequence, all, choice), extract <element> definitions
+        // handles inline complex/simple definitions by generating a unique inline type name
+        // resolves type refs or @ref, applies min/max occurrence and nillable flags
         const collectParticles = (ownerTypeName, node) => {
             const out = [];
             const groups = [
@@ -185,52 +206,33 @@ export function compileCatalog(cat, _opts) {
             for (const grp of groups) {
                 for (const e of getChildrenWithLocalName(grp, "element")) {
                     const nameOrRef = e["@_name"] || e["@_ref"];
-                    if (!nameOrRef)
+                    if (!nameOrRef) {
                         continue;
-                    let propName = e["@_name"] || undefined;
+                    }
+                    const propName = e["@_name"];
                     const min = e["@_minOccurs"] ? Number(e["@_minOccurs"]) : 1;
                     const maxAttr = e["@_maxOccurs"];
                     const max = maxAttr === "unbounded" ? "unbounded" : maxAttr ? Number(maxAttr) : 1;
                     const nillable = e["@_nillable"] === "true";
-                    // inline complex/simple types
+                    // inline complexType: create a nested interface with a generated name
                     const inlineComplex = getFirstWithLocalName(e, "complexType");
                     const inlineSimple = getFirstWithLocalName(e, "simpleType");
                     if (inlineComplex) {
                         const inlineName = makeInlineTypeName(ownerTypeName, propName || nameOrRef, max);
                         const rec = getOrCompileComplex(inlineName, inlineComplex, schemaNS, prefixes);
-                        out.push({
-                            name: propName || nameOrRef,
-                            tsType: rec.name,
-                            min,
-                            max,
-                            nillable,
-                            declaredType: `{${schemaNS}}${rec.name}`,
-                        });
+                        out.push({ name: propName || nameOrRef, tsType: rec.name, min, max, nillable, declaredType: `{${schemaNS}}${rec.name}` });
                     }
                     else if (inlineSimple) {
+                        // inline simpleType (e.g., list or enumeration)
                         const r = compileSimpleTypeNode(inlineSimple, schemaNS, prefixes);
-                        out.push({
-                            name: propName || nameOrRef,
-                            tsType: r.tsType,
-                            min,
-                            max,
-                            nillable,
-                            declaredType: r.declared,
-                        });
+                        out.push({ name: propName || nameOrRef, tsType: r.tsType, min, max, nillable, declaredType: r.declared });
                     }
                     else {
-                        // normal ref/type
+                        // named type or ref: resolve via QName
                         const t = e["@_type"] || e["@_ref"];
                         const q = t ? resolveQName(t, schemaNS, prefixes) : { ns: XS, local: "string" };
                         const r = resolveTypeRef(q, schemaNS, prefixes);
-                        out.push({
-                            name: propName || nameOrRef,
-                            tsType: r.tsType,
-                            min,
-                            max,
-                            nillable,
-                            declaredType: r.declared,
-                        });
+                        out.push({ name: propName || nameOrRef, tsType: r.tsType, min, max, nillable, declaredType: r.declared });
                     }
                 }
             }
@@ -277,7 +279,7 @@ export function compileCatalog(cat, _opts) {
                 if (baseAttr) {
                     r = resolveTypeRef(resolveQName(baseAttr, schemaNS, prefixes), schemaNS, prefixes);
                 }
-                // 👇👇 text node is modeled as "$value" (not "value")
+                // text node is modeled as "$value" (not "value")
                 mergeElems(elems, [{
                         name: "$value",
                         tsType: r.tsType,
@@ -292,10 +294,12 @@ export function compileCatalog(cat, _opts) {
                 inProgress.delete(key);
                 return result;
             };
-            if (ext)
+            if (ext) {
                 return model(ext);
-            if (res)
+            }
+            if (res) {
                 return model(res);
+            }
         }
         // Attributes + particles
         mergeAttrs(attrs, collectAttributes(cnode));
@@ -305,13 +309,84 @@ export function compileCatalog(cat, _opts) {
         inProgress.delete(key);
         return result;
     }
+    // Helper: compile a global element into a surface type (wrapper)
+    function compileElementAsType(name, enode, schemaNS, prefixes) {
+        const outName = pascal(name);
+        const key = `${schemaNS}|${outName}`;
+        const present = compiledMap.get(key);
+        if (present)
+            return present;
+        const inlineComplex = getFirstWithLocalName(enode, "complexType");
+        if (inlineComplex) {
+            return getOrCompileComplex(name, inlineComplex, schemaNS, prefixes);
+        }
+        const inlineSimple = getFirstWithLocalName(enode, "simpleType");
+        if (inlineSimple) {
+            const r = compileSimpleTypeNode(inlineSimple, schemaNS, prefixes);
+            const t = {
+                name: outName,
+                ns: schemaNS,
+                attrs: [],
+                elems: [{ name: "$value", tsType: r.tsType, min: 0, max: 1, nillable: false, declaredType: r.declared }],
+            };
+            compiledMap.set(key, t);
+            return t;
+        }
+        const tAttr = enode["@_type"];
+        if (tAttr) {
+            const q = resolveQName(tAttr, schemaNS, prefixes);
+            // If references a simple type → $value; if complex type → copy members
+            if (q.ns === XS) {
+                const label = `xs:${q.local}`;
+                const t = {
+                    name: outName,
+                    ns: schemaNS,
+                    attrs: [],
+                    elems: [{ name: "$value", tsType: xsdToTsPrimitive(label, _opts?.primitive), min: 0, max: 1, nillable: false, declaredType: label }],
+                };
+                compiledMap.set(key, t);
+                return t;
+            }
+            const baseRec = complexTypes.get(qkey(q));
+            if (baseRec) {
+                const base = getOrCompileComplex(baseRec.node["@_name"], baseRec.node, baseRec.tns, baseRec.prefixes);
+                const t = { name: outName, ns: schemaNS, attrs: [...(base.attrs || [])], elems: [...(base.elems || [])] };
+                compiledMap.set(key, t);
+                return t;
+            }
+            const srec = simpleTypes.get(qkey(q));
+            if (srec) {
+                const a = getOrCompileAlias(q.local, srec.node, srec.tns, srec.prefixes);
+                const t = {
+                    name: outName,
+                    ns: schemaNS,
+                    attrs: [],
+                    elems: [{ name: "$value", tsType: a.name, min: 0, max: 1, nillable: false, declaredType: `{${a.ns}}${q.local}` }],
+                };
+                compiledMap.set(key, t);
+                return t;
+            }
+        }
+        // default empty wrapper
+        const t = { name: outName, ns: schemaNS, attrs: [], elems: [] };
+        compiledMap.set(key, t);
+        return t;
+    }
     // compile every discovered complex type
     for (const rec of complexTypes.values()) {
         const name = rec.node["@_name"];
-        if (!name)
+        if (!name) {
             continue;
+        }
         getOrCompileComplex(name, rec.node, rec.tns, rec.prefixes);
     }
+    // compile global element wrappers, so metadata contains operation wrappers
+    for (const rec of elements.values()) {
+        const name = rec.node["@_name"];
+        if (!name)
+            continue;
+        compileElementAsType(name, rec.node, rec.tns, rec.prefixes);
+    }
     // emit lists
     const typesList = Array.from(compiledMap.values());
     const aliasList = Array.from(aliasMap.values());
@@ -332,36 +407,68 @@ export function compileCatalog(cat, _opts) {
         childType[t.name] = child;
         propMeta[t.name] = meta;
     }
-    // operations / soapAction (minimal)
+    // operations / soapAction (enriched)
+    // 1) Gather all binding definitions and select the SOAP binding (soap:binding or soap12:binding child).
+    // 2) Use the binding's @type to locate the matching portType in definitions.
+    // 3) Enumerate operations on that portType (wsdl:operation) for input/output WSDL messages.
+    // 4) In the chosen binding, extract the <soap:operation> child to read SOAP action URIs.
     const defs = cat.wsdlXml["wsdl:definitions"] || cat.wsdlXml["definitions"];
-    const portType = defs?.["wsdl:portType"] || defs?.["portType"];
-    const binding = defs?.["wsdl:binding"] || defs?.["binding"];
-    const pOps = normalizeArray(portType?.["wsdl:operation"] || portType?.["operation"]);
+    const tns = defs?.["@_targetNamespace"] || "";
+    const bindingDefs = normalizeArray(defs?.["wsdl:binding"] || defs?.["binding"]);
+    const soapBinding = bindingDefs.find(b => Object.keys(b).some(k => k === "soap:binding" || k === "soap12:binding")) || bindingDefs[0];
+    // binding @type typically looks like "tns:MyPortType", so resolve via prefixes map
+    const portTypeAttr = soapBinding?.["@_type"];
+    const portTypeQName = portTypeAttr ? resolveQName(portTypeAttr, tns, cat.prefixMap) : undefined;
+    const portTypeDefs = normalizeArray(defs?.["wsdl:portType"] || defs?.["portType"]);
+    const targetPortType = portTypeQName
+        ? portTypeDefs.find(pt => pt?.["@_name"] === portTypeQName.local)
+        : portTypeDefs[0];
+    // operations listed under <wsdl:portType>
+    const pOps = targetPortType ? getChildrenWithLocalName(targetPortType, "operation") : [];
     const bOps = new Map();
-    const bindingOps = normalizeArray(binding?.["wsdl:operation"] || binding?.["operation"]);
-    const bindingOpsAny = bindingOps.length ? bindingOps : getChildrenWithLocalName(binding || {}, "operation");
-    for (const bo of bindingOpsAny) {
-        const name = bo?.["@_name"];
-        if (!name)
-            continue;
-        let action = "";
-        for (const [k, v] of Object.entries(bo || {})) {
-            if (k === "operation" || k.endsWith(":operation")) {
-                const node = Array.isArray(v) ? v[0] : v;
-                action = node?.["@_soapAction"] || node?.["@_soapActionURI"] || node?.["@_soapActionUrl"] || "";
-                if (action)
-                    break;
-            }
-        }
+    // in the <wsdl:binding>, each operation has a nested <soap:operation> child
+    const opsNodes = getChildrenWithLocalName(soapBinding, "operation").filter(o => o["@_name"]);
+    for (const bo of opsNodes) {
+        // operation name must match portType operation name
+        const name = bo["@_name"];
+        // find nested soap:operation node for the soapAction attribute
+        const soapOps = getChildrenWithLocalName(bo, "operation");
+        const soapOp = soapOps[0];
+        const action = soapOp?.["@_soapAction"] || soapOp?.["@_soapActionURI"] || soapOp?.["@_soapActionUrl"] || "";
         bOps.set(name, action);
     }
-    const ops = [];
-    for (const po of pOps) {
+    const msgDefs = normalizeArray(defs?.["wsdl:message"] || defs?.["message"]);
+    const findMessage = (qstr) => {
+        if (!qstr)
+            return undefined;
+        const q = resolveQName(qstr, tns, cat.prefixMap);
+        return msgDefs.find(m => m?.["@_name"] === q.local);
+    };
+    const elementOfMessage = (msg) => {
+        if (!msg)
+            return undefined;
+        const parts = getChildrenWithLocalName(msg, "part");
+        // Prefer element-based part (doc/literal)
+        const withElem = parts.find(p => p?.["@_element"]);
+        const el = withElem?.["@_element"];
+        if (!el)
+            return undefined;
+        const q = resolveQName(el, tns, cat.prefixMap);
+        return { ns: q.ns, local: q.local };
+    };
+    // build operations list
+    const ops = (pOps
+        .map(po => {
         const name = po?.["@_name"];
         if (!name)
-            continue;
-        ops.push({ name, soapAction: bOps.get(name) || "" });
-    }
+            return undefined;
+        const inMsg = findMessage(getFirstWithLocalName(po, "input")?.["@_message"]);
+        const outMsg = findMessage(getFirstWithLocalName(po, "output")?.["@_message"]);
+        const inputElement = elementOfMessage(inMsg);
+        const outputElement = elementOfMessage(outMsg);
+        return { name, soapAction: bOps.get(name) || "", inputElement, outputElement };
+    })
+        .filter((x) => x != null));
     return {
         types: typesList,
         aliases: aliasList,

package/dist/config.d.ts

@@ -1,13 +1,35 @@
 import type { PrimitiveOptions } from "./xsd/primitives.js";
+/**
+ * Options to control WSDL-to-TypeScript compilation behavior.
+ */
 export type CompilerOptions = {
+    /**
+     * How to represent XML <choice> elements: as all-optional properties or a discriminated union.
+     */
     choice?: "all-optional" | "union";
+    /**
+     * Legacy flag: map all date/time/duration types to string or Date. Superceded by primitive.dateAs if set.
+     */
     dateAs?: "string" | "date";
+    /**
+     * Legacy flag: shorthand for int64As and bigIntegerAs. Maps integer types to number or string.
+     */
     intAs?: "number" | "string";
+    /**
+     * Emit errors if any type references cannot be resolved in the WSDL schema.
+     */
     failOnUnresolved?: boolean;
-    /** Attribute bag key for the runtime mapper (node-soap). */
+    /**
+     * Attribute bag key for the runtime mapper (node-soap).
+     */
     attributesKey?: string;
-    /** Controls how XSD primitives are mapped to TypeScript. Safe defaults apply. */
+    /**
+     * Controls low-level mapping of XSD primitives to TypeScript types. Safe defaults are provided.
+     */
     primitive?: PrimitiveOptions;
 };
+/**
+ * Default compiler options. Users may override selectively.
+ */
 export declare const defaultOptions: CompilerOptions;
 //# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D,MAAM,MAAM,eAAe,GAAG;IAC1B,MAAM,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC;IAClC,MAAM,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAC;IAC3B,KAAK,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAC5B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,4DAA4D;IAC5D,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,iFAAiF;IACjF,SAAS,CAAC,EAAE,gBAAgB,CAAC;CAChC,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,eAM5B,CAAC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC1B;;OAEG;IACH,MAAM,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC;IAClC;;OAEG;IACH,MAAM,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAC;IAC3B;;OAEG;IACH,KAAK,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAC5B;;OAEG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;OAEG;IACH,SAAS,CAAC,EAAE,gBAAgB,CAAC;CAChC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,eAM5B,CAAC"}

package/dist/config.js

@@ -1,3 +1,6 @@
+/**
+ * Default compiler options. Users may override selectively.
+ */
 export const defaultOptions = {
     choice: "all-optional",
     dateAs: "string",

package/dist/emit/clientEmitter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clientEmitter.d.ts","sourceRoot":"","sources":["../../src/emit/clientEmitter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,EAAE,IAAI,EAAE,eAAe,GAAG;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,QA6BpH"}
+{"version":3,"file":"clientEmitter.d.ts","sourceRoot":"","sources":["../../src/emit/clientEmitter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAGpD,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,EAAE,IAAI,EAAE,eAAe,GAAG;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,QAmCpH"}

package/dist/emit/clientEmitter.js

@@ -1,4 +1,5 @@
 import fs from "node:fs";
+import { pascal } from "../util/xml.js";
 export function emitClient(outFile, compiled, opts) {
     const ext = opts.importExt ?? ".js";
     const lines = [];
@@ -14,14 +15,20 @@ export function emitClient(outFile, compiled, opts) {
     lines.push(`  }`);
     for (const op of compiled.operations) {
         const m = op.name;
+        const inTypeName = op.inputElement ? pascal(op.inputElement.local) : undefined;
+        const outTypeName = op.outputElement ? pascal(op.outputElement.local) : undefined;
+        const inTs = inTypeName ? `T.${inTypeName}` : `any`;
+        const outTs = outTypeName ? `T.${outTypeName}` : `any`;
+        const inMetaKey = inTypeName ?? m;
+        const outMetaKey = outTypeName ?? m;
         lines.push(`  /** SOAPAction: ${op.soapAction} */`);
-        lines.push(`  async ${m}(args: any): Promise<any> {`);
+        lines.push(`  async ${m}(args: ${inTs}): Promise<${outTs}> {`);
         lines.push(`    const c: any = await this._client();`);
         lines.push(`    const meta = { ATTR_SPEC, CHILD_TYPE, PROP_META } as const;`);
-        lines.push(`    const soapArgs = toSoapArgs(args, "${m}", meta, this.attributesKey);`);
+        lines.push(`    const soapArgs = toSoapArgs(args as any, "${inMetaKey}", meta, this.attributesKey);`);
         lines.push(`    return new Promise((resolve, reject) => {`);
         lines.push(`      c['${m}'](soapArgs, (err: any, result: any) => {`);
-        lines.push(`        if (err) reject(err); else resolve(fromSoapResult(result, "${m}", meta, this.attributesKey));`);
+        lines.push(`        if (err) reject(err); else resolve(fromSoapResult(result, "${outMetaKey}", meta, this.attributesKey));`);
         lines.push(`      });`);
         lines.push(`    });`);
         lines.push(`  }`);

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAYnD,wBAAsB,oBAAoB,CAAC,KAAK,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,eAAe,CAAA;CAAE,iBAiC5G;AAID,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,YAAY,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAcnD,wBAAsB,oBAAoB,CACtC,KAAK,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,eAAe,CAAA;CAAE,iBA6CrE;AAGD,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,YAAY,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -8,39 +8,50 @@ import { emitClient } from "./emit/clientEmitter.js";
 import { emitRuntime } from "./emit/runtimeEmitter.js";
 import fs from "node:fs";
 import path from "node:path";
+// Entry point for programmatic API: compile a WSDL into a set of TypeScript files in a project layout
 // noinspection JSUnusedGlobalSymbols
 export async function compileWsdlToProject(input) {
-    const opts = { ...defaultOptions, ...(input.options || {}) };
-    // Backward-compat: map legacy flags to primitive preferences unless explicitly provided
-    const primitive = { ...(opts.primitive || {}) };
-    if (opts.dateAs && primitive.dateAs == null)
-        primitive.dateAs = opts.dateAs === "date" ? "Date" : "string";
-    if (opts.intAs && (primitive.int64As == null || primitive.bigIntegerAs == null)) {
-        const as = opts.intAs; // "number" | "string"
-        if (primitive.int64As == null)
-            primitive.int64As = as;
-        if (primitive.bigIntegerAs == null)
-            primitive.bigIntegerAs = as;
+    // Merge defaults with user overrides
+    const baseOptions = { ...defaultOptions, ...(input.options || {}) };
+    // Backward compatibility: legacy flags map to the new primitive preferences if not set
+    const normalizedPrimitive = { ...(baseOptions.primitive || {}) };
+    if (baseOptions.dateAs && normalizedPrimitive.dateAs == null) {
+        // dateAs legacy: choose Date or string based on flag
+        normalizedPrimitive.dateAs = baseOptions.dateAs === "date" ? "Date" : "string";
     }
-    const mergedOpts = { ...opts, primitive };
-    const catalog = await loadWsdl(input.wsdl);
-    console.log(`Loaded WSDL: ${catalog.wsdlUri}`);
-    const compiled = compileCatalog(catalog, mergedOpts);
-    console.log(`Schemas discovered: ${catalog.schemas.length}`);
-    console.log(`Compiled types: ${compiled.types.length}`);
-    console.log(`Operations: ${compiled.operations.length}`);
+    if (baseOptions.intAs && (normalizedPrimitive.int64As == null || normalizedPrimitive.bigIntegerAs == null)) {
+        // intAs legacy: apply to both 64-bit and big integer types
+        const as = baseOptions.intAs;
+        if (normalizedPrimitive.int64As == null)
+            normalizedPrimitive.int64As = as;
+        if (normalizedPrimitive.bigIntegerAs == null)
+            normalizedPrimitive.bigIntegerAs = as;
+    }
+    // Final merged options including computed primitive mappings
+    const finalOptions = { ...baseOptions, primitive: normalizedPrimitive };
+    // Load WSDL definitions and schema catalog (remote or local file)
+    const wsdlCatalog = await loadWsdl(input.wsdl);
+    console.log(`Loaded WSDL: ${wsdlCatalog.wsdlUri}`);
+    // Compile schemas and operations into intermediate data structures
+    const compiledCatalog = compileCatalog(wsdlCatalog, finalOptions);
+    console.log(`Schemas discovered: ${wsdlCatalog.schemas.length}`);
+    console.log(`Compiled types: ${compiledCatalog.types.length}`);
+    console.log(`Operations: ${compiledCatalog.operations.length}`);
+    // Prepare output directory for generated files
     fs.mkdirSync(input.outDir, { recursive: true });
-    const typesPath = path.join(input.outDir, "types.ts");
-    const metaPath = path.join(input.outDir, "meta.ts");
-    const opsPath = path.join(input.outDir, "operations.json");
-    const clientPath = path.join(input.outDir, "client.ts");
-    const runtimePath = path.join(input.outDir, "runtime.ts");
-    emitTypes(typesPath, compiled);
-    emitMeta(metaPath, compiled, mergedOpts);
-    emitOperations(opsPath, compiled);
-    emitClient(clientPath, compiled, mergedOpts);
-    emitRuntime(path.join(runtimePath, "runtime.ts"));
+    // Define target paths
+    const typesFile = path.join(input.outDir, "types.ts");
+    const metaFile = path.join(input.outDir, "meta.ts");
+    const opsFile = path.join(input.outDir, "operations.json");
+    const clientFile = path.join(input.outDir, "client.ts");
+    const runtimeFile = path.join(input.outDir, "runtime.ts");
+    // Emit code artifacts: types, metadata, operations listing, client harness, runtime helpers
+    emitTypes(typesFile, compiledCatalog);
+    emitMeta(metaFile, compiledCatalog, finalOptions);
+    emitOperations(opsFile, compiledCatalog);
+    emitClient(clientFile, compiledCatalog, finalOptions);
+    emitRuntime(runtimeFile);
 }
-// Public API re-exports for library users
+// Re-export public API for library consumers
 export { compileCatalog } from "./compiler/schemaCompiler.js";
 export { xsdToTsPrimitive } from "./xsd/primitives.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@techspokes/typescript-wsdl-client",
-  "version": "0.1.8",
+  "version": "0.2.0",
   "description": "TypeScript WSDL → SOAP client generator with full xs:attribute support, complex types, sequences, inheritance, and namespace-collision merging.",
   "keywords": [
     "wsdl",
@@ -53,7 +53,7 @@
     "prepublishOnly": "npm run clean && npm run build",
     "test": "exit 0",
     "smoke": "tsx src/cli.ts --help",
-    "smoke:gen": "rimraf tmp && tsx src/cli.ts --wsdl examples/minimal/echo.wsdl --out tmp && tsc --noEmit --module NodeNext --moduleResolution NodeNext --target ES2022 tmp/types.ts tmp/meta.ts tmp/operations.ts tmp/runtime.ts tmp/client.ts src/types/soap.d.ts",
+    "smoke:gen": "rimraf tmp && tsx src/cli.ts --wsdl examples/minimal/weather.wsdl --out tmp && tsc --noEmit --module NodeNext --moduleResolution NodeNext --target ES2022 tmp/types.ts tmp/meta.ts tmp/operations.ts tmp/runtime.ts tmp/client.ts src/types/soap.d.ts",
     "ci": "npm run build && npm run typecheck && npm run smoke && npm run smoke:gen"
   },
   "devDependencies": {