@wirebench/engine 2.1.1

package/dist/wsdl/fetch.js

@@ -0,0 +1,60 @@
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { HttpError } from '../errors.js';
+const DEFAULT_TIMEOUT_MS = 20_000;
+const USER_AGENT = 'wirebench/0.1';
+/**
+ * Decodes bytes as UTF-8, honouring an `<?xml ... encoding="iso-8859-1" ?>`
+ * declaration when present (single-byte, so it is safely sniffable by
+ * decoding the head as UTF-8 first). A `utf-16` declaration would require a
+ * BOM/byte-order sniff before the declaration itself is even legible, which
+ * does not fit a small helper like this — such documents fall back to (and
+ * garble under) UTF-8; use a pre-fetched `text` in that case instead.
+ */
+function decodeXmlBytes(bytes) {
+    const head = new TextDecoder('utf-8').decode(bytes.subarray(0, 200));
+    const match = /^\s*<\?xml[^>]*\bencoding=["']([^"']+)["']/i.exec(head);
+    if (match?.[1]?.toLowerCase() === 'iso-8859-1') {
+        return new TextDecoder('iso-8859-1').decode(bytes);
+    }
+    return new TextDecoder('utf-8').decode(bytes);
+}
+async function fetchFile(location) {
+    const bytes = await readFile(fileURLToPath(location));
+    return { location, bytes: new Uint8Array(bytes), text: decodeXmlBytes(bytes) };
+}
+async function fetchHttp(location, signal) {
+    const timeoutSignal = AbortSignal.timeout(DEFAULT_TIMEOUT_MS);
+    const combinedSignal = signal !== undefined ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+    const response = await fetch(location, {
+        redirect: 'follow',
+        signal: combinedSignal,
+        headers: { 'user-agent': USER_AGENT },
+    });
+    if (!response.ok) {
+        throw new HttpError('fetch-failed', `GET ${location} failed with status ${response.status}`, {
+            details: { location, status: response.status },
+        });
+    }
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    return { location: response.url, bytes, text: decodeXmlBytes(bytes) };
+}
+/**
+ * Creates the default {@link FetchDocument} implementation: `file:` URLs are
+ * read from disk via `node:fs/promises`, and `http(s):` URLs are fetched via
+ * the global `fetch` (following redirects, with a 20s timeout combined with
+ * the caller's `AbortSignal`, and a `wirebench/0.1` User-Agent).
+ *
+ * Text is decoded as UTF-8 by default, honouring an `iso-8859-1` `encoding`
+ * in the document's XML declaration when present (see {@link decodeXmlBytes}
+ * for why `utf-16` isn't sniffed the same way). Other declared encodings
+ * fall back to UTF-8.
+ */
+export function createDefaultFetchDocument() {
+    return async (location, signal) => {
+        if (location.startsWith('file:')) {
+            return fetchFile(location);
+        }
+        return fetchHttp(location, signal);
+    };
+}

package/dist/wsdl/merge.d.ts

@@ -0,0 +1,17 @@
+import type { WsdlDefinition } from './model.js';
+import type { DefinitionBundle } from './resolver.js';
+/**
+ * Merges a resolved {@link DefinitionBundle} into a single {@link WsdlDefinition}.
+ *
+ * Every `wsdl`-kind document in the bundle is parsed with {@link parseWsdlDocument}
+ * and merged: the root's `location`/`targetNamespace`/`documentation`/`imports`
+ * are kept, while `messages`/`portTypes`/`bindings`/`services` are concatenated
+ * (root first, then imports in discovery order) with duplicate QNames resolved
+ * by keeping the first occurrence. `schemaElements` collects the root's own
+ * inline schemas, plus the inline schemas of every imported `wsdl`-kind document,
+ * plus the root `xs:schema` element of every `xsd`-kind document in the bundle
+ * (in that order: root first, then imports in discovery order, then xsd roots).
+ *
+ * @param bundle the bundle produced by {@link resolveDefinition}
+ */
+export declare function parseWsdlBundle(bundle: DefinitionBundle): WsdlDefinition;

