wsdl2ts

This tool generates TypeScript type definitions and SOAP clients from WSDL files. Internally it parses WSDL with fast-xml-parser and constructs/prints TypeScript ASTs using ts-morph.

Installation

``bash
npm i @univa.tech/wsdl2ts
`

Usage

`ts
import { generateFromWsdl } from "wsdl2ts"

await generateFromWsdl({
wsdlPaths: [
"./path/to/foo.wsdl",
"./path/to/bar.wsdl",
],
outDir: "./generated",
esm: true, // defaults to true; set to false to emit CJS-compatible imports without extensions
})
`

- wsdlPaths can mix file and directory paths. Directories are scanned recursively.
- outDir -- The generated files are placed at outDir.
- esm -- defaults to true; set to false to emit CJS-compatible imports without extensions

Generated Output

- types/client.ts
- Declares the shared factory signature once for the entire output:
`ts
import type { Client, IOptions } from "@univa.tech/soap"

export type SoapClientFactory = (
wsdlFileName: string,
options?: IOptions,
) => Promise
`
- /client.ts
- Emits a single ServiceClient interface that aggregates every operation across all portType definitions in the WSDL.
- Each operation produces both callback and Promise-based overloads. Promise variants still resolve to Promise<[result, rawResponse, soapHeader, rawRequest]>.
- Empty request messages reference the shared Void type and remain required parameters (args: Void).
- Provides a createClientAsync helper that uses the shared SoapClientFactory to create strongly typed clients:
`ts
export interface ServiceClient extends Client {
doSomething(args: FooParam, callback: ..., options?: unknown, extraHeaders?: Record): void
doSomethingAsync(args: FooParam, options?: unknown, extraHeaders?: Record): Promise<[result: FooResponse, ...]>
}

export function createClientAsync(
factory: SoapClientFactory,
options?: IOptions,
): Promise {
return factory("foo", options) as Promise
}
`
- types/
- TypeScript interface definitions for each message and complex type
- Message request/response shapes (and the elements/types referenced directly from their parts) are emitted under types//
- Shared complex types that are not tied to a specific message remain directly under types/
- Message bound request/response interfaces reuse the referenced complex type name and are wrapped in a namespace matching the port (e.g. ExamplePort.ExampleRequest)
- Multi-part message wrappers keep a port-prefixed alias to avoid collisions
- Empty complex types are replaced with Void, limited to types directly under messages
- types/index.ts re-exports every file within the directory (per WSDL and for shared types) and includes the shared client.ts barrel
- /index.ts
- Re-exports the WSDL specific client.ts and types/index.ts
- index.ts
- Re-exports each WSDL namespace (e.g. export * as Sample from './sample/index.js') and the shared types/index.ts / types/client.ts`

When processing multiple WSDLs, the generator verifies that types with the same namespace and name share the exact structure. Any differences abort generation and the log states which WSDLs conflicted.