@wirebench/engine 2.1.1

package/dist/validate/wsi/assertions/helpers.js

@@ -0,0 +1,387 @@
+/**
+ * Shared DOM navigation for the WS-I assertions.
+ *
+ * The assertions work on the *raw* documents rather than the merged {@link WsdlDefinition}: the
+ * profile constrains constructs the model normalizes away (a missing `use` attribute, a `parts`
+ * list, the order of `wsdl:input`/`wsdl:output`), and findings need the document and position the
+ * offending element actually came from.
+ */
+import { NS } from '../../../xml/namespaces.js';
+import { getPosition } from '../../../xml/parse.js';
+import { childElements, firstChildElement, optionalAttribute } from '../../../wsdl/dom-utils.js';
+import { parseQName, qnameToString } from '../../../wsdl/qname.js';
+/** The two WSDL SOAP binding namespaces, in the order they are probed. */
+export const SOAP_BINDING_NAMESPACES = [NS.WSDL_SOAP11, NS.WSDL_SOAP12];
+/** Every `wsdl:definitions` document in the bundle, in discovery order. */
+export function wsdlDocuments(context) {
+    const views = [];
+    for (const doc of context.bundle.documents) {
+        const root = context.documents.get(doc.location)?.documentElement ?? null;
+        if (root !== null && root.namespaceURI === NS.WSDL && root.localName === 'definitions') {
+            views.push({ location: doc.location, definitions: root });
+        }
+    }
+    return views;
+}
+/** Every `xs:schema` element in the bundle: the inline ones first, then standalone XSD roots. */
+export function schemaElements(context) {
+    const views = [];
+    for (const doc of context.bundle.documents) {
+        const root = context.documents.get(doc.location)?.documentElement ?? null;
+        if (root === null) {
+            continue;
+        }
+        if (root.namespaceURI === NS.WSDL && root.localName === 'definitions') {
+            const typesEl = firstChildElement(root, NS.WSDL, 'types');
+            if (typesEl !== undefined) {
+                for (const schema of childElements(typesEl, NS.XSD, 'schema')) {
+                    views.push({ location: doc.location, schema });
+                }
+            }
+        }
+        else if (root.namespaceURI === NS.XSD && root.localName === 'schema') {
+            views.push({ location: doc.location, schema: root });
+        }
+    }
+    return views;
+}
+/** Every descendant element of `root` (excluding `root` itself), depth first. */
+export function descendants(root) {
+    const out = [];
+    const visit = (parent) => {
+        let child = parent.firstChild;
+        while (child !== null) {
+            if (child.nodeType === 1) {
+                const element = child;
+                out.push(element);
+                visit(element);
+            }
+            child = child.nextSibling;
+        }
+    };
+    visit(root);
+    return out;
+}
+/** The SOAP binding namespace a `wsdl:binding` uses, or `undefined` when it is not a SOAP binding. */
+export function soapNamespaceOf(binding) {
+    return SOAP_BINDING_NAMESPACES.find((ns) => firstChildElement(binding, ns, 'binding') !== undefined);
+}
+/** Every `wsdl:binding` that is a SOAP binding, across the whole bundle. */
+export function soapBindings(context) {
+    const views = [];
+    for (const doc of wsdlDocuments(context)) {
+        for (const binding of childElements(doc.definitions, NS.WSDL, 'binding')) {
+            const soapNs = soapNamespaceOf(binding);
+            const soapBinding = soapNs === undefined ? undefined : firstChildElement(binding, soapNs, 'binding');
+            if (soapNs !== undefined && soapBinding !== undefined) {
+                views.push({ location: doc.location, binding, soapNs, soapBinding });
+            }
+        }
+    }
+    return views;
+}
+/** The effective style of one binding operation: its own `soapbind:operation/@style`, else the binding's. */
+export function operationStyle(view, operation) {
+    const soapOperation = firstChildElement(operation, view.soapNs, 'operation');
+    const own = soapOperation === undefined ? undefined : optionalAttribute(soapOperation, 'style');
+    if (own === 'rpc' || own === 'document') {
+        return own;
+    }
+    return optionalAttribute(view.soapBinding, 'style') === 'rpc' ? 'rpc' : 'document';
+}
+/** The `wsdl:input`/`wsdl:output` children of a binding operation, in document order. */
+export function bindingMessages(operation) {
+    return [...childElements(operation, NS.WSDL, 'input'), ...childElements(operation, NS.WSDL, 'output')];
+}
+/** The `soapbind:body` of a binding `wsdl:input`/`wsdl:output`, if it declares one. */
+export function soapBodyOf(message, soapNs) {
+    return firstChildElement(message, soapNs, 'body');
+}
+/** Resolves a QName-valued attribute against the in-scope prefixes of `element`. */
+export function attributeQName(element, attribute, defaultNamespace) {
+    const raw = optionalAttribute(element, attribute);
+    if (raw === undefined) {
+        return undefined;
+    }
+    try {
+        return parseQName(raw, element, defaultNamespace);
+    }
+    catch {
+        // An unbound prefix is a well-formedness problem the WSDL parser reports; for the profile
+        // assertions the reference is simply unresolvable.
+        return undefined;
+    }
+}
+/** The `targetNamespace` of the `wsdl:definitions` an element belongs to (empty string when absent). */
+export function targetNamespaceOf(definitions) {
+    return optionalAttribute(definitions, 'targetNamespace') ?? '';
+}
+/**
+ * Every namespace the description defines or imports: the `targetNamespace` of each
+ * `wsdl:definitions` and each `xs:schema` of the bundle, the `namespace` of each
+ * `wsdl:import`/`xs:import`, and the XML Schema namespace itself (always available to a
+ * description). This is the set R2101 and R2102 measure their QName references against.
+ */
+export function declaredNamespaces(context) {
+    const known = new Set([NS.XSD, ...context.schemaSet.namespaces]);
+    for (const doc of wsdlDocuments(context)) {
+        known.add(targetNamespaceOf(doc.definitions));
+        for (const importEl of childElements(doc.definitions, NS.WSDL, 'import')) {
+            const namespace = optionalAttribute(importEl, 'namespace');
+            if (namespace !== undefined) {
+                known.add(namespace);
+            }
+        }
+    }
+    for (const view of schemaElements(context)) {
+        known.add(optionalAttribute(view.schema, 'targetNamespace') ?? '');
+        for (const importEl of childElements(view.schema, NS.XSD, 'import')) {
+            const namespace = optionalAttribute(importEl, 'namespace');
+            if (namespace !== undefined) {
+                known.add(namespace);
+            }
+        }
+    }
+    return known;
+}
+const indexCache = new WeakMap();
+/** Indexes every `wsdl:message` and `wsdl:portType` of the bundle by expanded name (cached per context). */
+export function wsdlIndex(context) {
+    const cached = indexCache.get(context);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const messages = new Map();
+    const portTypes = new Map();
+    for (const doc of wsdlDocuments(context)) {
+        const tns = targetNamespaceOf(doc.definitions);
+        for (const [localName, target] of [
+            ['message', messages],
+            ['portType', portTypes],
+        ]) {
+            for (const element of childElements(doc.definitions, NS.WSDL, localName)) {
+                const name = optionalAttribute(element, 'name');
+                if (name !== undefined) {
+                    const key = qnameToString({ namespaceUri: tns, localName: name });
+                    if (!target.has(key)) {
+                        target.set(key, { location: doc.location, element });
+                    }
+                }
+            }
+        }
+    }
+    const index = { messages, portTypes };
+    indexCache.set(context, index);
+    return index;
+}
+/** Looks a `wsdl:message` up by the QName an attribute of `element` refers to. */
+export function referencedMessage(context, element, attribute, defaultNamespace) {
+    const qname = attributeQName(element, attribute, defaultNamespace);
+    return qname === undefined ? undefined : wsdlIndex(context).messages.get(qnameToString(qname));
+}
+/** The `wsdl:part` children of a `wsdl:message`. */
+export function messageParts(message) {
+    return childElements(message, NS.WSDL, 'part');
+}
+/** Finds a `wsdl:part` of `message` by name. */
+export function findPart(message, name) {
+    return messageParts(message).find((part) => optionalAttribute(part, 'name') === name);
+}
+/** A readable element path, using `@name` where an element has one and a position index otherwise. */
+export function xpathOf(element) {
+    const steps = [];
+    let current = element;
+    while (current !== null && current.nodeType === 1) {
+        const name = optionalAttribute(current, 'name');
+        steps.unshift(`${current.localName ?? current.nodeName}${name !== undefined ? `[@name='${name}']` : ''}`);
+        const parent = current.parentNode;
+        current = parent !== null && parent.nodeType === 1 ? parent : null;
+    }
+    return `/${steps.join('/')}`;
+}
+/** Builds a finding pointing at `element` in the document at `location`. */
+export function findingAt(location, element, message) {
+    const position = getPosition(element);
+    return {
+        message,
+        location: { document: location, ...(position !== undefined ? position : {}), xpath: xpathOf(element) },
+    };
+}
+/** True when `value` is an absolute URI (a scheme followed by a scheme-specific part). */
+export function isAbsoluteUri(value) {
+    return /^[A-Za-z][A-Za-z0-9+.-]*:/.test(value);
+}
+/** Resolves a relative reference against a base location, returning `undefined` when it is not resolvable. */
+export function resolveAgainst(reference, base) {
+    try {
+        return new URL(reference, base).toString();
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Looks a bundled document up by the location one of its importers referenced. */
+export function bundledDocumentFor(context, resolvedLocation) {
+    return context.bundle.documents.find((doc) => doc.location === resolvedLocation || doc.requestedLocation === resolvedLocation);
+}
+/**
+ * The names of `abstractMessage`'s parts that a `soapbind:header` or `soapbind:headerfault` of
+ * `operation` binds. A header names its message explicitly, so only the headers pointing at this
+ * very message count.
+ */
+function headerBoundPartNames(context, operation, soapNs, tns, abstractMessage) {
+    const names = new Set();
+    if (abstractMessage === undefined) {
+        return names;
+    }
+    for (const message of bindingMessages(operation)) {
+        for (const header of childElements(message, soapNs, 'header')) {
+            for (const element of [header, ...childElements(header, soapNs, 'headerfault')]) {
+                const referenced = referencedMessage(context, element, 'message', tns);
+                if (referenced?.element !== abstractMessage.element) {
+                    continue;
+                }
+                for (const name of (optionalAttribute(element, 'part') ?? '').split(/\s+/)) {
+                    if (name.length > 0) {
+                        names.add(name);
+                    }
+                }
+            }
+        }
+    }
+    return names;
+}
+/** The `wsdl:portType` a binding refers to, when it resolves. */
+export function portTypeOf(context, view, definitions) {
+    const qname = attributeQName(view.binding, 'type', targetNamespaceOf(definitions));
+    return qname === undefined ? undefined : wsdlIndex(context).portTypes.get(qnameToString(qname));
+}
+/**
+ * Every side of one binding `wsdl:operation` a message can be bound on: its `wsdl:input`, its
+ * `wsdl:output`, and each of its `wsdl:fault`s (a binding operation may declare several, told
+ * apart by `@name`).
+ */
+function bindingSides(operation) {
+    const sides = [];
+    for (const direction of ['input', 'output']) {
+        const element = firstChildElement(operation, NS.WSDL, direction);
+        if (element !== undefined) {
+            sides.push([direction, element]);
+        }
+    }
+    for (const fault of childElements(operation, NS.WSDL, 'fault')) {
+        sides.push(['fault', fault]);
+    }
+    return sides;
+}
+/** The abstract `wsdl:input`/`output`/`fault` matching one binding side, when the port type has one. */
+function abstractSideFor(abstractOperation, direction, messageElement) {
+    if (direction !== 'fault') {
+        return firstChildElement(abstractOperation, NS.WSDL, direction);
+    }
+    // Faults are matched by name: an operation may declare more than one, and only the abstract
+    // fault of the same name carries the wsdl:message the binding fault actually binds.
+    const name = optionalAttribute(messageElement, 'name');
+    return childElements(abstractOperation, NS.WSDL, 'fault').find((candidate) => optionalAttribute(candidate, 'name') === name);
+}
+/** Joins every binding operation's input/output to the abstract message it binds. */
+export function boundMessages(context) {
+    const views = [];
+    for (const doc of wsdlDocuments(context)) {
+        const tns = targetNamespaceOf(doc.definitions);
+        for (const binding of childElements(doc.definitions, NS.WSDL, 'binding')) {
+            const soapNs = soapNamespaceOf(binding);
+            const soapBinding = soapNs === undefined ? undefined : firstChildElement(binding, soapNs, 'binding');
+            if (soapNs === undefined || soapBinding === undefined) {
+                continue;
+            }
+            const bindingView = { location: doc.location, binding, soapNs, soapBinding };
+            const portType = portTypeOf(context, bindingView, doc.definitions);
+            for (const operation of childElements(binding, NS.WSDL, 'operation')) {
+                const operationName = optionalAttribute(operation, 'name');
+                const abstractOperation = portType === undefined || operationName === undefined
+                    ? undefined
+                    : childElements(portType.element, NS.WSDL, 'operation').find((candidate) => optionalAttribute(candidate, 'name') === operationName);
+                for (const [direction, messageElement] of bindingSides(operation)) {
+                    const abstractSide = abstractOperation === undefined ? undefined : abstractSideFor(abstractOperation, direction, messageElement);
+                    const abstractMessage = abstractSide === undefined ? undefined : referencedMessage(context, abstractSide, 'message', tns);
+                    const parts = abstractMessage === undefined ? [] : messageParts(abstractMessage.element);
+                    const soapBody = soapBodyOf(messageElement, soapNs);
+                    const rawParts = soapBody === undefined ? undefined : optionalAttribute(soapBody, 'parts');
+                    const declaredParts = rawParts?.split(/\s+/).filter((name) => name.length > 0);
+                    const boundParts = direction === 'fault'
+                        ? []
+                        : declaredParts === undefined
+                            ? parts
+                            : parts.filter((part) => declaredParts.includes(optionalAttribute(part, 'name') ?? ''));
+                    const headerNames = headerBoundPartNames(context, operation, soapNs, tns, abstractMessage);
+                    const faultBound = direction === 'fault' && firstChildElement(messageElement, soapNs, 'fault') !== undefined;
+                    const soapBoundParts = faultBound
+                        ? parts
+                        : parts.filter((part) => boundParts.includes(part) || headerNames.has(optionalAttribute(part, 'name') ?? ''));
+                    views.push({
+                        location: doc.location,
+                        bindingView,
+                        operation,
+                        direction,
+                        messageElement,
+                        ...(soapBody !== undefined ? { soapBody } : {}),
+                        style: operationStyle(bindingView, operation),
+                        ...(abstractMessage !== undefined ? { abstractMessage } : {}),
+                        parts,
+                        ...(declaredParts !== undefined ? { declaredParts } : {}),
+                        boundParts,
+                        soapBoundParts,
+                    });
+                }
+            }
+        }
+    }
+    return views;
+}
+/** Every `soapbind:body`/`header`/`headerfault`/`fault` element of every SOAP binding. */
+export function soapExtensions(context) {
+    const views = [];
+    for (const bindingView of soapBindings(context)) {
+        const { location, soapNs } = bindingView;
+        for (const operation of childElements(bindingView.binding, NS.WSDL, 'operation')) {
+            const style = operationStyle(bindingView, operation);
+            const base = { location, bindingView, operation, style };
+            for (const message of bindingMessages(operation)) {
+                const body = soapBodyOf(message, soapNs);
+                if (body !== undefined) {
+                    views.push({ ...base, element: body, kind: 'body' });
+                }
+                for (const header of childElements(message, soapNs, 'header')) {
+                    views.push({ ...base, element: header, kind: 'header' });
+                    for (const headerfault of childElements(header, soapNs, 'headerfault')) {
+                        views.push({ ...base, element: headerfault, kind: 'headerfault' });
+                    }
+                }
+            }
+            for (const wsdlFault of childElements(operation, NS.WSDL, 'fault')) {
+                for (const fault of childElements(wsdlFault, soapNs, 'fault')) {
+                    views.push({ ...base, element: fault, kind: 'fault', wsdlFault });
+                }
+            }
+        }
+    }
+    return views;
+}
+/** Every `soapbind:address` element in the bundle. */
+export function soapAddresses(context) {
+    const views = [];
+    for (const doc of wsdlDocuments(context)) {
+        for (const service of childElements(doc.definitions, NS.WSDL, 'service')) {
+            for (const port of childElements(service, NS.WSDL, 'port')) {
+                for (const ns of SOAP_BINDING_NAMESPACES) {
+                    const address = firstChildElement(port, ns, 'address');
+                    if (address !== undefined) {
+                        views.push({ location: doc.location, port, address });
+                    }
+                }
+            }
+        }
+    }
+    return views;
+}

package/dist/validate/wsi/assertions/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The WS-I Basic Profile 1.1 WSDL assertion catalogue.
+ *
+ * This array is the single source of truth: `runWsdlAssertions` evaluates it in order, and
+ * `scripts/wsi-docs.ts` generates `docs/ws-i-assertions.md` from it. Adding an assertion means
+ * adding a module here — nothing else needs to know.
+ */
+import type { WsiAssertion } from '../types.js';
+import { R2001 } from './r2001.js';
+import { R2002 } from './r2002.js';
+import { R2003 } from './r2003.js';
+import { R2005 } from './r2005.js';
+import { R2101 } from './r2101.js';
+import { R2102 } from './r2102.js';
+import { R2105 } from './r2105.js';
+import { R2110 } from './r2110.js';
+import { R2111 } from './r2111.js';
+import { R2112 } from './r2112.js';
+import { R2201 } from './r2201.js';
+import { R2203 } from './r2203.js';
+import { R2204 } from './r2204.js';
+import { R2205 } from './r2205.js';
+import { R2206 } from './r2206.js';
+import { R2209 } from './r2209.js';
+import { R2210 } from './r2210.js';
+import { R2303 } from './r2303.js';
+import { R2304 } from './r2304.js';
+import { R2401 } from './r2401.js';
+import { R2701 } from './r2701.js';
+import { R2702 } from './r2702.js';
+import { R2705 } from './r2705.js';
+import { R2706 } from './r2706.js';
+import { R2710 } from './r2710.js';
+import { R2716 } from './r2716.js';
+import { R2717 } from './r2717.js';
+import { R2718 } from './r2718.js';
+import { R2720 } from './r2720.js';
+import { R2721 } from './r2721.js';
+import { R2722 } from './r2722.js';
+import { R2801 } from './r2801.js';
+import { R2803 } from './r2803.js';
+/** Every implemented WSDL assertion, in profile id order. */
+export declare const WSI_WSDL_ASSERTIONS: readonly WsiAssertion[];
+export { R2001, R2002, R2003, R2005, R2101, R2102, R2105, R2110, R2111, R2112, R2201, R2203, R2204, R2205, R2206, R2209, R2210, R2303, R2304, R2401, R2701, R2702, R2705, R2706, R2710, R2716, R2717, R2718, R2720, R2721, R2722, R2801, R2803, };

package/dist/validate/wsi/assertions/index.js

@@ -0,0 +1,77 @@
+/**
+ * The WS-I Basic Profile 1.1 WSDL assertion catalogue.
+ *
+ * This array is the single source of truth: `runWsdlAssertions` evaluates it in order, and
+ * `scripts/wsi-docs.ts` generates `docs/ws-i-assertions.md` from it. Adding an assertion means
+ * adding a module here — nothing else needs to know.
+ */
+import { R2001 } from './r2001.js';
+import { R2002 } from './r2002.js';
+import { R2003 } from './r2003.js';
+import { R2005 } from './r2005.js';
+import { R2101 } from './r2101.js';
+import { R2102 } from './r2102.js';
+import { R2105 } from './r2105.js';
+import { R2110 } from './r2110.js';
+import { R2111 } from './r2111.js';
+import { R2112 } from './r2112.js';
+import { R2201 } from './r2201.js';
+import { R2203 } from './r2203.js';
+import { R2204 } from './r2204.js';
+import { R2205 } from './r2205.js';
+import { R2206 } from './r2206.js';
+import { R2209 } from './r2209.js';
+import { R2210 } from './r2210.js';
+import { R2303 } from './r2303.js';
+import { R2304 } from './r2304.js';
+import { R2401 } from './r2401.js';
+import { R2701 } from './r2701.js';
+import { R2702 } from './r2702.js';
+import { R2705 } from './r2705.js';
+import { R2706 } from './r2706.js';
+import { R2710 } from './r2710.js';
+import { R2716 } from './r2716.js';
+import { R2717 } from './r2717.js';
+import { R2718 } from './r2718.js';
+import { R2720 } from './r2720.js';
+import { R2721 } from './r2721.js';
+import { R2722 } from './r2722.js';
+import { R2801 } from './r2801.js';
+import { R2803 } from './r2803.js';
+/** Every implemented WSDL assertion, in profile id order. */
+export const WSI_WSDL_ASSERTIONS = Object.freeze([
+    R2001,
+    R2002,
+    R2003,
+    R2005,
+    R2101,
+    R2102,
+    R2105,
+    R2110,
+    R2111,
+    R2112,
+    R2201,
+    R2203,
+    R2204,
+    R2205,
+    R2206,
+    R2209,
+    R2210,
+    R2303,
+    R2304,
+    R2401,
+    R2701,
+    R2702,
+    R2705,
+    R2706,
+    R2710,
+    R2716,
+    R2717,
+    R2718,
+    R2720,
+    R2721,
+    R2722,
+    R2801,
+    R2803,
+]);
+export { R2001, R2002, R2003, R2005, R2101, R2102, R2105, R2110, R2111, R2112, R2201, R2203, R2204, R2205, R2206, R2209, R2210, R2303, R2304, R2401, R2701, R2702, R2705, R2706, R2710, R2716, R2717, R2718, R2720, R2721, R2722, R2801, R2803, };

package/dist/validate/wsi/assertions/message/helpers.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Shared DOM and HTTP navigation for the message-level WS-I assertions.
+ *
+ * The message assertions look at the bytes that actually went on the wire, so they work on the
+ * parsed envelope plus the HTTP metadata rather than on any model: the profile constrains
+ * constructs (a `DOCTYPE`, a processing instruction, an attribute nobody models) that a parsed
+ * SOAP message would otherwise normalise away.
+ */
+import type { Element } from '@xmldom/xmldom';
+import type { WsiFinding, WsiMessageContext, WsiMessageView } from '../../types.js';
+/** The envelope namespace a SOAP version uses. */
+export declare const SOAP_ENVELOPE_NS: Readonly<Record<'1.1' | '1.2', string>>;
+/** The encoding namespace a SOAP version uses. */
+export declare const SOAP_ENCODING_NS: Readonly<Record<'1.1' | '1.2', string>>;
+/** Every message half that actually parsed into a `soap:Envelope`. */
+export declare function envelopes(context: WsiMessageContext): readonly WsiMessageView[];
+/** Builds a finding pointing at `element`, attributed to the half it was found in. */
+export declare function messageFinding(view: WsiMessageView, element: Element, message: string): WsiFinding;
+/** Builds a finding about a half as a whole (an HTTP header, a missing envelope). */
+export declare function viewFinding(view: WsiMessageView, message: string): WsiFinding;
+/** The envelope element and every element beneath it, in document order. */
+export declare function envelopeElements(view: WsiMessageView): readonly Element[];
+/** The element children of `parent`, in document order (whatever their namespace). */
+export declare function elementChildren(parent: Element): readonly Element[];
+/** The element children of `soap:Envelope`, in document order (whatever their namespace). */
+export declare function envelopeChildren(view: WsiMessageView): readonly Element[];
+/** The `soap:Body` of a half, when it has exactly the one the profile requires. */
+export declare function bodyOf(view: WsiMessageView): Element | undefined;
+/** The `soap:Header` of a half, when it declares one. */
+export declare function headerOf(view: WsiMessageView): Element | undefined;
+/** The `soap:Fault` carried directly by `soap:Body`, when the half is a fault. */
+export declare function faultOf(view: WsiMessageView): Element | undefined;
+/** The element children of `soap:Body`, in document order. */
+export declare function bodyChildren(view: WsiMessageView): readonly Element[];
+/** Every attribute of `element`, as a plain list (xmldom's `attributes` is a live NamedNodeMap). */
+export declare function attributesOf(element: Element): readonly {
+    name: string;
+    localName: string;
+    namespaceUri: string | null;
+    value: string;
+}[];
+/** The media type of a `Content-Type` value, lower-cased and stripped of its parameters. */
+export declare function mediaTypeOf(contentType: string): string;
+/** The `charset` parameter of a `Content-Type` value, when it states one. */
+export declare function charsetOf(contentType: string): string | undefined;
+/** One header of a half, by its (already lower-cased) name. */
+export declare function headerValue(view: WsiMessageView, name: string): string | undefined;
+/** The prefixes in scope on `element`, mapped to the namespace they are bound to. */
+export declare function inScopePrefixes(element: Element): ReadonlyMap<string, string>;
+/**
+ * The first unqualified child element of `parent` with this local name. SOAP 1.1 declares the
+ * fault's children in no namespace, and xmldom reports that as a `null` `namespaceURI`, which
+ * `childElements(parent, '', name)` does not match.
+ */
+export declare function unqualifiedChild(parent: Element, localName: string): Element | undefined;
+/** Every `soap:Header` block (its element children), in document order. */
+export declare function headerBlocks(view: WsiMessageView): readonly Element[];
+/** The `soap:Body` children of a half, skipping the `soap:Fault` (which has its own rules). */
+export declare function partAccessors(view: WsiMessageView): readonly Element[];
+/** The number of `soap:Body` elements directly under `soap:Envelope`. */
+export declare function bodyCount(view: WsiMessageView): number;
+/** The number of `soap:Header` elements directly under `soap:Envelope`. */
+export declare function headerCount(view: WsiMessageView): number;