package/dist/wsdl/merge.js

@@ -0,0 +1,57 @@
+import { qnameEquals } from './qname.js';
+import { parseWsdlDocument } from './parse-wsdl.js';
+/** Keeps the first occurrence of each expanded QName, dropping later duplicates. */
+function dedupeByQName(items) {
+    const result = [];
+    for (const item of items) {
+        if (!result.some((existing) => qnameEquals(existing.name, item.name))) {
+            result.push(item);
+        }
+    }
+    return result;
+}
+/**
+ * Merges a resolved {@link DefinitionBundle} into a single {@link WsdlDefinition}.
+ *
+ * Every `wsdl`-kind document in the bundle is parsed with {@link parseWsdlDocument}
+ * and merged: the root's `location`/`targetNamespace`/`documentation`/`imports`
+ * are kept, while `messages`/`portTypes`/`bindings`/`services` are concatenated
+ * (root first, then imports in discovery order) with duplicate QNames resolved
+ * by keeping the first occurrence. `schemaElements` collects the root's own
+ * inline schemas, plus the inline schemas of every imported `wsdl`-kind document,
+ * plus the root `xs:schema` element of every `xsd`-kind document in the bundle
+ * (in that order: root first, then imports in discovery order, then xsd roots).
+ *
+ * @param bundle the bundle produced by {@link resolveDefinition}
+ */
+export function parseWsdlBundle(bundle) {
+    const rootDef = parseWsdlDocument(bundle.root.document, bundle.root.location);
+    const importedWsdlDefs = bundle.documents
+        .filter((doc) => doc.kind === 'wsdl' && doc.location !== bundle.root.location)
+        .map((doc) => parseWsdlDocument(doc.document, doc.location));
+    const messages = dedupeByQName([...rootDef.messages, ...importedWsdlDefs.flatMap((d) => d.messages)]);
+    const portTypes = dedupeByQName([...rootDef.portTypes, ...importedWsdlDefs.flatMap((d) => d.portTypes)]);
+    const bindings = dedupeByQName([...rootDef.bindings, ...importedWsdlDefs.flatMap((d) => d.bindings)]);
+    const services = dedupeByQName([...rootDef.services, ...importedWsdlDefs.flatMap((d) => d.services)]);
+    const xsdSchemaElements = bundle.documents
+        .filter((doc) => doc.kind === 'xsd')
+        .map((doc) => doc.document.documentElement)
+        .filter((el) => el !== null);
+    return {
+        location: rootDef.location,
+        targetNamespace: rootDef.targetNamespace,
+        ...(rootDef.documentation !== undefined ? { documentation: rootDef.documentation } : {}),
+        messages,
+        portTypes,
+        bindings,
+        services,
+        schemaElements: [
+            ...rootDef.schemaElements,
+            ...importedWsdlDefs.flatMap((d) => d.schemaElements),
+            ...xsdSchemaElements,
+        ],
+        imports: rootDef.imports,
+        namespaceDeclarations: rootDef.namespaceDeclarations,
+        problems: rootDef.problems,
+    };
+}

package/dist/wsdl/model.d.ts

