@techspokes/typescript-wsdl-client 0.1.7

package/dist/compiler/schemaCompiler.js

@@ -0,0 +1,372 @@
+import { getChildrenWithLocalName, getFirstWithLocalName, normalizeArray, pascal, resolveQName, } from "../util/xml.js";
+import { xsdToTsPrimitive } from "../xsd/primitives.js";
+const XS = "http://www.w3.org/2001/XMLSchema";
+function qkey(q) {
+    return `{${q.ns}}${q.local}`;
+}
+/** Inline complex type naming */
+function makeInlineTypeName(parentTypeName, propName, _max) {
+    const base = pascal(parentTypeName || "AnonParent");
+    const prop = pascal(propName || "");
+    if (prop)
+        return prop;
+    return `${base}Anon`;
+}
+export function compileCatalog(cat, _opts) {
+    // symbol tables discovered across all schemas
+    const complexTypes = new Map();
+    const simpleTypes = new Map();
+    const elements = new Map();
+    for (const s of cat.schemas) {
+        const tns = s.targetNS;
+        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 });
+        }
+        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 });
+        }
+        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 });
+        }
+    }
+    // outputs & state
+    const compiledMap = new Map(); // key: ns|name
+    const aliasMap = new Map(); // key: ns|name
+    const inProgress = new Set();
+    // meta accumulators
+    const attrSpec = {};
+    const childType = {};
+    const propMeta = {};
+    /** Compile a simpleType node to TS */
+    function compileSimpleTypeNode(simpleNode, schemaNS, prefixes) {
+        const rest = getFirstWithLocalName(simpleNode, "restriction");
+        if (rest) {
+            const enums = normalizeArray(rest["xs:enumeration"] || rest["enumeration"])
+                .map((e) => e["@_value"])
+                .filter(Boolean);
+            const base = rest["@_base"];
+            const q = base ? resolveQName(base, schemaNS, prefixes) : { ns: XS, local: "string" };
+            const declared = q.ns === XS ? `xs:${q.local}` : `{${q.ns}}${q.local}`;
+            if (enums.length) {
+                const union = enums.map((v) => JSON.stringify(v)).join(" | ");
+                return { tsType: union, declared, jsdoc: JSON.stringify({ kind: "enum", values: enums }) };
+            }
+            return { tsType: xsdToTsPrimitive(declared, _opts?.primitive), declared };
+        }
+        const list = getFirstWithLocalName(simpleNode, "list");
+        if (list?.["@_itemType"]) {
+            const q = resolveQName(list["@_itemType"], schemaNS, prefixes);
+            const declared = q.ns === XS ? `xs:${q.local}` : `{${q.ns}}${q.local}`;
+            return { tsType: `${xsdToTsPrimitive(declared, _opts?.primitive)}[]`, declared };
+        }
+        // fallback
+        return { tsType: "string", declared: "xs:string" };
+    }
+    /** Compile and cache a named simpleType */
+    function getOrCompileAlias(name, sNode, schemaNS, prefixes) {
+        const key = `${schemaNS}|${name}`;
+        const present = aliasMap.get(key);
+        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);
+        return alias;
+    }
+    /** Resolve a QName reference to a TS type; compile targets if needed. */
+    function resolveTypeRef(q, schemaNS, prefixes) {
+        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 };
+        }
+        const k = qkey(q);
+        const srec = simpleTypes.get(k);
+        if (srec) {
+            const a = getOrCompileAlias(q.local, srec.node, srec.tns, srec.prefixes);
+            return { tsType: a.name, declared: `{${a.ns}}${q.local}` };
+        }
+        const crec = complexTypes.get(k);
+        if (crec) {
+            const t = getOrCompileComplex(q.local, crec.node, crec.tns, crec.prefixes);
+            return { tsType: t.name, declared: `{${t.ns}}${q.local}` };
+        }
+        // fallback
+        return { tsType: "any", declared: `{${q.ns}}${q.local}` };
+    }
+    function findComplexRec(q) {
+        const k = qkey(q);
+        return complexTypes.get(k);
+    }
+    function getOrCompileComplex(name, cnode, schemaNS, prefixes) {
+        const outName = pascal(name);
+        const key = `${schemaNS}|${outName}`;
+        const present = compiledMap.get(key);
+        if (present)
+            return present;
+        if (inProgress.has(key)) {
+            // minimal cycle break
+            return { name: outName, ns: schemaNS, attrs: [], elems: [] };
+        }
+        inProgress.add(key);
+        const mergeAttrs = (into, list) => {
+            const idx = new Map();
+            into.forEach((a, i) => idx.set(a.name, i));
+            for (const a of list) {
+                const pos = idx.get(a.name);
+                if (pos == null) {
+                    idx.set(a.name, into.length);
+                    into.push(a);
+                }
+                else {
+                    into[pos] = a; // override
+                }
+            }
+        };
+        const mergeElems = (into, list) => {
+            const idx = new Map();
+            into.forEach((e, i) => idx.set(e.name, i));
+            for (const e of list) {
+                const pos = idx.get(e.name);
+                if (pos == null) {
+                    idx.set(e.name, into.length);
+                    into.push(e);
+                }
+                else {
+                    into[pos] = e; // override
+                }
+            }
+        };
+        const collectAttributes = (node) => {
+            const out = [];
+            const attrs = getChildrenWithLocalName(node, "attribute");
+            for (const a of attrs) {
+                const an = a["@_name"];
+                if (!an)
+                    continue;
+                const inlineSimple = getFirstWithLocalName(a, "simpleType");
+                if (inlineSimple) {
+                    const r = compileSimpleTypeNode(inlineSimple, schemaNS, prefixes);
+                    out.push({
+                        name: an,
+                        tsType: r.tsType,
+                        use: a["@_use"] === "required" ? "required" : "optional",
+                        declaredType: r.declared,
+                    });
+                }
+                else {
+                    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,
+                    });
+                }
+            }
+            return out;
+        };
+        const collectParticles = (ownerTypeName, node) => {
+            const out = [];
+            const groups = [
+                ...getChildrenWithLocalName(node, "sequence"),
+                ...getChildrenWithLocalName(node, "all"),
+                ...getChildrenWithLocalName(node, "choice"),
+            ];
+            for (const grp of groups) {
+                for (const e of getChildrenWithLocalName(grp, "element")) {
+                    const nameOrRef = e["@_name"] || e["@_ref"];
+                    if (!nameOrRef)
+                        continue;
+                    let propName = e["@_name"] || undefined;
+                    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
+                    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}`,
+                        });
+                    }
+                    else if (inlineSimple) {
+                        const r = compileSimpleTypeNode(inlineSimple, schemaNS, prefixes);
+                        out.push({
+                            name: propName || nameOrRef,
+                            tsType: r.tsType,
+                            min,
+                            max,
+                            nillable,
+                            declaredType: r.declared,
+                        });
+                    }
+                    else {
+                        // normal ref/type
+                        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,
+                        });
+                    }
+                }
+            }
+            return out;
+        };
+        // Result accumulators
+        const attrs = [];
+        const elems = [];
+        // Inheritance: complexContent
+        const complexContent = getFirstWithLocalName(cnode, "complexContent");
+        if (complexContent) {
+            const ext = getFirstWithLocalName(complexContent, "extension");
+            const res = getFirstWithLocalName(complexContent, "restriction");
+            const node = ext || res;
+            if (node) {
+                const baseAttr = node["@_base"];
+                if (baseAttr) {
+                    const baseQ = resolveQName(baseAttr, schemaNS, prefixes);
+                    const baseRec = findComplexRec(baseQ);
+                    if (baseRec) {
+                        const base = getOrCompileComplex(baseRec.node["@_name"], baseRec.node, baseRec.tns, baseRec.prefixes);
+                        // inherit base
+                        mergeAttrs(attrs, base.attrs);
+                        mergeElems(elems, base.elems);
+                    }
+                }
+                // local additions/overrides
+                mergeAttrs(attrs, collectAttributes(node));
+                mergeElems(elems, collectParticles(outName, node));
+                const result = { name: outName, ns: schemaNS, attrs, elems };
+                compiledMap.set(key, result);
+                inProgress.delete(key);
+                return result;
+            }
+        }
+        // Simple content: text + attributes (IMPORTANT: model text as "$value")
+        const simpleContent = getFirstWithLocalName(cnode, "simpleContent");
+        if (simpleContent) {
+            const ext = getFirstWithLocalName(simpleContent, "extension");
+            const res = getFirstWithLocalName(simpleContent, "restriction");
+            const model = (scNode) => {
+                const baseAttr = scNode["@_base"];
+                let r = { tsType: "string", declared: "xs:string" };
+                if (baseAttr) {
+                    r = resolveTypeRef(resolveQName(baseAttr, schemaNS, prefixes), schemaNS, prefixes);
+                }
+                // 👇👇 text node is modeled as "$value" (not "value")
+                mergeElems(elems, [{
+                        name: "$value",
+                        tsType: r.tsType,
+                        min: 0,
+                        max: 1,
+                        nillable: false,
+                        declaredType: r.declared,
+                    }]);
+                mergeAttrs(attrs, collectAttributes(scNode));
+                const result = { name: outName, ns: schemaNS, attrs, elems };
+                compiledMap.set(key, result);
+                inProgress.delete(key);
+                return result;
+            };
+            if (ext)
+                return model(ext);
+            if (res)
+                return model(res);
+        }
+        // Attributes + particles
+        mergeAttrs(attrs, collectAttributes(cnode));
+        mergeElems(elems, collectParticles(outName, cnode));
+        const result = { name: outName, ns: schemaNS, attrs, elems };
+        compiledMap.set(key, result);
+        inProgress.delete(key);
+        return result;
+    }
+    // compile every discovered complex type
+    for (const rec of complexTypes.values()) {
+        const name = rec.node["@_name"];
+        if (!name)
+            continue;
+        getOrCompileComplex(name, rec.node, rec.tns, rec.prefixes);
+    }
+    // emit lists
+    const typesList = Array.from(compiledMap.values());
+    const aliasList = Array.from(aliasMap.values());
+    // meta
+    for (const t of typesList) {
+        attrSpec[t.name] = (t.attrs || []).map(a => a.name);
+        const child = {};
+        const meta = {};
+        for (const e of t.elems || []) {
+            child[e.name] = typeof e.tsType === "string" ? e.tsType : "any";
+            meta[e.name] = {
+                declaredType: e.declaredType,
+                min: e.min,
+                max: e.max,
+                nillable: !!e.nillable,
+            };
+        }
+        childType[t.name] = child;
+        propMeta[t.name] = meta;
+    }
+    // operations / soapAction (minimal)
+    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 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;
+            }
+        }
+        bOps.set(name, action);
+    }
+    const ops = [];
+    for (const po of pOps) {
+        const name = po?.["@_name"];
+        if (!name)
+            continue;
+        ops.push({ name, soapAction: bOps.get(name) || "" });
+    }
+    return {
+        types: typesList,
+        aliases: aliasList,
+        meta: { attrSpec, childType, propMeta },
+        operations: ops,
+        wsdlTargetNS: defs?.["@_targetNamespace"] || "",
+    };
+}

package/dist/config.d.ts

@@ -0,0 +1,13 @@
+import type { PrimitiveOptions } from "./xsd/primitives.js";
+export type CompilerOptions = {
+    choice?: "all-optional" | "union";
+    dateAs?: "string" | "date";
+    intAs?: "number" | "string";
+    failOnUnresolved?: boolean;
+    /** Attribute bag key for the runtime mapper (node-soap). */
+    attributesKey?: string;
+    /** Controls how XSD primitives are mapped to TypeScript. Safe defaults apply. */
+    primitive?: PrimitiveOptions;
+};
+export declare const defaultOptions: CompilerOptions;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +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"}

package/dist/config.js

@@ -0,0 +1,7 @@
+export const defaultOptions = {
+    choice: "all-optional",
+    dateAs: "string",
+    intAs: "number",
+    failOnUnresolved: false,
+    attributesKey: "$attributes",
+};

package/dist/emit/clientEmitter.d.ts

@@ -0,0 +1,6 @@
+import type { CompiledCatalog } from "../compiler/schemaCompiler.js";
+import type { CompilerOptions } from "../config.js";
+export declare function emitClient(outFile: string, compiled: CompiledCatalog, opts: CompilerOptions & {
+    importExt?: string;
+}): void;
+//# sourceMappingURL=clientEmitter.d.ts.map

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

@@ -0,0 +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"}

package/dist/emit/clientEmitter.js

@@ -0,0 +1,31 @@
+import fs from "node:fs";
+export function emitClient(outFile, compiled, opts) {
+    const ext = opts.importExt ?? ".js";
+    const lines = [];
+    lines.push(`import { createSoapClient, toSoapArgs, fromSoapResult } from "./runtime${ext}";`);
+    lines.push(`import { ATTR_SPEC, CHILD_TYPE, PROP_META } from "./meta${ext}";`);
+    lines.push(`import type * as T from "./types${ext}";`);
+    lines.push("");
+    lines.push(`export class GeneratedSoapClient {`);
+    lines.push(`  constructor(private source: string | any, private attributesKey: string = "${opts.attributesKey || "$attributes"}") {}`);
+    lines.push(`  async _client() {`);
+    lines.push(`    if (typeof this.source === 'string') return createSoapClient({ wsdlUrl: this.source });`);
+    lines.push(`    return this.source;`);
+    lines.push(`  }`);
+    for (const op of compiled.operations) {
+        const m = op.name;
+        lines.push(`  /** SOAPAction: ${op.soapAction} */`);
+        lines.push(`  async ${m}(args: any): Promise<any> {`);
+        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(`    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(`      });`);
+        lines.push(`    });`);
+        lines.push(`  }`);
+    }
+    lines.push(`}`);
+    fs.writeFileSync(outFile, lines.join("\n"), "utf8");
+}

package/dist/emit/metaEmitter.d.ts

@@ -0,0 +1,4 @@
+import type { CompiledCatalog } from "../compiler/schemaCompiler.js";
+import type { CompilerOptions } from "../config.js";
+export declare function emitMeta(outFile: string, compiled: CompiledCatalog, opts?: CompilerOptions): void;
+//# sourceMappingURL=metaEmitter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"metaEmitter.d.ts","sourceRoot":"","sources":["../../src/emit/metaEmitter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,EAAE,IAAI,CAAC,EAAE,eAAe,QAQ1F"}

package/dist/emit/metaEmitter.js

@@ -0,0 +1,9 @@
+import fs from "node:fs";
+export function emitMeta(outFile, compiled, opts) {
+    const { attrSpec, childType, propMeta } = compiled.meta;
+    const src = `export const ATTR_SPEC = ${JSON.stringify(attrSpec, null, 2)} as const;\n` +
+        `export const CHILD_TYPE = ${JSON.stringify(childType, null, 2)} as const;\n` +
+        `export const PROP_META = ${JSON.stringify(propMeta, null, 2)} as const;\n` +
+        `export const OPTIONS = ${JSON.stringify(opts || {}, null, 2)} as const;\n`;
+    fs.writeFileSync(outFile, src, "utf8");
+}

package/dist/emit/opsEmitter.d.ts

@@ -0,0 +1,4 @@
+import type { CompiledCatalog } from "../compiler/schemaCompiler.js";
+export declare function emitOperations(outFile: string, compiled: CompiledCatalog): void;
+export declare function emitOps(outFile: string, compiled: CompiledCatalog): void;
+//# sourceMappingURL=opsEmitter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"opsEmitter.d.ts","sourceRoot":"","sources":["../../src/emit/opsEmitter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAErE,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,QAExE;AAED,wBAAgB,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,QAOjE"}

package/dist/emit/opsEmitter.js

@@ -0,0 +1,13 @@
+import fs from "node:fs";
+export function emitOperations(outFile, compiled) {
+    fs.writeFileSync(outFile, JSON.stringify(compiled.operations, null, 2), "utf8");
+}
+export function emitOps(outFile, compiled) {
+    if (outFile.endsWith(".ts")) {
+        const src = `export const OPERATIONS = ${JSON.stringify(compiled.operations, null, 2)} as const;\n`;
+        fs.writeFileSync(outFile, src, "utf8");
+    }
+    else {
+        emitOperations(outFile, compiled);
+    }
+}

package/dist/emit/runtimeEmitter.d.ts

@@ -0,0 +1,2 @@
+export declare function emitRuntime(outFile: string): void;
+//# sourceMappingURL=runtimeEmitter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runtimeEmitter.d.ts","sourceRoot":"","sources":["../../src/emit/runtimeEmitter.ts"],"names":[],"mappings":"AAGA,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,QAuF1C"}

package/dist/emit/runtimeEmitter.js

@@ -0,0 +1,90 @@
+import fs from "node:fs";
+import path from "node:path";
+export function emitRuntime(outFile) {
+    const code = `// noinspection NpmUsedModulesInstalled,JSLastCommaInObjectLiteral,CommaExpressionJS,JSUnresolvedReference
+
+import soap from "soap";
+export type CreateSoapClientOptions = {
+  wsdlUrl: string;
+  endpoint?: string;
+  wsdlOptions?: Record<string, any>;
+  requestOptions?: Record<string, any>;
+}
+export type AttrSpec = Record<string, readonly string[]>;
+export type ChildType = Record<string, Readonly<Record<string, string>>>;
+export type PropMeta = Record<string, Readonly<Record<string, any>>>;
+
+export async function createSoapClient(opts: CreateSoapClientOptions): Promise<any> {
+  const client = await soap.createClientAsync(opts.wsdlUrl, opts.wsdlOptions || {});
+  if (opts.endpoint) client.setEndpoint(opts.endpoint);
+  if (opts.requestOptions) {
+    const { wsdlUrl, endpoint, wsdlOptions, ...req } = opts as any;
+    if (client.setSecurity && req) {
+      // security is caller's responsibility (if needed)
+    }
+  }
+  return client;
+}
+
+export function toSoapArgs(
+  value: any,
+  typeName?: string,
+  meta?: { ATTR_SPEC: AttrSpec; CHILD_TYPE: ChildType; PROP_META: PropMeta },
+  attributesKey: string = "$attributes"
+): any {
+  if (value == null) return value;
+  if (typeof value !== "object") return value;
+  const attrList = (typeName && meta?.ATTR_SPEC?.[typeName]) || [];
+  const childType = (typeName && meta?.CHILD_TYPE?.[typeName]) || {};
+  const out: any = {};
+  const attrBag: any = {};
+  // map TS $value -> SOAP $value
+  if ("$value" in value && Object.keys(value).length >= 1) out.$value = (value as any).$value;
+
+  for (const [k, v] of Object.entries<any>(value)) {
+    if (k === "$value") continue;                 // skip text node (already mapped)
+    if (k === attributesKey) continue;            // user shouldn't send raw attr bag
+    if (attrList.includes(k)) { attrBag[k] = v; continue; }
+    const childT = (childType as any)[k] as string | undefined;
+    out[k] = Array.isArray(v)
+      ? v.map(it => toSoapArgs(it, childT, meta, attributesKey))
+      : toSoapArgs(v, childT, meta, attributesKey);
+  }
+  if (Object.keys(attrBag).length) out[attributesKey] = attrBag;
+  return out;
+}
+
+export function fromSoapResult(
+  node: any,
+  typeName?: string,
+  meta?: { ATTR_SPEC: AttrSpec; CHILD_TYPE: ChildType; PROP_META: PropMeta },
+  attributesKey: string = "$attributes"
+): any {
+  if (node == null) return node;
+  if (typeof node !== "object") return node;
+  if (Array.isArray(node)) return node.map(n => fromSoapResult(n, typeName, meta, attributesKey));
+
+  const childType = (typeName && meta?.CHILD_TYPE?.[typeName]) || {};
+  const result: any = {};
+
+  // map SOAP $value -> TS $value
+  if ("$value" in node) result.$value = (node as any).$value;
+
+  // hoist attributes
+  if (attributesKey in node && node[attributesKey] && typeof node[attributesKey] === "object") {
+    Object.assign(result, node[attributesKey]);
+  }
+
+  for (const [k, v] of Object.entries<any>(node)) {
+    if (k === attributesKey || k === "$value") continue;
+    const childT = (childType as any)[k] as string | undefined;
+    result[k] = Array.isArray(v)
+      ? v.map(it => fromSoapResult(it, childT, meta, attributesKey))
+      : fromSoapResult(v, childT, meta, attributesKey);
+  }
+  return result;
+}
+`;
+    fs.mkdirSync(path.dirname(outFile), { recursive: true });
+    fs.writeFileSync(outFile, code, "utf8");
+}

package/dist/emit/typesEmitter.d.ts

@@ -0,0 +1,11 @@
+import type { CompiledCatalog } from "../compiler/schemaCompiler.js";
+/**
+ * Emit TypeScript types from a compiled XSD catalog.
+ *
+ * - Text node is modeled as "$value" (not "value") to avoid collisions with real elements.
+ * - xs:complexType + xs:simpleContent/extension is flattened to `extends <BaseType>`.
+ * - All properties (attributes and elements) include @xsd JSDoc.
+ * - If a "$value" element is present, it is emitted last.
+ */
+export declare function emitTypes(outFile: string, compiled: CompiledCatalog): void;
+//# sourceMappingURL=typesEmitter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"typesEmitter.d.ts","sourceRoot":"","sources":["../../src/emit/typesEmitter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAErE;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,QA+FnE"}