@wirebench/engine 2.1.1

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

@@ -0,0 +1,28 @@
+import { optionalAttribute } from '../../../wsdl/dom-utils.js';
+import { NOT_APPLICABLE } from '../types.js';
+import { boundMessages, findingAt } from './helpers.js';
+/**
+ * BP 1.1 R2201: a document-literal binding "MUST, in each of its soapbind:body element(s), have at
+ * most one part listed in the parts attribute, if the parts attribute is specified" — a literal
+ * body carries exactly one child element.
+ */
+export const R2201 = {
+    id: 'R2201',
+    title: 'A document-literal soapbind:body lists at most one part',
+    level: 'REQUIRED',
+    section: '4.7 SOAP Binding',
+    check(context) {
+        const findings = [];
+        let bodies = 0;
+        for (const view of boundMessages(context)) {
+            if (view.style !== 'document' || view.soapBody === undefined || view.declaredParts === undefined) {
+                continue;
+            }
+            bodies += 1;
+            if (view.declaredParts.length > 1) {
+                findings.push(findingAt(view.location, view.soapBody, `soapbind:body parts="${optionalAttribute(view.soapBody, 'parts') ?? ''}" lists ${view.declaredParts.length} parts; a document-literal body may list at most one`));
+            }
+        }
+        return bodies === 0 ? NOT_APPLICABLE : findings;
+    },
+};

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

@@ -0,0 +1,7 @@
+import type { WsiAssertion } from '../types.js';
+/**
+ * BP 1.1 R2203: an rpc-literal binding's message parts bound to `soapbind:body` "MUST use the type
+ * attribute" — the operation wrapper supplies the element name, so the part contributes only a
+ * type.
+ */
+export declare const R2203: WsiAssertion;

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

@@ -0,0 +1,30 @@
+import { optionalAttribute } from '../../../wsdl/dom-utils.js';
+import { NOT_APPLICABLE } from '../types.js';
+import { boundMessages, findingAt } from './helpers.js';
+/**
+ * BP 1.1 R2203: an rpc-literal binding's message parts bound to `soapbind:body` "MUST use the type
+ * attribute" — the operation wrapper supplies the element name, so the part contributes only a
+ * type.
+ */
+export const R2203 = {
+    id: 'R2203',
+    title: 'rpc-literal parts are declared with type, not element',
+    level: 'REQUIRED',
+    section: '4.7 SOAP Binding',
+    check(context) {
+        const findings = [];
+        let parts = 0;
+        for (const view of boundMessages(context)) {
+            if (view.style !== 'rpc') {
+                continue;
+            }
+            for (const part of view.boundParts) {
+                parts += 1;
+                if (optionalAttribute(part, 'type') === undefined) {
+                    findings.push(findingAt(view.location, part, `wsdl:part "${optionalAttribute(part, 'name') ?? ''}" is bound to an rpc-literal soapbind:body but does not use the type attribute`));
+                }
+            }
+        }
+        return parts === 0 ? NOT_APPLICABLE : findings;
+    },
+};

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

@@ -0,0 +1,6 @@
+import type { WsiAssertion } from '../types.js';
+/**
+ * BP 1.1 R2204: a document-literal binding's message parts bound to `soapbind:body` "MUST use the
+ * element attribute" — the part itself names the single global element the body carries.
+ */
+export declare const R2204: WsiAssertion;

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

@@ -0,0 +1,29 @@
+import { optionalAttribute } from '../../../wsdl/dom-utils.js';
+import { NOT_APPLICABLE } from '../types.js';
+import { boundMessages, findingAt } from './helpers.js';
+/**
+ * BP 1.1 R2204: a document-literal binding's message parts bound to `soapbind:body` "MUST use the
+ * element attribute" — the part itself names the single global element the body carries.
+ */
+export const R2204 = {
+    id: 'R2204',
+    title: 'document-literal parts are declared with element, not type',
+    level: 'REQUIRED',
+    section: '4.7 SOAP Binding',
+    check(context) {
+        const findings = [];
+        let parts = 0;
+        for (const view of boundMessages(context)) {
+            if (view.style !== 'document') {
+                continue;
+            }
+            for (const part of view.boundParts) {
+                parts += 1;
+                if (optionalAttribute(part, 'element') === undefined) {
+                    findings.push(findingAt(view.location, part, `wsdl:part "${optionalAttribute(part, 'name') ?? ''}" is bound to a document-literal soapbind:body but does not use the element attribute`));
+                }
+            }
+        }
+        return parts === 0 ? NOT_APPLICABLE : findings;
+    },
+};

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