@@ -0,0 +1,176 @@
+import type { Element } from '@xmldom/xmldom';
+import type { QName } from './qname.js';
+import type { ResolveProblem } from './resolver.js';
+/** A `wsdl:part` within a `wsdl:message`. Exactly one of `element`/`type` is normally present. */
+export interface Part {
+    readonly name: string;
+    readonly element?: QName;
+    readonly type?: QName;
+}
+/** A `wsdl:message` definition. */
+export interface Message {
+    readonly name: QName;
+    readonly documentation?: string;
+    readonly parts: readonly Part[];
+}
+/** Reference to a message from an operation's `wsdl:input`/`wsdl:output`. */
+export interface MessageRef {
+    readonly name?: string;
+    readonly message: QName;
+    /**
+     * The `wsdl:input`/`wsdl:output` element this reference was parsed from, kept so extension
+     * attributes and elements no parser models (notably `wsam:Action`) stay reachable. Absent
+     * only for a reference built programmatically rather than parsed.
+     */
+    readonly sourceElement?: Element;
+}
+/** A `wsdl:fault` within a `wsdl:operation`. */
+export interface Fault {
+    readonly name: string;
+    readonly message: QName;
+    readonly documentation?: string;
+}
+/** A `wsdl:operation` within a `wsdl:portType`. */
+export interface Operation {
+    readonly name: string;
+    readonly documentation?: string;
+    readonly input?: MessageRef;
+    readonly output?: MessageRef;
+    readonly faults: readonly Fault[];
+    readonly parameterOrder?: readonly string[];
+}
+/** A `wsdl:portType` definition (the abstract interface). */
+export interface PortType {
+    readonly name: QName;
+    readonly documentation?: string;
+    readonly operations: readonly Operation[];
+}
+/** `use` attribute of a `soap:body`/`soap:header`/`soap:fault`. */
+export type SoapUse = 'literal' | 'encoded';
+/** A `soap:body` element within a binding operation's input/output. */
+export interface SoapBody {
+    readonly use: SoapUse;
+    readonly parts?: readonly string[];
+    readonly namespace?: string;
+    readonly encodingStyle?: string;
+}
+/** A `soap:headerfault` within a `soap:header`. */
+export interface SoapHeaderFault {
+    readonly message: QName;
+    readonly part: string;
+    readonly use: SoapUse;
+}
+/** A `soap:header` element within a binding operation's input/output. */
+export interface SoapHeader {
+    readonly message: QName;
+    readonly part: string;
+    readonly use: SoapUse;
+    readonly namespace?: string;
+    readonly encodingStyle?: string;
+    readonly headerFaults: readonly SoapHeaderFault[];
+}
+/**
+ * One `mime:content` of a `mime:multipartRelated` binding message: the `wsdl:part` it carries
+ * and the media type the binding declares for it (absent when the WSDL states none).
+ */
+export interface MimePartInfo {
+    readonly part: string;
+    readonly type?: string;
+}
+/** The input or output side of a `wsdl:binding` operation. */
+export interface BindingMessage {
+    readonly body: SoapBody;
+    readonly headers: readonly SoapHeader[];
+    /**
+     * The attachment parts of a WSDL 1.1 `mime:multipartRelated` binding, in document order.
+     * Absent (rather than empty) when the message is a plain `soap:body`, so "no MIME binding"
+     * and "a MIME binding with no content parts" stay distinguishable.
+     */
+    readonly mimeParts?: readonly MimePartInfo[];
+}
+/** A `wsdl:fault` within a `wsdl:binding` operation, carrying its `soap:fault` `use`. */
+export interface BindingFault {
+    readonly name: string;
+    readonly use: SoapUse;
+}
+/** A `wsdl:operation` within a `wsdl:binding`. */
+export interface BindingOperation {
+    readonly name: string;
+    readonly soapAction?: string;
+    readonly style?: 'document' | 'rpc';
+    readonly input?: BindingMessage;
+    readonly output?: BindingMessage;
+    readonly faults: readonly BindingFault[];
+}
+/** SOAP version bound by a `wsdl:binding`, or `'none'` for non-SOAP (e.g. HTTP GET/POST) bindings. */
+export type SoapVersion = '1.1' | '1.2' | 'none';
+/** A `wsdl:binding` definition. */
+export interface Binding {
+    readonly name: QName;
+    readonly type: QName;
+    readonly soapVersion: SoapVersion;
+    readonly style: 'document' | 'rpc';
+    readonly transport?: string;
+    readonly operations: readonly BindingOperation[];
+    /** The `wsdl:binding` element, kept for extensions no parser models (`wsaw:UsingAddressing`, `wsp:Policy`). */
+    readonly sourceElement?: Element;
+}
+/** A `wsdl:port` within a `wsdl:service`. */
+export interface Port {
+    readonly name: string;
+    readonly binding: QName;
+    readonly address?: string;
+    /** The `wsdl:port` element, kept for extensions no parser models (`wsaw:UsingAddressing`, `wsp:Policy`). */
+    readonly sourceElement?: Element;
+}
+/** A `wsdl:service` definition. */
+export interface Service {
+    readonly name: QName;
+    readonly documentation?: string;
+    readonly ports: readonly Port[];
+}
+/** A raw, unresolved `wsdl:import` (namespace/location pair); resolved by Task 6's resolver. */
+export interface WsdlImport {
+    readonly namespace?: string;
+    readonly location: string;
+}
+/**
+ * The parsed model of a single WSDL 1.1 document. `imports` and
+ * `schemaElements` are left raw/unresolved for later tasks (import
+ * resolution in Task 6, XSD compilation in Task 7).
+ */
+export interface WsdlDefinition {
+    readonly location: string;
+    readonly targetNamespace: string;
+    readonly documentation?: string;
+    readonly messages: readonly Message[];
+    readonly portTypes: readonly PortType[];
+    readonly bindings: readonly Binding[];
+    readonly services: readonly Service[];
+    /** Raw `xs:schema` elements found under `wsdl:types`, consumed by Task 7's schema set. */
+    readonly schemaElements: readonly Element[];
+    readonly imports: readonly WsdlImport[];
+    /**
+     * Prefix → namespace URI for every `xmlns:*` declared on the root
+     * `wsdl:definitions` element. WSDL-scoped QName-valued *attribute values*
+     * that no parser resolves (notably `wsdl:arrayType` on a SOAP-encoded array)
+     * are resolved against these.
+     */
+    readonly namespaceDeclarations: Readonly<Record<string, string>>;
+    /**
+     * Problems encountered parsing this WSDL document itself. Import-resolution
+     * problems (failed fetches, unsupported redefines, and the like) live on
+     * the {@link DefinitionBundle}'s `problems`, not here — this is always
+     * empty for the current parser, which does not yet record WSDL-parse-level
+     * problems.
+     */
+    readonly problems: readonly ResolveProblem[];
+}
+/** Finds a `wsdl:message` by expanded name, or `undefined` if not present in this document. */
+export declare function findMessage(def: WsdlDefinition, qname: QName): Message | undefined;
+/** Finds a `wsdl:portType` by expanded name, or `undefined` if not present in this document. */
+export declare function findPortType(def: WsdlDefinition, qname: QName): PortType | undefined;
+/** Finds a `wsdl:binding` by expanded name, or `undefined` if not present in this document. */
+export declare function findBinding(def: WsdlDefinition, qname: QName): Binding | undefined;
+/** Finds a `wsdl:service` by expanded name, or `undefined` if not present in this document. */
+export declare function findService(def: WsdlDefinition, qname: QName): Service | undefined;

