npm - @techspokes/typescript-wsdl-client - Versions diffs - 0.2.2 → 0.2.6 - Mend

@techspokes/typescript-wsdl-client 0.2.2 → 0.2.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/README.md +69 -193
package/dist/compiler/schemaCompiler.d.ts +15 -0
package/dist/compiler/schemaCompiler.d.ts.map +1 -1
package/dist/compiler/schemaCompiler.js +44 -42
package/dist/emit/clientEmitter.d.ts.map +1 -1
package/dist/emit/clientEmitter.js +19 -4
package/dist/emit/typesEmitter.d.ts.map +1 -1
package/dist/emit/typesEmitter.js +74 -26
package/dist/util/xml.d.ts.map +1 -1
package/dist/util/xml.js +29 -1
package/package.json +1 -1

package/README.md CHANGED Viewed

@@ -11,285 +11,160 @@
 [![TechSpokes Org](https://img.shields.io/badge/org-techspokes-181717?logo=github)](https://github.com/techspokes)
 [![Sponsor TechSpokes](https://img.shields.io/badge/sponsor-GitHub-blue?logo=github-sponsors)](https://github.com/sponsors/TechSpokes)
-**TypeScript WSDL → SOAP client generator.**
-Reads WSDL/XSD (with imports) and emits a small, typed client you can compile into your app.
+## Introduction
-* `xs:attribute` support (attributes become first-class fields, not bags)
-* `complexType` (`sequence` / `all` / `choice`)
-* `simpleContent` / `complexContent` (`extension` + `restriction`)
-* Inline **anonymous** types (auto-named, stable)
-* Global `element @ref` resolution
-* Duplicate/local-name **merge** across schemas/namespaces
-* Deterministic metadata (`ATTR_SPEC`, `PROP_META`) for clean JSON ⇄ SOAP mapping
-* ESM **and** CommonJS friendly output
+**TypeScript WSDL Client** is a generator that converts WSDL/XSD files into a fully-typed SOAP client for TypeScript. It simplifies SOAP integration by generating deterministic, type-safe code that works seamlessly with modern TypeScript and Node.js environments.
-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)
+Key features:
+- **Typed SOAP client**: Generates TypeScript interfaces and runtime code.
+- **Deterministic metadata**: Ensures clean JSON ⇄ SOAP mapping.
+- **ESM and CommonJS support**: Compatible with modern and legacy module systems.
+- **Customizable mappings**: Control how XML primitives (e.g., `xs:decimal`, `xs:date`) are mapped.
+Vendor: **[TechSpokes](https://www.techspokes.com)**
+Maintainer: **Serge Liatko** ([@sergeliatko](https://github.com/sergeliatko))
 ---
-## Quick start
+## Installation
-Install the generator (dev-time) in your project:
+Install the generator as a development dependency:
 ```bash
 npm i -D @techspokes/typescript-wsdl-client
-# your app will use node-soap at runtime:
+# Your app will use node-soap at runtime:
 npm i soap
 ```
-Generate into your app (recommended under `src/generated/...`):
+---
+## Quick Start
+### Generate a SOAP Client
+Run the following command to generate a client from your WSDL file:
 ```bash
 npx wsdl-tsc --wsdl ./spec/wsdl/MyService.wsdl --out ./src/generated/my --imports js --ops-ts
 ```
-Use the generated client:
+### Use the Generated Client
 ```ts
-// ESM / NodeNext app
 import { createSoapClient } from "./generated/my/runtime.js";
-// class name defaults to <ServiceName>SoapClient (from WSDL), e.g., MyServiceSoapClient
 import { MyServiceSoapClient } from "./generated/my/client.js";
-// optional: pass security straight into createSoapClient (node-soap security instance)
 import soap from "soap";
-const security = new soap.WSSecurity("user", "pass");
+const security = new soap.WSSecurity("user", "pass");
 const soapClient = await createSoapClient({
   wsdlUrl: "https://example.com/MyService?wsdl",
-  security, // or configure after creation: (await createSoapClient(...)).setSecurity(security)
+  security,
 });
-const client = new MyServiceSoapClient(soapClient, "$attributes"); // attributes key optional
-// Example: To set literal text content for an XML element, use the reserved `$value` key.
-// Other keys in the object represent XML attributes (e.g. `MyAttribute`) and child elements (e.g. `MyElement`).
-// This lets you build mixed-content XML: `$value` for text, attribute keys for XML attributes, and element keys for nested elements.
-const rs = await client.MyOperation({
+const client = new MyServiceSoapClient(soapClient, "$attributes");
+const response = await client.MyOperation({
   MyOperationRQ: {
-    MyAttribute: "passed as attribute",
-    MyElement: "passed as child element",
-    $value: "passed text content here",
-  }
+    MyElement: {
+      MyAttribute: "value",
+      ChildElementA: "valueA",
+    },
+  },
 });
-console.log(rs);
+console.log(response);
 ```
-> The generator always emits TypeScript sources (`*.ts`). You compile them with your app.
 ---
-## Security and WS-Policy hints
+## Features
-- node-soap leaves security up to you. Create a security instance (e.g., `new soap.BasicAuthSecurity(...)`, `new soap.WSSecurity(...)`, `new soap.ClientSSLSecurity(...)`) and set it on the client via `client.setSecurity(...)`.
-- The runtime factory `createSoapClient({ wsdlUrl, endpoint?, wsdlOptions?, security? })` accepts an optional `security` and will call `client.setSecurity(security)` for you.
-- The generated client includes minimal WS-Policy hints if your WSDL embeds inline `wsp:Policy` under `wsdl:binding` or `wsdl:binding/wsdl:operation`.
-  - Hints are surfaced in method JSDoc as “Security (WSDL policy hint): …” and in `operations.json`/`operations.ts` as a `security: string[]` field (e.g., `usernameToken`, `https`, `x509`, `messageSecurity`).
-  - These hints are best-effort and not authoritative (no `wsp:PolicyReference` dereferencing yet). They’re intended to nudge you to configure the right security.
-  - At runtime, if an operation has hints and your client has no `security` configured, a console warning is emitted.
+- **Attributes and Child Elements**: Supports both attributes and nested elements in SOAP requests.
+- **Literal Text Values**: Handles mixed content (attributes + text).
+- **Security Integration**: Works with `node-soap` security instances (e.g., `WSSecurity`, `BasicAuthSecurity`).
+- **WS-Policy Hints**: Provides inline hints for security configuration based on WSDL policies.
 ---
-## CLI
-```
-wsdl-tsc --wsdl <path-or-url> --out <dir> [options]
-```
-### Local development
+## CLI Usage
-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:
+The CLI is the primary way to generate SOAP clients.
 ```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**
+### Required Flags
+- `--wsdl`: Path or URL to the WSDL file.
+- `--out`: Output directory for the generated files.
-* `--wsdl` — WSDL path or URL
-* `--out` — output directory (created if missing)
-**Options**
+### Options
 | 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                |
-| `--client-name`     | string    | any                            | —            | Override the exported client class name (exact)                  |
 | `--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                              |
-### Client naming
-- By default, the generated client class is named after the WSDL service: `<ServiceName>SoapClient`.
-- If the service name can’t be determined, we fall back to the WSDL filename: `<WsdlFileBaseName>SoapClient`.
-- If neither is available, we fall back to `GeneratedSoapClient`.
-- You can override the name entirely with `--client-name MyCustomClient` (the exact export name will be used).
-**Primitive mapping (safe defaults)**
-Defaults are **string-first** to avoid precision & timezone surprises:
-* `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.
+## Generated Files
-# What gets generated
+The generator produces the following files in the output directory:
 ```
 <out>/
-  types.ts       # interfaces + type aliases (with @xsd JSDoc: original XML type/occurs)
-  client.ts      # thin operation wrapper (calls into runtime)
-  runtime.ts     # small SOAP runtime: createSoapClient, toSoapArgs, fromSoapResult
-  meta.ts        # ATTR_SPEC, CHILD_TYPE, PROP_META for JSON ⇄ SOAP mapping
-  operations.ts  # compiled operation metadata (name, soapAction, etc.)
-```
-Example: if `User` has `@Id` and `@CreatedAt`, you’ll see:
-```ts
-interface User {
-  Id?: string;
-  CreatedAt?: string; // or Date if you chose --date-as Date
-}
+  types.ts       # TypeScript interfaces and type aliases
+  client.ts      # Thin wrapper for SOAP operations
+  runtime.ts     # SOAP runtime utilities
+  meta.ts        # Metadata for JSON ⇄ SOAP mapping
+  operations.ts  # Operation metadata (optional, based on --ops-ts)
 ```
 ---
-## Using in different app module systems
-### ESM / NodeNext (recommended)
+## Advanced Usage
-Service `tsconfig.json`:
+### Programmatic API
-```json
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true
-  }
-}
-```
-Generate with `--imports js` and import `./client.js`, `./runtime.js`.
-### CommonJS
-Keep your app `module: "CommonJS"` and generate with `--imports bare` (imports like `./runtime`).
-TypeScript will compile to `require("./runtime")` cleanly.
----
-## Recommended workflow
-* **Vendor** your WSDL(s) in `spec/wsdl/` for reproducible builds.
-* Generate into `src/generated/<service>/` and **commit the generated files** (deterministic CI/Docker).
-* Build your app (the generated code compiles with it).
-**Example scripts (app `package.json`):**
-```json
-{
-  "scripts": {
-    "codegen:my": "wsdl-tsc --wsdl ./spec/wsdl/MyService.wsdl --out ./src/generated/my --imports js --ops-ts",
-    "prebuild": "npm run codegen:my",
-    "build": "tsc -p tsconfig.json"
-  }
-}
-```
----
-## Programmatic API (optional)
+You can use the generator programmatically for custom workflows:
 ```ts
-import { compileCatalog, xsdToTsPrimitive, type CompilerOptions } from "@techspokes/typescript-wsdl-client";
-import { loadWsdlCatalog } from "@techspokes/typescript-wsdl-client/internal-or-your-loader"; // if you expose it
+import { compileCatalog } from "@techspokes/typescript-wsdl-client";
 const catalog = await loadWsdlCatalog("./spec/wsdl/MyService.wsdl");
 const compiled = compileCatalog(catalog, {
-  primitive: { decimalAs: "string", dateAs: "string" }
+  primitive: { decimalAs: "string", dateAs: "string" },
 });
-// …write your own emitters or use the built-ins in the CLI.
-```
----
-## Primitive mapping rationale
-Defaults are **string-first** to avoid precision & timezone surprises:
-* `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)
-Change per your needs with the CLI flags above.
----
-## Minimal test you can run
-```bash
-# generate from a local WSDL
-npx wsdl-tsc --wsdl ./spec/wsdl/MyService.wsdl --out ./tmp --imports js --ops-ts
-# quick typecheck of generated output (NodeNext)
-npx tsc --noEmit --module NodeNext --moduleResolution NodeNext --target ES2022 ./tmp/*.ts
+// Use the compiled output as needed.
 ```
 ---
 ## Troubleshooting
-* **“I don’t see `runtime.ts`”** — You should. Ensure you’re on a recent version and check that the output directory is writable.
-* **“Cannot find './runtime.js'”** — Your app must be `module: "NodeNext"` when using `--imports js`.
-  Use `--imports bare` for CommonJS apps.
-* **“node-soap not found”** — Install it in your **app**: `npm i soap`.
-* **“Security required?”** — If your generated client warns or JSDoc shows a security hint, configure node-soap security: `client.setSecurity(new soap.WSSecurity(...))` or pass `security` to `createSoapClient`.
+- **Missing `runtime.ts`**: Ensure the output directory is writable and you're using the latest version.
+- **Module system issues**: Use `--imports js` for ESM/NodeNext or `--imports bare` for CommonJS.
+- **Security warnings**: Configure `node-soap` security (e.g., `WSSecurity`) as needed.
 ---
-## Contributing
-Issues and PRs welcome. Please include a **minimal WSDL/XSD** fixture that reproduces the case.
-Node 20+ supported.
+## Roadmap
-- See CONTRIBUTING.md for setup and workflow.
-- See CODE_OF_CONDUCT.md for community expectations.
-- Security reports: see SECURITY.md.
+Please see the [ROADMAP.md](ROADMAP.md) for planned features and improvements.
 ---
-## Community
+## Contributing
-- Contributing guide: CONTRIBUTING.md
-- Code of Conduct: CODE_OF_CONDUCT.md
-- Security policy: SECURITY.md
-- Support: SUPPORT.md
-- Roadmap: ROADMAP.md
-- Changelog: CHANGELOG.md
+We welcome contributions! Please see the following resources:
+- [CONTRIBUTING.md](CONTRIBUTING.md): Development workflow and guidelines.
+- [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md): Community expectations.
+- [SECURITY.md](SECURITY.md): Reporting vulnerabilities.
 ---
@@ -306,9 +181,10 @@ MIT © TechSpokes.
 - Your Name Here!
 **Gold Sponsors**
-- [Your Name or Company](https://your-link-here.com)
+- [Your Name or Company (with a link) Here!](https://your-link-here.com)
 **Platinum Sponsors**
-- [Your Name or Company](https://your-link-here.com) – 30-min one-to-one video meeting on AI, business automations, vacation rentals industry, development, tools, or a subject of your choice.
+- [Your Name or Company (with a link) Here!](https://your-link-here.com)
+- **AND** 30-min one-to-one video meeting on AI, business automations, vacation rentals industry, development, tools, or a subject of your choice.
 Want to see your name or company here? [Become a sponsor!](https://github.com/sponsors/TechSpokes)

package/dist/compiler/schemaCompiler.d.ts CHANGED Viewed

@@ -22,6 +22,21 @@ export type CompiledType = {
         declaredType: string;
     }>;
     jsdoc?: string;
+    base?: string;
+    localAttrs?: Array<{
+        name: string;
+        tsType: string;
+        use?: "required" | "optional";
+        declaredType: string;
+    }>;
+    localElems?: Array<{
+        name: string;
+        tsType: string;
+        min: number;
+        max: number | "unbounded";
+        nillable?: boolean;
+        declaredType: string;
+    }>;
 };
 export type CompiledAlias = {
     name: string;

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

	@@ -1 +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;QACtB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;KACrB,CAAC,CAAC;IACH,YAAY,EAAE,MAAM,CAAC;IAErB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AA6DF;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,WAAW,EAAE,KAAK,EAAE,eAAe,GAAG,eAAe,~~CA2gBxF~~"}
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;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,UAAU,CAAC,EAAE,KAAK,CAAC;QACjB,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;IAEH,UAAU,CAAC,EAAE,KAAK,CAAC;QACjB,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;CACJ,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;QACtB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;KACrB,CAAC,CAAC;IACH,YAAY,EAAE,MAAM,CAAC;IAErB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AA6DF;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,WAAW,EAAE,KAAK,EAAE,eAAe,GAAG,eAAe,CA2fxF"}

package/dist/compiler/schemaCompiler.js CHANGED Viewed

@@ -176,21 +176,10 @@ export function compileCatalog(cat, _opts) {
     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);
-        // mergeAttrs: combine base attributes with local ones, overriding duplicates by name
+        // hoisted helpers for merging and collecting
         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) {
@@ -198,11 +187,10 @@ export function compileCatalog(cat, _opts) {
                     into.push(a);
                 }
                 else {
-                    into[pos] = a; // override existing attribute details
+                    into[pos] = a;
                 }
             }
         };
-        // 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));
@@ -213,12 +201,10 @@ export function compileCatalog(cat, _opts) {
                     into.push(e);
                 }
                 else {
-                    into[pos] = e; // override existing element details
+                    into[pos] = e;
                 }
             }
         };
-        // 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");
@@ -243,28 +229,20 @@ export function compileCatalog(cat, _opts) {
             }
             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 = [
-                ...getChildrenWithLocalName(node, "sequence"),
-                ...getChildrenWithLocalName(node, "all"),
-                ...getChildrenWithLocalName(node, "choice"),
-            ];
-            for (const grp of groups) {
-                for (const e of getChildrenWithLocalName(grp, "element")) {
+            // process a compositor or element container recursively
+            const recurse = (groupNode) => {
+                // handle direct element children
+                for (const e of getChildrenWithLocalName(groupNode, "element")) {
                     const nameOrRef = e["@_name"] || e["@_ref"];
-                    if (!nameOrRef) {
+                    if (!nameOrRef)
                         continue;
-                    }
                     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 complexType: create a nested interface with a generated name
                     const inlineComplex = getFirstWithLocalName(e, "complexType");
                     const inlineSimple = getFirstWithLocalName(e, "simpleType");
                     if (inlineComplex) {
@@ -273,22 +251,41 @@ export function compileCatalog(cat, _opts) {
                         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 });
                     }
                     else {
-                        // 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 });
                     }
                 }
-            }
+                // recurse into nested compositor groups
+                for (const comp of ["sequence", "all", "choice"]) {
+                    for (const sub of getChildrenWithLocalName(groupNode, comp)) {
+                        recurse(sub);
+                    }
+                }
+            };
+            recurse(node);
             return out;
         };
-        // Result accumulators
+        const present = compiledMap.get(key);
+        if (present) {
+            // On duplicate definitions, merge new attributes and elements
+            const newAttrs = collectAttributes(cnode);
+            const newElems = collectParticles(outName, cnode);
+            mergeAttrs(present.attrs, newAttrs);
+            mergeElems(present.elems, newElems);
+            return present;
+        }
+        if (inProgress.has(key)) {
+            // minimal cycle break
+            return { name: outName, ns: schemaNS, attrs: [], elems: [] };
+        }
+        inProgress.add(key);
+        // result accumulators
         const attrs = [];
         const elems = [];
         // Inheritance: complexContent
@@ -298,21 +295,26 @@ export function compileCatalog(cat, _opts) {
             const res = getFirstWithLocalName(complexContent, "restriction");
             const node = ext || res;
             if (node) {
+                // handle complexContent extension: record base and separate local additions
+                let baseName;
                 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);
+                        const baseType = getOrCompileComplex(baseRec.node["@_name"], baseRec.node, baseRec.tns, baseRec.prefixes);
+                        baseName = baseType.name;
+                        // inherit base members
+                        attrs.push(...baseType.attrs);
+                        elems.push(...baseType.elems);
                     }
                 }
-                // local additions/overrides
-                mergeAttrs(attrs, collectAttributes(node));
-                mergeElems(elems, collectParticles(outName, node));
-                const result = { name: outName, ns: schemaNS, attrs, elems };
+                // collect local additions/overrides
+                const locals = collectAttributes(node);
+                const localElems = collectParticles(outName, node);
+                attrs.push(...locals);
+                elems.push(...localElems);
+                const result = { name: outName, ns: schemaNS, attrs, elems, base: baseName, localAttrs: locals, localElems };
                 compiledMap.set(key, result);
                 inProgress.delete(key);
                 return result;

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

	@@ -1 +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;AAGpD,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,EAAE,IAAI,EAAE,eAAe,GAAG;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,~~QAkDpH~~"}
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;AAGpD,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,EAAE,IAAI,EAAE,eAAe,GAAG;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,QAmEpH"}

package/dist/emit/clientEmitter.js CHANGED Viewed

@@ -18,6 +18,15 @@ export function emitClient(outFile, compiled, opts) {
         return noExt ? pascal(noExt) : "";
     })();
     const className = overrideName || ((svcName || fileBase) ? `${svcName || fileBase}SoapClient` : "GeneratedSoapClient");
+    // Helpers for emitting safe method names
+    const isValidIdent = (name) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name);
+    const reserved = new Set([
+        "break", "case", "catch", "class", "const", "continue", "debugger", "default", "delete",
+        "do", "else", "enum", "export", "extends", "false", "finally", "for", "function", "if",
+        "import", "in", "instanceof", "new", "null", "return", "super", "switch", "this", "throw",
+        "true", "try", "typeof", "var", "void", "while", "with", "as", "implements", "interface",
+        "let", "package", "private", "protected", "public", "static", "yield", "constructor"
+    ]);
     lines.push(`export class ${className} {`);
     lines.push(`  constructor(private source: string | any, private attributesKey: string = "${opts.attributesKey || "$attributes"}") {}`);
     lines.push(`  async _client() {`);
