@techspokes/typescript-wsdl-client 0.1.7

package/dist/emit/typesEmitter.js

@@ -0,0 +1,91 @@
+import fs from "node:fs";
+/**
+ * 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 function emitTypes(outFile, compiled) {
+    const lines = [];
+    // Convenience lookups
+    const typeNames = new Set(compiled.types.map((t) => t.name));
+    //
+    // 1) Named simple types (aliases) first
+    //
+    for (const a of compiled.aliases) {
+        const ann = a.jsdoc ? `  /** @xsd ${a.jsdoc} */\n` : "";
+        lines.push(`${ann}export type ${a.name} = ${a.tsType};`);
+        lines.push("");
+    }
+    //
+    // 2) Complex types as interfaces
+    //
+    for (const t of compiled.types) {
+        // Detect mis-mapped simpleContent extension:
+        //   single "$value" whose tsType is another named interface ⇒ extend that interface
+        const valueElems = (t.elems || []).filter((e) => e.name === "$value" &&
+            (e.max === 1 || e.max === undefined) &&
+            typeof e.tsType === "string" &&
+            typeNames.has(e.tsType));
+        const isSimpleContentExtension = (t.elems?.length || 0) === 1 && valueElems.length === 1;
+        const baseName = isSimpleContentExtension ? valueElems[0].tsType : undefined;
+        // Header
+        if (baseName) {
+            lines.push(`export interface ${t.name} extends ${baseName} {`);
+        }
+        else {
+            lines.push(`export interface ${t.name} {`);
+        }
+        //
+        // Attributes — with JSDoc on every attribute
+        //
+        for (const a of t.attrs || []) {
+            const opt = a.use === "required" ? "" : "?";
+            const annObj = {
+                kind: "attribute",
+                type: a.declaredType,
+                use: a.use || "optional",
+            };
+            const ann = `  /** @xsd ${JSON.stringify(annObj)} */`;
+            lines.push(ann);
+            lines.push(`  ${a.name}${opt}: ${a.tsType};`);
+        }
+        //
+        // Elements — with JSDoc on every element
+        //
+        const elementsToEmit = [...(t.elems || [])];
+        // If we detected simpleContent extension, drop the synthetic $value (we're extending instead).
+        if (isSimpleContentExtension) {
+            const idx = elementsToEmit.findIndex((e) => e.name === "$value");
+            if (idx >= 0)
+                elementsToEmit.splice(idx, 1);
+        }
+        // Ensure "$value" is last if present
+        elementsToEmit.sort((a, b) => {
+            if (a.name === "$value" && b.name !== "$value")
+                return 1;
+            if (a.name !== "$value" && b.name === "$value")
+                return -1;
+            return 0;
+        });
+        for (const e of elementsToEmit) {
+            const isArray = e.max === "unbounded" ||
+                (typeof e.max === "number" && e.max > 1);
+            const arr = isArray ? "[]" : "";
+            const opt = (e.min ?? 0) === 0 ? "?" : "";
+            const annObj = {
+                kind: "element",
+                type: e.declaredType,
+                occurs: { min: e.min, max: e.max, nillable: e.nillable ?? false },
+            };
+            const ann = `  /** @xsd ${JSON.stringify(annObj)} */`;
+            lines.push(ann);
+            lines.push(`  ${e.name}${opt}: ${e.tsType}${arr};`);
+        }
+        lines.push("}");
+        lines.push("");
+    }
+    fs.writeFileSync(outFile, lines.join("\n"), "utf8");
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import type { CompilerOptions } from "./config.js";
+export declare function compileWsdlToProject(input: {
+    wsdl: string;
+    outDir: string;
+    options?: CompilerOptions;
+}): Promise<void>;
+export { compileCatalog } from "./compiler/schemaCompiler.js";
+export type { PrimitiveOptions } from "./xsd/primitives.js";
+export { xsdToTsPrimitive } from "./xsd/primitives.js";
+export type { CompilerOptions } from "./config.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -0,0 +1,46 @@
+import { defaultOptions } from "./config.js";
+import { loadWsdl } from "./loader/wsdlLoader.js";
+import { compileCatalog } from "./compiler/schemaCompiler.js";
+import { emitTypes } from "./emit/typesEmitter.js";
+import { emitMeta } from "./emit/metaEmitter.js";
+import { emitOperations } from "./emit/opsEmitter.js";
+import { emitClient } from "./emit/clientEmitter.js";
+import { emitRuntime } from "./emit/runtimeEmitter.js";
+import fs from "node:fs";
+import path from "node:path";
+// 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;
+    }
+    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}`);
+    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"));
+}
+// Public API re-exports for library users
+export { compileCatalog } from "./compiler/schemaCompiler.js";
+export { xsdToTsPrimitive } from "./xsd/primitives.js";