package/dist/wsdl/model.js

@@ -0,0 +1,17 @@
+import { qnameEquals } from './qname.js';
+/** Finds a `wsdl:message` by expanded name, or `undefined` if not present in this document. */
+export function findMessage(def, qname) {
+    return def.messages.find((m) => qnameEquals(m.name, qname));
+}
+/** Finds a `wsdl:portType` by expanded name, or `undefined` if not present in this document. */
+export function findPortType(def, qname) {
+    return def.portTypes.find((p) => qnameEquals(p.name, qname));
+}
+/** Finds a `wsdl:binding` by expanded name, or `undefined` if not present in this document. */
+export function findBinding(def, qname) {
+    return def.bindings.find((b) => qnameEquals(b.name, qname));
+}
+/** Finds a `wsdl:service` by expanded name, or `undefined` if not present in this document. */
+export function findService(def, qname) {
+    return def.services.find((s) => qnameEquals(s.name, qname));
+}

package/dist/wsdl/parse-binding.d.ts

@@ -0,0 +1,6 @@
+import type { Element } from '@xmldom/xmldom';
+import type { Binding, Service } from './model.js';
+/** Parses a single `wsdl:binding` element into a {@link Binding}. */
+export declare function parseBinding(bindingEl: Element, location: string, defaultNamespace: string): Binding;
+/** Parses a single `wsdl:service` element into a {@link Service}. */
+export declare function parseService(serviceEl: Element, location: string, defaultNamespace: string): Service;