@@ -0,0 +1,8 @@
+import type { WsiAssertion } from '../types.js';
+/**
+ * BP 1.1 R2205: a description "MUST refer, in each of its soapbind:header and
+ * soapbind:headerfault elements, only to wsdl:part element(s) that have been defined using the
+ * element attribute" — a header is always a single global element. A reference that does not
+ * resolve to a part at all is left to R2720/the WSDL parser.
+ */
+export declare const R2205: WsiAssertion;

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

@@ -0,0 +1,46 @@
+import { NS } from '../../../xml/namespaces.js';
+import { childElements, optionalAttribute } from '../../../wsdl/dom-utils.js';
+import { NOT_APPLICABLE } from '../types.js';
+import { bindingMessages, findPart, findingAt, referencedMessage, soapBindings, targetNamespaceOf, wsdlDocuments, } from './helpers.js';
+/**
+ * BP 1.1 R2205: a description "MUST refer, in each of its soapbind:header and
+ * soapbind:headerfault elements, only to wsdl:part element(s) that have been defined using the
+ * element attribute" — a header is always a single global element. A reference that does not
+ * resolve to a part at all is left to R2720/the WSDL parser.
+ */
+export const R2205 = {
+    id: 'R2205',
+    title: 'soapbind:header and headerfault refer to element-declared parts',
+    level: 'REQUIRED',
+    section: '4.7 SOAP Binding',
+    check(context) {
+        const tnsByLocation = new Map(wsdlDocuments(context).map((doc) => [doc.location, targetNamespaceOf(doc.definitions)]));
+        const findings = [];
+        let references = 0;
+        for (const view of soapBindings(context)) {
+            const tns = tnsByLocation.get(view.location) ?? '';
+            for (const operation of childElements(view.binding, NS.WSDL, 'operation')) {
+                for (const message of bindingMessages(operation)) {
+                    for (const header of childElements(message, view.soapNs, 'header')) {
+                        for (const element of [header, ...childElements(header, view.soapNs, 'headerfault')]) {
+                            const partName = optionalAttribute(element, 'part');
+                            const target = referencedMessage(context, element, 'message', tns);
+                            if (partName === undefined || target === undefined) {
+                                continue;
+                            }
+                            const part = findPart(target.element, partName);
+                            if (part === undefined) {
+                                continue;
+                            }
+                            references += 1;
+                            if (optionalAttribute(part, 'element') === undefined) {
+                                findings.push(findingAt(view.location, element, `soapbind:${element.localName ?? 'header'} refers to wsdl:part "${partName}", which is not declared with the element attribute`));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return references === 0 ? NOT_APPLICABLE : findings;
+    },
+};

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

@@ -0,0 +1,7 @@
+import type { WsiAssertion } from '../types.js';
+/**
+ * BP 1.1 R2206: a `wsdl:part` that uses the element attribute "MUST refer to a global element
+ * declaration" — the schema set must actually declare it. Parts naming a namespace the schema set
+ * knows nothing about are reported by R2101 instead.
+ */
+export declare const R2206: WsiAssertion;

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

@@ -0,0 +1,36 @@
+import { NS } from '../../../xml/namespaces.js';
+import { childElements, optionalAttribute } from '../../../wsdl/dom-utils.js';
+import { NOT_APPLICABLE } from '../types.js';
+import { attributeQName, findingAt, messageParts, targetNamespaceOf, wsdlDocuments } from './helpers.js';
+/**
+ * BP 1.1 R2206: a `wsdl:part` that uses the element attribute "MUST refer to a global element
+ * declaration" — the schema set must actually declare it. Parts naming a namespace the schema set
+ * knows nothing about are reported by R2101 instead.
+ */
+export const R2206 = {
+    id: 'R2206',
+    title: 'An element-declared part refers to a global element declaration',
+    level: 'REQUIRED',
+    section: '4.7 SOAP Binding',
+    check(context) {
+        const findings = [];
+        let parts = 0;
+        for (const doc of wsdlDocuments(context)) {
+            const tns = targetNamespaceOf(doc.definitions);
+            for (const message of childElements(doc.definitions, NS.WSDL, 'message')) {
+                for (const part of messageParts(message)) {
+                    const raw = optionalAttribute(part, 'element');
+                    const qname = attributeQName(part, 'element', tns);
+                    if (raw === undefined || qname === undefined || !context.schemaSet.namespaces.includes(qname.namespaceUri)) {
+                        continue;
+                    }
+                    parts += 1;
+                    if (context.schemaSet.lookupElement(qname) === undefined) {
+                        findings.push(findingAt(doc.location, part, `wsdl:part element="${raw}" does not resolve to a global element declaration`));
+                    }
+                }
+            }
+        }
+        return parts === 0 ? NOT_APPLICABLE : findings;
+    },
+};

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

@@ -0,0 +1,12 @@
+import type { WsiAssertion } from '../types.js';
+/**
+ * BP 1.1 R2209: a `wsdl:binding` "SHOULD bind every wsdl:part of a wsdl:message in the
+ * wsdl:portType to which it refers to one of soapbind:body, soapbind:header, soapbind:fault or
+ * soapbind:headerfault". An unbound part never reaches the wire, so it is reported as a warning.
+ *
+ * All four constructs count: a part left out of `soapbind:body/@parts` is still bound when a
+ * `soapbind:header` or `soapbind:headerfault` of the same binding operation names it on this very
+ * message, and a fault message's part is bound when the binding's `wsdl:fault` carries a
+ * `soapbind:fault` (see `soapBoundParts`).
+ */
+export declare const R2209: WsiAssertion;

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

@@ -0,0 +1,37 @@
+import { optionalAttribute } from '../../../wsdl/dom-utils.js';
+import { NOT_APPLICABLE } from '../types.js';
+import { boundMessages, findingAt } from './helpers.js';
+/**
+ * BP 1.1 R2209: a `wsdl:binding` "SHOULD bind every wsdl:part of a wsdl:message in the
+ * wsdl:portType to which it refers to one of soapbind:body, soapbind:header, soapbind:fault or
+ * soapbind:headerfault". An unbound part never reaches the wire, so it is reported as a warning.
+ *
+ * All four constructs count: a part left out of `soapbind:body/@parts` is still bound when a
+ * `soapbind:header` or `soapbind:headerfault` of the same binding operation names it on this very
+ * message, and a fault message's part is bound when the binding's `wsdl:fault` carries a
+ * `soapbind:fault` (see `soapBoundParts`).
+ */
+export const R2209 = {
+    id: 'R2209',
+    title: 'Every part of a bound message is bound to a SOAP construct',
+    level: 'RECOMMENDED',
+    section: '4.7 SOAP Binding',
+    check(context) {
+        const findings = [];
+        let messages = 0;
+        for (const view of boundMessages(context)) {
+            if (view.abstractMessage === undefined || view.parts.length === 0) {
+                continue;
+            }
+            messages += 1;
+            const boundNames = new Set(view.soapBoundParts.map((part) => optionalAttribute(part, 'name')));
+            for (const part of view.parts) {
+                const name = optionalAttribute(part, 'name');
+                if (!boundNames.has(name)) {
+                    findings.push(findingAt(view.location, view.messageElement, `wsdl:part "${name ?? ''}" of the bound message is not bound to any SOAP construct`));
+                }
+            }
+        }
+        return messages === 0 ? NOT_APPLICABLE : findings;
+    },
+};

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

@@ -0,0 +1,7 @@
+import type { WsiAssertion } from '../types.js';
+/**
+ * BP 1.1 R2210: if a document-literal binding does not specify the parts attribute on
+ * `soapbind:body`, "the corresponding abstract wsdl:message MUST define zero or one wsdl:parts" —
+ * otherwise the body would carry more than one child element.
+ */
+export declare const R2210: WsiAssertion;

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

@@ -0,0 +1,30 @@
+import { NOT_APPLICABLE } from '../types.js';
+import { boundMessages, findingAt } from './helpers.js';
+/**
+ * BP 1.1 R2210: if a document-literal binding does not specify the parts attribute on
+ * `soapbind:body`, "the corresponding abstract wsdl:message MUST define zero or one wsdl:parts" —
+ * otherwise the body would carry more than one child element.
+ */
+export const R2210 = {
+    id: 'R2210',
+    title: 'A document-literal body without a parts attribute binds a message of at most one part',
+    level: 'REQUIRED',
+    section: '4.7 SOAP Binding',
+    check(context) {
+        const findings = [];
+        let bodies = 0;
+        for (const view of boundMessages(context)) {
+            if (view.style !== 'document' ||
+                view.soapBody === undefined ||
+                view.declaredParts !== undefined ||
+                view.abstractMessage === undefined) {
+                continue;
+            }
+            bodies += 1;
+            if (view.parts.length > 1) {
+                findings.push(findingAt(view.location, view.soapBody, `soapbind:body has no parts attribute and its message defines ${view.parts.length} parts`));
+            }
+        }
+        return bodies === 0 ? NOT_APPLICABLE : findings;
+    },
+};

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

@@ -0,0 +1,7 @@
+import type { WsiAssertion } from '../types.js';
+/**
+ * BP 1.1 R2303: a description "MUST NOT use Solicit-Response and Notification type operations" —
+ * the profile covers only the two client-initiated message exchange patterns, so a port-type
+ * operation whose first message is an output is out of profile.
+ */
+export declare const R2303: WsiAssertion;

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

@@ -0,0 +1,44 @@
+import { NS } from '../../../xml/namespaces.js';
+import { childElements, optionalAttribute } from '../../../wsdl/dom-utils.js';
+import { NOT_APPLICABLE } from '../types.js';
+import { findingAt, wsdlDocuments } from './helpers.js';
+/** The first `wsdl:input`/`wsdl:output` child of a port-type operation, in document order. */
+function firstMessageKind(operation) {
+    let child = operation.firstChild;
+    while (child !== null) {
+        if (child.nodeType === 1) {
+            const element = child;
+            if (element.namespaceURI === NS.WSDL && (element.localName === 'input' || element.localName === 'output')) {
+                return element.localName;
+            }
+        }
+        child = child.nextSibling;
+    }
+    return undefined;
+}
+/**
+ * BP 1.1 R2303: a description "MUST NOT use Solicit-Response and Notification type operations" —
+ * the profile covers only the two client-initiated message exchange patterns, so a port-type
+ * operation whose first message is an output is out of profile.
+ */
+export const R2303 = {
+    id: 'R2303',
+    title: 'No Solicit-Response or Notification operations',
+    level: 'REQUIRED',
+    section: '4.6 Operations',
+    check(context) {
+        const findings = [];
+        let operations = 0;
+        for (const doc of wsdlDocuments(context)) {
+            for (const portType of childElements(doc.definitions, NS.WSDL, 'portType')) {
+                for (const operation of childElements(portType, NS.WSDL, 'operation')) {
+                    operations += 1;
+                    if (firstMessageKind(operation) === 'output') {
+                        findings.push(findingAt(doc.location, operation, `Operation "${optionalAttribute(operation, 'name') ?? ''}" starts with wsdl:output, which is a Solicit-Response or Notification operation`));
+                    }
+                }
+            }
+        }
+        return operations === 0 ? NOT_APPLICABLE : findings;
+    },
+};

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

@@ -0,0 +1,6 @@
+import type { WsiAssertion } from '../types.js';
+/**
+ * BP 1.1 R2304: a description "MUST have operations with distinct values for their name attributes
+ * within the same wsdl:portType" — WSDL 1.1 operation overloading is outside the profile.
+ */
+export declare const R2304: WsiAssertion;

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

@@ -0,0 +1,32 @@
+import { NS } from '../../../xml/namespaces.js';
+import { childElements, optionalAttribute } from '../../../wsdl/dom-utils.js';
+import { NOT_APPLICABLE } from '../types.js';
+import { findingAt, wsdlDocuments } from './helpers.js';
+/**
+ * BP 1.1 R2304: a description "MUST have operations with distinct values for their name attributes
+ * within the same wsdl:portType" — WSDL 1.1 operation overloading is outside the profile.
+ */
+export const R2304 = {
+    id: 'R2304',
+    title: 'Operation names are distinct within a portType',
+    level: 'REQUIRED',
+    section: '4.6 Operations',
+    check(context) {
+        const findings = [];
+        let operations = 0;
+        for (const doc of wsdlDocuments(context)) {
+            for (const portType of childElements(doc.definitions, NS.WSDL, 'portType')) {
+                const seen = new Set();
+                for (const operation of childElements(portType, NS.WSDL, 'operation')) {
+                    operations += 1;
+                    const name = optionalAttribute(operation, 'name') ?? '';
+                    if (seen.has(name)) {
+                        findings.push(findingAt(doc.location, operation, `wsdl:portType "${optionalAttribute(portType, 'name') ?? ''}" declares more than one operation named "${name}"`));
+                    }
+                    seen.add(name);
+                }
+            }
+        }
+        return operations === 0 ? NOT_APPLICABLE : findings;
+    },
+};

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

@@ -0,0 +1,12 @@
+import type { WsiAssertion } from '../types.js';
+/**
+ * A `wsdl:port` describes an endpoint through `soapbind:address`, whose `location` must be an
+ * absolute URI — a relative reference has no base once the description is republished elsewhere.
+ *
+ * The requirement itself is part of BP 1.1 §4.7's SOAP binding extensions, but its requirement
+ * *number* could not be confirmed against the published profile: `R2401` is the id this catalogue
+ * uses, flagged `unverifiedId` so the generated document says so rather than asserting an id
+ * Wirebench is not sure of. (It is definitely not `R2701`, which is the HTTP-transport
+ * requirement.)
+ */
+export declare const R2401: WsiAssertion;

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

@@ -0,0 +1,31 @@
+import { optionalAttribute } from '../../../wsdl/dom-utils.js';
+import { NOT_APPLICABLE } from '../types.js';
+import { findingAt, isAbsoluteUri, soapAddresses } from './helpers.js';
+/**
+ * A `wsdl:port` describes an endpoint through `soapbind:address`, whose `location` must be an
+ * absolute URI — a relative reference has no base once the description is republished elsewhere.
+ *
+ * The requirement itself is part of BP 1.1 §4.7's SOAP binding extensions, but its requirement
+ * *number* could not be confirmed against the published profile: `R2401` is the id this catalogue
+ * uses, flagged `unverifiedId` so the generated document says so rather than asserting an id
+ * Wirebench is not sure of. (It is definitely not `R2701`, which is the HTTP-transport
+ * requirement.)
+ */
+export const R2401 = {
+    id: 'R2401',
+    title: 'soapbind:address declares an absolute endpoint URI',
+    level: 'REQUIRED',
+    section: '4.7 SOAP Binding Extensions',
+    unverifiedId: true,
+    check(context) {
+        const findings = [];
+        const addresses = soapAddresses(context);
+        for (const view of addresses) {
+            const location = optionalAttribute(view.address, 'location');
+            if (location === undefined || !isAbsoluteUri(location)) {
+                findings.push(findingAt(view.location, view.address, `soapbind:address location="${location ?? ''}" is not an absolute URI`));
+            }
+        }
+        return addresses.length === 0 ? NOT_APPLICABLE : findings;
+    },
+};

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

@@ -0,0 +1,7 @@
+import type { WsiAssertion } from '../types.js';
+/**
+ * BP 1.1 R2701: the `wsdl:binding` element of a description "MUST be a WSDL SOAP binding" as
+ * defined by WSDL 1.1 section 3 — a binding carrying, for instance, an HTTP GET/POST extension
+ * instead of `soapbind:binding` is outside the profile.
+ */
+export declare const R2701: WsiAssertion;

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

@@ -0,0 +1,28 @@
+import { NS } from '../../../xml/namespaces.js';
+import { childElements, optionalAttribute } from '../../../wsdl/dom-utils.js';
+import { NOT_APPLICABLE } from '../types.js';
+import { findingAt, soapNamespaceOf, wsdlDocuments } from './helpers.js';
+/**
+ * BP 1.1 R2701: the `wsdl:binding` element of a description "MUST be a WSDL SOAP binding" as
+ * defined by WSDL 1.1 section 3 — a binding carrying, for instance, an HTTP GET/POST extension
+ * instead of `soapbind:binding` is outside the profile.
+ */
+export const R2701 = {
+    id: 'R2701',
+    title: 'Every wsdl:binding is a SOAP binding',
+    level: 'REQUIRED',
+    section: '4.7 SOAP Binding',
+    check(context) {
+        const findings = [];
+        let bindings = 0;
+        for (const doc of wsdlDocuments(context)) {
+            for (const binding of childElements(doc.definitions, NS.WSDL, 'binding')) {
+                bindings += 1;
+                if (soapNamespaceOf(binding) === undefined) {
+                    findings.push(findingAt(doc.location, binding, `wsdl:binding "${optionalAttribute(binding, 'name') ?? ''}" has no soapbind:binding element`));
+                }
+            }
+        }
+        return bindings === 0 ? NOT_APPLICABLE : findings;
+    },
+};

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

@@ -0,0 +1,6 @@
+import type { WsiAssertion } from '../types.js';
+/**
+ * BP 1.1 R2702: a `wsdl:binding` "MUST specify the transport attribute with the value
+ * http://schemas.xmlsoap.org/soap/http" — the profile binds SOAP to HTTP only.
+ */
+export declare const R2702: WsiAssertion;

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

@@ -0,0 +1,26 @@
+import { optionalAttribute } from '../../../wsdl/dom-utils.js';
+import { NOT_APPLICABLE } from '../types.js';
+import { findingAt, soapBindings } from './helpers.js';
+/** The only transport the profile allows a SOAP binding to declare. */
+const HTTP_TRANSPORT = 'http://schemas.xmlsoap.org/soap/http';
+/**
+ * BP 1.1 R2702: a `wsdl:binding` "MUST specify the transport attribute with the value
+ * http://schemas.xmlsoap.org/soap/http" — the profile binds SOAP to HTTP only.
+ */
+export const R2702 = {
+    id: 'R2702',
+    title: 'soapbind:binding declares the HTTP transport',
+    level: 'REQUIRED',
+    section: '4.7 SOAP Binding',
+    check(context) {
+        const findings = [];
+        const bindings = soapBindings(context);
+        for (const view of bindings) {
+            const transport = optionalAttribute(view.soapBinding, 'transport');
+            if (transport !== HTTP_TRANSPORT) {
+                findings.push(findingAt(view.location, view.soapBinding, `soapbind:binding transport="${transport ?? ''}" is not "${HTTP_TRANSPORT}"`));
+            }
+        }
+        return bindings.length === 0 ? NOT_APPLICABLE : findings;
+    },
+};

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

@@ -0,0 +1,11 @@
+import type { WsiAssertion } from '../types.js';
+/**
+ * BP 1.1 R2705: a `wsdl:binding` "MUST be either rpc-literal or document-literal" — one binding
+ * cannot mix the two styles across its operations.
+ *
+ * Only the *style* half of that requirement is checked here: whether the binding's operations agree
+ * on `document` vs `rpc`. That the `use` is `literal` rather than `encoded` is checked by
+ * {@link R2706}, so a binding that consistently uses one style but encodes its bodies fails there,
+ * not here.
+ */
+export declare const R2705: WsiAssertion;

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

@@ -0,0 +1,31 @@
+import { NS } from '../../../xml/namespaces.js';
+import { childElements, optionalAttribute } from '../../../wsdl/dom-utils.js';
+import { NOT_APPLICABLE } from '../types.js';
+import { findingAt, operationStyle, soapBindings } from './helpers.js';
+/**
+ * BP 1.1 R2705: a `wsdl:binding` "MUST be either rpc-literal or document-literal" — one binding
+ * cannot mix the two styles across its operations.
+ *
+ * Only the *style* half of that requirement is checked here: whether the binding's operations agree
+ * on `document` vs `rpc`. That the `use` is `literal` rather than `encoded` is checked by
+ * {@link R2706}, so a binding that consistently uses one style but encodes its bodies fails there,
+ * not here.
+ */
+export const R2705 = {
+    id: 'R2705',
+    title: 'A binding does not mix the document and rpc styles (literal-ness is R2706)',
+    level: 'REQUIRED',
+    section: '4.7 SOAP Binding',
+    check(context) {
+        const findings = [];
+        const bindings = soapBindings(context);
+        for (const view of bindings) {
+            const operations = childElements(view.binding, NS.WSDL, 'operation');
+            const styles = new Set(operations.map((operation) => operationStyle(view, operation)));
+            if (styles.size > 1) {
+                findings.push(findingAt(view.location, view.binding, `wsdl:binding "${optionalAttribute(view.binding, 'name') ?? ''}" mixes the document and rpc styles across its operations`));
+            }
+        }
+        return bindings.length === 0 ? NOT_APPLICABLE : findings;
+    },
+};

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

@@ -0,0 +1,7 @@
+import type { WsiAssertion } from '../types.js';
+/**
+ * BP 1.1 R2706: a `wsdl:binding` "MUST use the value of 'literal' for the use attribute in all
+ * soapbind:body, soapbind:fault, soapbind:header and soapbind:headerfault elements" — SOAP
+ * encoding is out of profile. An absent `use` is left to the description's own default.
+ */
+export declare const R2706: WsiAssertion;

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

@@ -0,0 +1,29 @@
+import { optionalAttribute } from '../../../wsdl/dom-utils.js';
+import { NOT_APPLICABLE } from '../types.js';
+import { findingAt, soapExtensions } from './helpers.js';
+/**
+ * BP 1.1 R2706: a `wsdl:binding` "MUST use the value of 'literal' for the use attribute in all
+ * soapbind:body, soapbind:fault, soapbind:header and soapbind:headerfault elements" — SOAP
+ * encoding is out of profile. An absent `use` is left to the description's own default.
+ */
+export const R2706 = {
+    id: 'R2706',
+    title: 'Every soapbind element that declares use declares "literal"',
+    level: 'REQUIRED',
+    section: '4.7 SOAP Binding',
+    check(context) {
+        const findings = [];
+        let declarations = 0;
+        for (const view of soapExtensions(context)) {
+            const use = optionalAttribute(view.element, 'use');
+            if (use === undefined) {
+                continue;
+            }
+            declarations += 1;
+            if (use !== 'literal') {
+                findings.push(findingAt(view.location, view.element, `soapbind:${view.kind} declares use="${use}"`));
+            }
+        }
+        return declarations === 0 ? NOT_APPLICABLE : findings;
+    },
+};

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

@@ -0,0 +1,13 @@
+import type { WsiAssertion } from '../types.js';
+/**
+ * BP 1.1 R2710: the operations of a `wsdl:binding` "MUST result in wire signatures that are
+ * different from one another".
+ *
+ * This is an **approximation**: the profile's subject is the *wire signature* (for document-literal,
+ * the qualified name of the body's first child; for rpc-literal, the wrapper element), which two
+ * differently-named operations can still share. What is checked here is the much cheaper and
+ * strictly narrower condition that no two operations of one binding share a `name` — the case
+ * that is both unambiguous and by far the most common. Operations whose names differ but whose
+ * wire signatures collide are not reported.
+ */
+export declare const R2710: WsiAssertion;