package/dist/loader/fetch.d.ts

@@ -0,0 +1,5 @@
+export declare function fetchText(urlOrPath: string, base?: string): Promise<{
+    uri: string;
+    text: string;
+}>;
+//# sourceMappingURL=fetch.d.ts.map

package/dist/loader/fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../../src/loader/fetch.ts"],"names":[],"mappings":"AAGA,wBAAsB,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAcxG"}

package/dist/loader/fetch.js

@@ -0,0 +1,19 @@
+import fs from "node:fs";
+import path from "node:path";
+export async function fetchText(urlOrPath, base) {
+    let uri = urlOrPath;
+    if (base && !/^https?:/i.test(urlOrPath) && !path.isAbsolute(urlOrPath)) {
+        uri = path.resolve(base, urlOrPath);
+    }
+    if (/^https?:/i.test(uri)) {
+        const res = await fetch(uri, { headers: { Accept: "application/xml,text/xml,*/*" } });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status} ${res.statusText} for ${uri}`);
+        const text = await res.text();
+        return { uri, text };
+    }
+    else {
+        const text = fs.readFileSync(uri, "utf8");
+        return { uri, text };
+    }
+}

package/dist/loader/wsdlLoader.d.ts

@@ -0,0 +1,14 @@
+export type SchemaDoc = {
+    uri: string;
+    xml: any;
+    targetNS: string;
+    prefixes: Record<string, string>;
+};
+export type WsdlCatalog = {
+    wsdlUri: string;
+    wsdlXml: any;
+    schemas: SchemaDoc[];
+    prefixMap: Record<string, string>;
+};
+export declare function loadWsdl(wsdlUrlOrPath: string): Promise<WsdlCatalog>;
+//# sourceMappingURL=wsdlLoader.d.ts.map

package/dist/loader/wsdlLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wsdlLoader.d.ts","sourceRoot":"","sources":["../../src/loader/wsdlLoader.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,SAAS,GAAG;IACpB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,GAAG,CAAC;IACT,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,GAAG,CAAC;IACb,OAAO,EAAE,SAAS,EAAE,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACrC,CAAC;AAIF,wBAAsB,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CA6B1E"}

package/dist/loader/wsdlLoader.js

@@ -0,0 +1,88 @@
+import { XMLParser } from "fast-xml-parser";
+import { fetchText } from "./fetch.js";
+import path from "node:path";
+// noinspection ES6UnusedImports
+import { getChildrenWithLocalName, normalizeArray } from "../util/xml.js";
+const parser = new XMLParser({ ignoreAttributes: false, attributeNamePrefix: "@_" });
+export async function loadWsdl(wsdlUrlOrPath) {
+    const { uri: wsdlUri, text } = await fetchText(wsdlUrlOrPath);
+    const wsdlXml = parser.parse(text);
+    const defs = wsdlXml["wsdl:definitions"] || wsdlXml["definitions"];
+    if (!defs)
+        throw new Error("Not a WSDL 1.1 file: missing wsdl:definitions");
+    // WSDL-level prefixes
+    const prefixMap = {};
+    for (const [k, v] of Object.entries(defs)) {
+        if (k.startsWith("@_xmlns:"))
+            prefixMap[k.slice(8)] = String(v);
+    }
+    const tns = defs["@_targetNamespace"] || "";
+    const types = defs["wsdl:types"] || defs["types"];
+    const schemas = [];
+    const visited = new Set(); // de-dupe fetched schema docs by absolute URL/path
+    if (types) {
+        // Find any <xsd:schema> (prefix-agnostic) directly under wsdl:types
+        const rawSchemas = getChildrenWithLocalName(types, "schema");
+        const baseDir = path.dirname(wsdlUri);
+        for (const s of rawSchemas) {
+            const discovered = await resolveSchema(s, baseDir, visited);
+            schemas.push(...discovered);
+        }
+    }
+    console.log(`[wsdl] types->schemas: ${schemas.length}`);
+    return { wsdlUri, wsdlXml, schemas, prefixMap: { ...prefixMap, tns } };
+}
+async function resolveSchema(schemaNode, baseDir, visited) {
+    const out = [];
+    const targetNS = schemaNode["@_targetNamespace"] || "";
+    const prefixes = {};
+    for (const [k, v] of Object.entries(schemaNode)) {
+        if (k.startsWith("@_xmlns:"))
+            prefixes[k.slice(8)] = String(v);
+    }
+    // Record the inlined schema from the WSDL (no own URI; inherit baseDir)
+    out.push({ uri: baseDir, xml: schemaNode, targetNS, prefixes });
+    // includes/imports (prefix-agnostic)
+    for (const inc of getChildrenWithLocalName(schemaNode, "include")) {
+        const loc = inc?.["@_schemaLocation"];
+        if (!loc)
+            continue;
+        const more = await fetchAndResolveSchemaDoc(loc, baseDir, visited);
+        out.push(...more);
+    }
+    for (const imp of getChildrenWithLocalName(schemaNode, "import")) {
+        const loc = imp?.["@_schemaLocation"];
+        if (!loc)
+            continue;
+        const more = await fetchAndResolveSchemaDoc(loc, baseDir, visited);
+        out.push(...more);
+    }
+    return out;
+}
+async function fetchAndResolveSchemaDoc(schemaLocation, baseDir, visited) {
+    const { uri, text } = await fetchText(schemaLocation, baseDir);
+    const docKey = uri;
+    if (visited.has(docKey))
+        return [];
+    visited.add(docKey);
+    const sx = parser.parse(text);
+    // The fetched document may contain one or more <schema> nodes at the root (prefix-agnostic).
+    const roots = getChildrenWithLocalName(sx, "schema");
+    const docs = [];
+    for (const sn of roots) {
+        const tns = sn["@_targetNamespace"] || "";
+        const prefixes = {};
+        for (const [k, v] of Object.entries(sn)) {
+            if (k.startsWith("@_xmlns:"))
+                prefixes[k.slice(8)] = String(v);
+        }
+        const thisDir = path.dirname(uri);
+        docs.push({ uri: thisDir, xml: sn, targetNS: tns, prefixes });
+        // Recurse into nested includes/imports of this external schema
+        const nested = await resolveSchema(sn, thisDir, visited);
+        // resolveSchema already pushed the 'sn'; but here we’ve just pushed it ourselves.
+        // Merge only the *children* discovered by resolveSchema to avoid duplicate heads.
+        docs.push(...nested.slice(1));
+    }
+    return docs;
+}

package/dist/util/xml.d.ts

@@ -0,0 +1,13 @@
+/** Normalize a possibly-single value into an array. */
+export declare function normalizeArray<T>(x: T | T[] | undefined | null): T[];
+/** Collect direct children whose LOCAL name matches (prefix-agnostic). */
+export declare function getChildrenWithLocalName(node: any, local: string): any[];
+/** Return the first direct child whose LOCAL name matches (prefix-agnostic). */
+export declare function getFirstWithLocalName(node: any, local: string): any | undefined;
+/** Simple PascalCase helper used across emitters/parsers. */
+export declare function pascal(s: string): string;
+export declare function resolveQName(qname: string, defaultNS: string, prefixes: Record<string, string>): {
+    ns: string;
+    local: string;
+};
+//# sourceMappingURL=xml.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"xml.d.ts","sourceRoot":"","sources":["../../src/util/xml.ts"],"names":[],"mappings":"AAAA,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,CAExC;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"}

package/dist/util/xml.js

@@ -0,0 +1,40 @@
+/** Normalize a possibly-single value into an array. */
+export function normalizeArray(x) {
+    if (x == null)
+        return [];
+    return Array.isArray(x) ? x : [x];
+}
+/** Collect direct children whose LOCAL name matches (prefix-agnostic). */
+export function getChildrenWithLocalName(node, local) {
+    const out = [];
+    for (const [k, v] of Object.entries(node || {})) {
+        if (k === local || k.endsWith(`:${local}`)) {
+            const arr = Array.isArray(v) ? v : [v];
+            out.push(...arr.filter(Boolean));
+        }
+    }
+    return out;
+}
+/** Return the first direct child whose LOCAL name matches (prefix-agnostic). */
+export function getFirstWithLocalName(node, local) {
+    for (const [k, v] of Object.entries(node || {})) {
+        if (k === local || k.endsWith(`:${local}`))
+            return v;
+    }
+    return undefined;
+}
+/** Simple PascalCase helper used across emitters/parsers. */
+export function pascal(s) {
+    return s.replace(/(^|[_\-\s])(\w)/g, (_, __, c) => c.toUpperCase()).replace(/[^A-Za-z0-9]/g, "");
+}
+export function resolveQName(qname, defaultNS, prefixes) {
+    if (!qname)
+        return { ns: defaultNS, local: "" };
+    const parts = qname.split(":");
+    if (parts.length === 2) {
+        const [prefix, local] = parts;
+        const ns = prefixes[prefix] || defaultNS;
+        return { ns, local };
+    }
+    return { ns: defaultNS, local: qname };
+}

package/dist/xsd/primitives.d.ts

@@ -0,0 +1,8 @@
+export type PrimitiveOptions = {
+    int64As?: "string" | "number" | "bigint";
+    bigIntegerAs?: "string" | "number";
+    decimalAs?: "string" | "number";
+    dateAs?: "string" | "Date";
+};
+export declare function xsdToTsPrimitive(xsdQName: string, options?: PrimitiveOptions): string;
+//# sourceMappingURL=primitives.d.ts.map

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

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

package/dist/xsd/primitives.js

@@ -0,0 +1,116 @@
+// 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)
+const DEFAULTS = {
+    int64As: "string",
+    bigIntegerAs: "string",
+    decimalAs: "string",
+    dateAs: "string",
+};
+// Helper to choose ts type for integer families depending on magnitude
+function intFamily(local, opts) {
+    // 64-bit or unbounded families → configurable
+    const int64 = new Set(["long", "unsignedLong"]);
+    const big = new Set([
+        "integer",
+        "nonPositiveInteger",
+        "negativeInteger",
+        "nonNegativeInteger",
+        "positiveInteger",
+    ]);
+    if (int64.has(local)) {
+        return opts.int64As === "bigint" ? "bigint" : opts.int64As;
+    }
+    if (big.has(local)) {
+        return opts.bigIntegerAs;
+    }
+    // Safe 32-bit families → number
+    const int32 = new Set(["int", "unsignedInt"]);
+    const int16 = new Set(["short", "unsignedShort"]);
+    const int8 = new Set(["byte", "unsignedByte"]);
+    if (int32.has(local) || int16.has(local) || int8.has(local))
+        return "number";
+    return "number";
+}
+function decimalFamily(local, opts) {
+    // xs:decimal and derived decimals (if any) → configurable
+    if (local === "decimal")
+        return opts.decimalAs;
+    return "number";
+}
+function dateFamily(local, opts) {
+    // You can choose "Date", but generator won’t parse at runtime; it’s just type-level.
+    const s = opts.dateAs;
+    switch (local) {
+        case "date":
+        case "dateTime":
+        case "time":
+        case "gYear":
+        case "gYearMonth":
+        case "gMonth":
+        case "gMonthDay":
+        case "gDay":
+        case "dateTimeStamp": // XSD 1.1
+        case "duration":
+        case "dayTimeDuration": // XSD 1.1
+        case "yearMonthDuration": // XSD 1.1
+            return s;
+        default:
+            return "string";
+    }
+}
+const STRING_LIKE = new Set([
+    "string",
+    "normalizedString",
+    "token",
+    "language",
+    "Name",
+    "NCName",
+    "NMTOKEN", "NMTOKENS",
+    "ID", "IDREF", "IDREFS",
+    "ENTITY", "ENTITIES",
+    "anyURI",
+    "QName",
+    "NOTATION",
+    "hexBinary",
+    "base64Binary", // could be "string" or a branded type
+]);
+export function xsdToTsPrimitive(xsdQName, options) {
+    const opts = { ...DEFAULTS, ...(options || {}) };
+    // Expect formats like "xs:int". Fall back to string if unknown.
+    const m = /^([a-zA-Z0-9_]+:)?([A-Za-z0-9_]+)$/.exec(xsdQName);
+    const local = m ? m[2] : xsdQName;
+    if (STRING_LIKE.has(local))
+        return "string";
+    if (local === "boolean")
+        return "boolean";
+    // Numerics
+    if (local === "byte" || local === "unsignedByte" ||
+        local === "short" || local === "unsignedShort" ||
+        local === "int" || local === "unsignedInt" ||
+        local === "long" || local === "unsignedLong" ||
+        local === "integer" ||
+        local === "nonNegativeInteger" || local === "positiveInteger" ||
+        local === "nonPositiveInteger" || local === "negativeInteger") {
+        return intFamily(local, opts);
+    }
+    if (local === "decimal")
+        return decimalFamily(local, opts);
+    if (local === "float" || local === "double")
+        return "number";
+    // Dates/times & durations
+    if (local === "date" || local === "dateTime" || local === "time" ||
+        local === "gYear" || local === "gYearMonth" || local === "gMonth" ||
+        local === "gMonthDay" || local === "gDay" ||
+        local === "dateTimeStamp" || local === "duration" ||
+        local === "dayTimeDuration" || local === "yearMonthDuration") {
+        return dateFamily(local, opts);
+    }
+    // anyType/anySimpleType → unknown (or 'any' if you prefer)
+    if (local === "anyType" || local === "anySimpleType")
+        return "unknown";
+    // Default fallback
+    return "string";
+}

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@techspokes/typescript-wsdl-client",
+  "version": "0.1.7",
+  "description": "TypeScript WSDL → SOAP client generator with full xs:attribute support, complex types, sequences, inheritance, and namespace-collision merging.",
+  "keywords": [
+    "wsdl",
+    "soap",
+    "typescript",
+    "codegen",
+    "generator",
+    "xml",
+    "xsd"
+  ],
+  "homepage": "https://github.com/techspokes/typescript-wsdl-client#readme",
+  "bugs": {
+    "url": "https://github.com/techspokes/typescript-wsdl-client/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/techspokes/typescript-wsdl-client.git"
+  },
+  "license": "MIT",
+  "author": "TechSpokes <contact@techspokes.com> (https://www.techspokes.com)",
+  "contributors": [
+    "Serge Liatko <contact@techspokes.com> (https://github.com/sergeliatko)"
+  ],
+  "type": "module",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "bin": {
+    "wsdl-tsc": "dist/cli.js"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "rimraf dist",
+    "dev": "tsx src/cli.ts",
+    "watch": "tsx watch src/cli.ts",
+    "typecheck": "tsc --noEmit",
+    "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",
+    "ci": "npm run build && npm run typecheck && npm run smoke && npm run smoke:gen"
+  },
+  "devDependencies": {
+    "@types/node": "^24.3.0",
+    "@types/yargs": "^17.0.33",
+    "rimraf": "^6.0.0",
+    "tsx": "^4.20.0",
+    "typescript": "^5.6.3"
+  },
+  "dependencies": {
+    "fast-xml-parser": "^5.2.5",
+    "yargs": "^18.0.0"
+  },
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/techspokes"
+  }
+}