package/dist/wsdl/parse-binding.js

@@ -0,0 +1,150 @@
+import { NS } from '../xml/namespaces.js';
+import { childElements, firstChildElement, optionalAttribute, readDocumentation, requireAttribute, } from './dom-utils.js';
+import { parseQName } from './qname.js';
+const SOAP_NAMESPACES = [NS.WSDL_SOAP11, NS.WSDL_SOAP12];
+function soapNs(binding) {
+    return SOAP_NAMESPACES.find((ns) => firstChildElement(binding, ns, 'binding') !== undefined);
+}
+function readUse(element) {
+    const use = element !== undefined ? optionalAttribute(element, 'use') : undefined;
+    return use === 'encoded' ? 'encoded' : 'literal';
+}
+function parseSoapBody(element) {
+    const parts = optionalAttribute(element, 'parts');
+    const namespace = optionalAttribute(element, 'namespace');
+    const encodingStyle = optionalAttribute(element, 'encodingStyle');
+    return {
+        use: readUse(element),
+        ...(parts !== undefined ? { parts: parts.split(/\s+/).filter((p) => p.length > 0) } : {}),
+        ...(namespace !== undefined ? { namespace } : {}),
+        ...(encodingStyle !== undefined ? { encodingStyle } : {}),
+    };
+}
+function parseHeaderFault(element, location, defaultNamespace) {
+    return {
+        message: parseQName(requireAttribute(element, 'message', location), element, defaultNamespace),
+        part: requireAttribute(element, 'part', location),
+        use: readUse(element),
+    };
+}
+function parseSoapHeader(element, ns, location, defaultNamespace) {
+    const headerFaults = childElements(element, ns, 'headerfault').map((hf) => parseHeaderFault(hf, location, defaultNamespace));
+    const namespace = optionalAttribute(element, 'namespace');
+    const encodingStyle = optionalAttribute(element, 'encodingStyle');
+    return {
+        message: parseQName(requireAttribute(element, 'message', location), element, defaultNamespace),
+        part: requireAttribute(element, 'part', location),
+        use: readUse(element),
+        ...(namespace !== undefined ? { namespace } : {}),
+        ...(encodingStyle !== undefined ? { encodingStyle } : {}),
+        headerFaults,
+    };
+}
+/**
+ * Splits a `mime:multipartRelated` into the `mime:part` that carries the SOAP envelope (the one
+ * holding `soap:body`) and the `mime:content` declarations of every other part — the attachment
+ * slots the request editor offers a "Part" for.
+ */
+function parseMultipartRelated(multipartEl, ns) {
+    let envelopePart;
+    const mimeParts = [];
+    for (const partEl of childElements(multipartEl, NS.WSDL_MIME, 'part')) {
+        if (firstChildElement(partEl, ns, 'body') !== undefined) {
+            envelopePart ??= partEl;
+            continue;
+        }
+        for (const contentEl of childElements(partEl, NS.WSDL_MIME, 'content')) {
+            const part = optionalAttribute(contentEl, 'part');
+            const type = optionalAttribute(contentEl, 'type');
+            if (part === undefined) {
+                continue;
+            }
+            mimeParts.push({ part, ...(type !== undefined ? { type } : {}) });
+        }
+    }
+    return { ...(envelopePart !== undefined ? { envelopePart } : {}), mimeParts };
+}
+function parseBindingMessage(wsdlMessageEl, ns, location, defaultNamespace) {
+    if (wsdlMessageEl === undefined || ns === undefined) {
+        return undefined;
+    }
+    // In a WSDL 1.1 MIME binding the `soap:body` sits one level down, inside the
+    // `mime:part` that carries the envelope — so the envelope's own `use`/`parts` would be
+    // lost if only the direct children were read.
+    const multipartEl = firstChildElement(wsdlMessageEl, NS.WSDL_MIME, 'multipartRelated');
+    const multipart = multipartEl !== undefined ? parseMultipartRelated(multipartEl, ns) : undefined;
+    const soapOwner = multipart?.envelopePart ?? wsdlMessageEl;
+    const bodyEl = firstChildElement(soapOwner, ns, 'body');
+    const body = bodyEl !== undefined ? parseSoapBody(bodyEl) : { use: 'literal' };
+    const headers = childElements(soapOwner, ns, 'header').map((h) => parseSoapHeader(h, ns, location, defaultNamespace));
+    return { body, headers, ...(multipart !== undefined ? { mimeParts: multipart.mimeParts } : {}) };
+}
+function parseBindingFault(element, ns, location) {
+    const soapFault = ns !== undefined ? firstChildElement(element, ns, 'fault') : undefined;
+    return { name: requireAttribute(element, 'name', location), use: readUse(soapFault) };
+}
+function parseBindingOperation(opEl, ns, location, defaultNamespace) {
+    const soapOp = ns !== undefined ? firstChildElement(opEl, ns, 'operation') : undefined;
+    const styleAttr = soapOp !== undefined ? optionalAttribute(soapOp, 'style') : undefined;
+    const soapAction = soapOp !== undefined ? optionalAttribute(soapOp, 'soapAction') : undefined;
+    const inputEl = firstChildElement(opEl, NS.WSDL, 'input');
+    const outputEl = firstChildElement(opEl, NS.WSDL, 'output');
+    const input = parseBindingMessage(inputEl, ns, location, defaultNamespace);
+    const output = parseBindingMessage(outputEl, ns, location, defaultNamespace);
+    const faults = childElements(opEl, NS.WSDL, 'fault').map((f) => parseBindingFault(f, ns, location));
+    return {
+        name: requireAttribute(opEl, 'name', location),
+        ...(soapAction !== undefined ? { soapAction } : {}),
+        ...(styleAttr === 'rpc' || styleAttr === 'document' ? { style: styleAttr } : {}),
+        ...(input !== undefined ? { input } : {}),
+        ...(output !== undefined ? { output } : {}),
+        faults,
+    };
+}
+/** Parses a single `wsdl:binding` element into a {@link Binding}. */
+export function parseBinding(bindingEl, location, defaultNamespace) {
+    const ns = soapNs(bindingEl);
+    const soapBindingEl = ns !== undefined ? firstChildElement(bindingEl, ns, 'binding') : undefined;
+    const soapVersion = ns === NS.WSDL_SOAP11 ? '1.1' : ns === NS.WSDL_SOAP12 ? '1.2' : 'none';
+    const styleAttr = soapBindingEl !== undefined ? optionalAttribute(soapBindingEl, 'style') : undefined;
+    const transport = soapBindingEl !== undefined ? optionalAttribute(soapBindingEl, 'transport') : undefined;
+    const operations = childElements(bindingEl, NS.WSDL, 'operation').map((op) => parseBindingOperation(op, ns, location, defaultNamespace));
+    return {
+        name: { namespaceUri: defaultNamespace, localName: requireAttribute(bindingEl, 'name', location) },
+        type: parseQName(requireAttribute(bindingEl, 'type', location), bindingEl, defaultNamespace),
+        soapVersion,
+        style: styleAttr === 'rpc' ? 'rpc' : 'document',
+        ...(transport !== undefined ? { transport } : {}),
+        operations,
+        sourceElement: bindingEl,
+    };
+}
+function readAddress(portEl) {
+    for (const ns of [NS.WSDL_SOAP11, NS.WSDL_SOAP12, NS.WSDL_HTTP]) {
+        const addressEl = firstChildElement(portEl, ns, 'address');
+        if (addressEl !== undefined) {
+            return optionalAttribute(addressEl, 'location');
+        }
+    }
+    return undefined;
+}
+function parsePort(portEl, location, defaultNamespace) {
+    const address = readAddress(portEl);
+    return {
+        name: requireAttribute(portEl, 'name', location),
+        binding: parseQName(requireAttribute(portEl, 'binding', location), portEl, defaultNamespace),
+        ...(address !== undefined ? { address } : {}),
+        sourceElement: portEl,
+    };
+}
+/** Parses a single `wsdl:service` element into a {@link Service}. */
+export function parseService(serviceEl, location, defaultNamespace) {
+    const documentation = readDocumentation(serviceEl, NS.WSDL);
+    const ports = childElements(serviceEl, NS.WSDL, 'port').map((p) => parsePort(p, location, defaultNamespace));
+    const name = { namespaceUri: defaultNamespace, localName: requireAttribute(serviceEl, 'name', location) };
+    return {
+        name,
+        ...(documentation !== undefined ? { documentation } : {}),
+        ports,
+    };
+}