@@ -33,17 +42,23 @@ export function emitClient(outFile, compiled, opts) {
         const inMetaKey = inTypeName ?? m;
         const outMetaKey = outTypeName ?? m;
         const secHints = Array.isArray(op.security) && op.security.length ? op.security : [];
+        const methodHeader = (isValidIdent(m) && !reserved.has(m))
+            ? `  async ${m}(args: ${inTs}): Promise<${outTs}> {`
+            : `  async [${JSON.stringify(m)}](args: ${inTs}): Promise<${outTs}> {`;
+        const clientCall = (isValidIdent(m) && !reserved.has(m))
+            ? `c.${m}`
+            : `c[${JSON.stringify(m)}]`;
         lines.push(`  /** SOAPAction: ${op.soapAction}${secHints.length ? `\n   * Security (WSDL policy hint): ${secHints.join(", ")}` : ""} */`);
-        lines.push(`  async ${m}(args: ${inTs}): Promise<${outTs}> {`);
+        lines.push(methodHeader);
         lines.push(`    const c: any = await this._client();`);
         if (secHints.length) {
             lines.push(`    if (!c || !c.security) { console.warn("[wsdl-client] Operation '${m}' may require security: ${secHints.join(", ")}. Configure client.setSecurity(...) or pass { security } to createSoapClient()."); }`);
         }
         lines.push(`    const meta = { ATTR_SPEC, CHILD_TYPE, PROP_META } as const;`);
-        lines.push(`    const soapArgs = toSoapArgs(args as any, "${inMetaKey}", meta, this.attributesKey);`);
+        lines.push(`    const soapArgs = toSoapArgs(args as any, ${JSON.stringify(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, "${outMetaKey}", meta, this.attributesKey));`);
+        lines.push(`      ${clientCall}(soapArgs, (err: any, result: any) => {`);
+        lines.push(`        if (err) reject(err); else resolve(fromSoapResult(result, ${JSON.stringify(outMetaKey)}, meta, this.attributesKey));`);
         lines.push(`      });`);
         lines.push(`    });`);
         lines.push(`  }`);

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

	@@ -1 +1 @@
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~~"}
1	+ {"version":3,"file":"typesEmitter.d.ts","sourceRoot":"","sources":["../../src/emit/typesEmitter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,eAAe,EAAe,MAAM,+BAA+B,CAAC;AAEjF;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,QA2InE"}

package/dist/emit/typesEmitter.js CHANGED Viewed

@@ -11,37 +11,71 @@ export function emitTypes(outFile, compiled) {
     const lines = [];
     // Convenience lookups
     const typeNames = new Set(compiled.types.map((t) => t.name));
+    const isValidIdent = (name) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name);
+    const emitPropName = (name) => (isValidIdent(name) ? name : JSON.stringify(name));
     //
     // 1) Named simple types (aliases) first
     //
+    // sort aliases by name to ensure consistent order
+    compiled.aliases.sort((a, b) => a.name.localeCompare(b.name));
     for (const a of compiled.aliases) {
-        const ann = a.jsdoc ? `  /** @xsd ${a.jsdoc} */\n` : "";
+        const ann = a.jsdoc ? `/** @xsd ${a.jsdoc} */\n` : "";
         lines.push(`${ann}export type ${a.name} = ${a.tsType};`);
         lines.push("");
     }
     //
     // 2) Complex types as interfaces
     //
+    // sort types by name to ensure consistent order
+    compiled.types.sort((a, b) => a.name.localeCompare(b.name));
     for (const t of compiled.types) {
-        // Detect mis-mapped simpleContent extension:
-        //   single "$value" whose tsType is another named interface ⇒ extend that interface
+        // Detect complexContent extension via compiled metadata or mis-mapped simpleContent extension
+        const complexBase = t.base;
+        // Detect mis-mapped simpleContent extension: single "$value" whose tsType is another named 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
+        const isSimpleContentExtension = !complexBase && (t.elems?.length || 0) === 1 && valueElems.length === 1;
+        const baseName = complexBase ?? (isSimpleContentExtension ? valueElems[0].tsType : undefined);
+        // Header: extend base type if applicable
         if (baseName) {
             lines.push(`export interface ${t.name} extends ${baseName} {`);
         }
         else {
             lines.push(`export interface ${t.name} {`);
         }
+        // Prepare lists: for complexContent extension use only local additions
+        const attrsToEmit = complexBase ? (t.localAttrs || []) : (t.attrs || []);
+        // Elements list similar
+        let elementsToEmit = complexBase ? (t.localElems || []) : (t.elems || []);
+        // SimpleContent extension special handling drops synthetic $value
+        if (isSimpleContentExtension && !complexBase) {
+            const idx = elementsToEmit.findIndex(e => e.name === "$value");
+            if (idx >= 0)
+                elementsToEmit.splice(idx, 1);
+        }
         //
         // Attributes — with JSDoc on every attribute
         //
-        for (const a of t.attrs || []) {
+        if (0 < attrsToEmit.length) {
+            // add attributes header comment
+            lines.push("");
+            lines.push("  /**");
+            lines.push((1 === t.attrs.length) ? "   * Attribute." : "   * Attributes.");
+            lines.push("   */");
+            // Sort the elements with the following logic: required first (sorted a-z), then optional (sorted a-z)
+            attrsToEmit.sort((a, b) => {
+                // Required attributes come before optional attributes
+                if (a.use === "required" && b.use !== "required")
+                    return -1; // `a` is required, b is optional
+                if (a.use !== "required" && b.use === "required")
+                    return 1; // `a` is optional, b is required
+                // Within the same group (required or optional), sort alphabetically
+                return a.name.localeCompare(b.name);
+            });
+        }
+        for (const a of attrsToEmit) {
             const opt = a.use === "required" ? "" : "?";
             const annObj = {
                 kind: "attribute",
@@ -49,40 +83,54 @@ export function emitTypes(outFile, compiled) {
                 use: a.use || "optional",
             };
             const ann = `  /** @xsd ${JSON.stringify(annObj)} */`;
+            lines.push("");
             lines.push(ann);
-            lines.push(`  ${a.name}${opt}: ${a.tsType};`);
+            lines.push(`  ${emitPropName(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);
+        // elementsToEmit already prepared above
+        if (0 < elementsToEmit.length) {
+            // add elements header comment
+            lines.push("");
+            lines.push("  /**");
+            lines.push((1 === elementsToEmit.length) ? "   * Child element." : "   * Children elements.");
+            lines.push("   */");
+            // Sort the elements with the following logic: required first (sorted a-z), then optional (sorted a-z), and finally "$value" if present.
+            elementsToEmit.sort((a, b) => {
+                // Special case: $value is always last
+                if (a.name === "$value")
+                    return 1;
+                if (b.name === "$value")
+                    return -1;
+                // Required elements come before optional elements
+                if (a.min !== 0 && b.min === 0)
+                    return -1; // `a` is required, b is optional
+                if (a.min === 0 && b.min !== 0)
+                    return 1; // `a` is optional, b is required
+                // Within the same group (required or optional), sort alphabetically
+                return a.name.localeCompare(b.name);
+            });
         }
-        // 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 isArray = e.max === "unbounded" || (e.max > 1);
             const arr = isArray ? "[]" : "";
             const opt = (e.min ?? 0) === 0 ? "?" : "";
             const annObj = {
-                kind: "element",
+                // if a.name === "$value", the kind should be "scalar value"
+                kind: e.name === "$value" ? "scalar value" : "element",
                 type: e.declaredType,
                 occurs: { min: e.min, max: e.max, nillable: e.nillable ?? false },
             };
+            // if the a.name === "$value" and we have more child elements, add an empty line before the annotation
+            if ((e.name === "$value") && (1 < elementsToEmit.length)) {
+                lines.push("");
+            }
             const ann = `  /** @xsd ${JSON.stringify(annObj)} */`;
+            lines.push("");
             lines.push(ann);
-            lines.push(`  ${e.name}${opt}: ${e.tsType}${arr};`);
+            lines.push(`  ${emitPropName(e.name)}${opt}: ${e.tsType}${arr};`);
         }
         lines.push("}");
         lines.push("");

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

	@@ -1 +1 @@
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"}
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,CA6BxC;AAED,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC/B;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAS/B"}

package/dist/util/xml.js CHANGED Viewed

@@ -25,7 +25,35 @@ export function getFirstWithLocalName(node, local) {
 }
 /** 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, "");
+    const raw = String(s ?? "");
+    // Split on underscores to preserve them literally
+    const segments = raw.split("_");
+    const cased = segments.map(seg => {
+        // Uppercase letters after common separators (start, space, dash, dot, colon, slash)
+        const up = seg.replace(/(^|[-\s.:\/])([A-Za-z0-9_$])/g, (_m, _sep, c) => String(c).toUpperCase());
+        // Remove disallowed identifier characters but preserve A-Z, a-z, 0-9, _ and $
+        return up.replace(/[^A-Za-z0-9_$]/g, "");
+    });
+    let out = cased.join("_");
+    if (!out)
+        out = "_"; // fallback
+    if (/^[0-9]/.test(out))
+        out = `_${out}`; // ensure valid identifier start
+    // guard against TypeScript reserved keywords when the identifier equals them exactly
+    const reserved = [
+        "break", "case", "catch", "class", "const", "continue", "debugger", "default", "delete",
+        "do", "else", "enum", "export", "extends", "false", "finally", "for", "function", "if",
+        "import", "in", "instanceof", "new", "null", "return", "super", "switch", "this", "throw",
+        "true", "try", "typeof", "var", "void", "while", "with", "as", "implements", "interface",
+        "let", "package", "private", "protected", "public", "static", "yield", "any", "boolean",
+        "constructor", "declare", "get", "module", "require", "number", "set", "string", "symbol",
+        "type", "from", "of"
+    ];
+    const lower = out.toLowerCase();
+    if (reserved.includes(lower)) {
+        out = `_${out}`;
+    }
+    return out;
 }
 export function resolveQName(qname, defaultNS, prefixes) {
     if (!qname)

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@techspokes/typescript-wsdl-client",
-  "version": "0.2.2",
+  "version": "0.2.6",
   "description": "TypeScript WSDL → SOAP client generator with full xs:attribute support, complex types, sequences, inheritance, and namespace-collision merging.",
   "keywords": [
     "wsdl",