package/dist/wsdl/parse-wsdl.d.ts

@@ -0,0 +1,47 @@
+import type { Document } from '@xmldom/xmldom';
+import type { WsdlDefinition } from './model.js';
+import type { FetchDocument } from './resolver.js';
+/**
+ * Source of a WSDL document. `text` is required when `resolveImports` is
+ * `false` (there is nothing to fetch it with); it is optional when
+ * `resolveImports` is `true`, in which case an absent `text` is fetched via
+ * `fetchDocument`.
+ */
+export interface WsdlDocumentSource {
+    readonly location: string;
+    readonly text?: string;
+}
+/** Options for {@link parseWsdl}. */
+export interface ParseWsdlOptions {
+    /** Fetches a WSDL/XSD document by location. Unused while `resolveImports` is `false`. */
+    readonly fetchDocument: FetchDocument;
+    /** Whether to follow `wsdl:import`/`xsd:import`/`xsd:include`/`xsd:redefine`. */
+    readonly resolveImports: boolean;
+    readonly signal?: AbortSignal;
+}
+/**
+ * Parses a single, already-loaded WSDL 1.1 `Document` into a {@link WsdlDefinition}.
+ *
+ * Pure and synchronous: it does not resolve `wsdl:import`s or fetch anything,
+ * and does not validate cross-references (e.g. a binding's `type` pointing at
+ * an unknown `portType`) — only structural requirements of the WSDL document
+ * itself (required attributes) are enforced.
+ *
+ * @param doc the parsed WSDL document
+ * @param location a human-readable origin for the document, echoed into the resulting model and errors
+ * @throws {WsdlParseError} with code `not-a-wsdl` if the root element is not `{NS.WSDL}definitions`
+ * @throws {WsdlParseError} with code `wsdl-invalid` for structural errors (e.g. a missing required attribute)
+ */
+export declare function parseWsdlDocument(doc: Document, location: string): WsdlDefinition;
+/**
+ * Parses a WSDL 1.1 document, given its root source.
+ *
+ * When `options.resolveImports` is `false`, only `root.text` is parsed as a
+ * single document (`fetchDocument` is unused). When `true`, the full import
+ * graph (`wsdl:import`/`xsd:import`/`xsd:include`/`xsd:redefine`) is resolved
+ * via {@link resolveDefinition} and merged via {@link parseWsdlBundle}.
+ *
+ * @throws {WsdlParseError} propagated from {@link parseWsdlDocument} for `not-a-wsdl`/`wsdl-invalid`
+ * @throws {WsdlParseError} with code `fetch-failed` if the root document cannot be fetched while resolving imports
+ */
+export declare function parseWsdl(root: WsdlDocumentSource, options: ParseWsdlOptions): Promise<WsdlDefinition>;