@wirebench/engine 2.1.1

package/dist/soap/recreate.js

@@ -0,0 +1,168 @@
+/**
+ * "Recreate Request": merge a freshly generated envelope
+ * (the source of structure) with an existing edited envelope (the source of
+ * values), by matching elements on a root-relative path of
+ * `localName[siblingIndex]` steps rather than by DOM identity.
+ */
+import { scanXml } from '../xsd/xml-scan.js';
+import { formatXml } from '../xml/pretty.js';
+function pathKey(path) {
+    return path.join('/');
+}
+/** Builds a map from root-relative path → element, for every element in the tree(s). */
+function indexByPath(roots) {
+    const map = new Map();
+    const walk = (elements, parentPath) => {
+        const counts = new Map();
+        for (const el of elements) {
+            const n = (counts.get(el.localName) ?? 0) + 1;
+            counts.set(el.localName, n);
+            const step = `${el.localName}[${n}]`;
+            const path = [...parentPath, step];
+            map.set(pathKey(path), el);
+            walk(el.children, path);
+        }
+    };
+    walk(roots, []);
+    return map;
+}
+/** Counts every removed element in `current` (present, absent from `generated`) recursively. */
+function countRemoved(currentRoots, generatedIndex, parentPath) {
+    let removed = 0;
+    const counts = new Map();
+    for (const el of currentRoots) {
+        const n = (counts.get(el.localName) ?? 0) + 1;
+        counts.set(el.localName, n);
+        const step = `${el.localName}[${n}]`;
+        const path = [...parentPath, step];
+        if (generatedIndex.has(pathKey(path))) {
+            removed += countRemoved(el.children, generatedIndex, path);
+        }
+        else {
+            removed += 1 + countAll(el.children);
+        }
+    }
+    return removed;
+}
+function countAll(elements) {
+    let n = 0;
+    for (const el of elements) {
+        n += 1 + countAll(el.children);
+    }
+    return n;
+}
+/** Splices `[value, at range]` replacements into `text`, applied back-to-front so ranges stay valid. */
+function applyReplacements(text, replacements) {
+    const sorted = [...replacements].sort((a, b) => b.start - a.start);
+    let out = text;
+    for (const r of sorted) {
+        out = out.slice(0, r.start) + r.value + out.slice(r.end);
+    }
+    return out;
+}
+function escapeXmlText(value) {
+    return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+function escapeXmlAttr(value) {
+    return escapeXmlText(value).replace(/"/g, '&quot;');
+}
+/**
+ * Merges `generatedXml` (structure) with `currentXml` (values), per the
+ * "Recreate Request" semantics.
+ */
+export function recreateRequest(currentXml, generatedXml, options) {
+    const { keepValues, keepHeaders } = options;
+    const currentScan = scanXml(currentXml);
+    const generatedScan = scanXml(generatedXml);
+    const currentEnvelope = currentScan.elements.find((e) => e.localName === 'Envelope');
+    const generatedEnvelope = generatedScan.elements.find((e) => e.localName === 'Envelope');
+    if (generatedEnvelope === undefined) {
+        return { xml: formatXml(generatedXml).text, kept: 0, added: 0, removed: 0 };
+    }
+    if (currentEnvelope === undefined) {
+        return { xml: formatXml(generatedXml).text, kept: 0, added: countAll(generatedEnvelope.children), removed: 0 };
+    }
+    const currentIndex = indexByPath(currentEnvelope.children);
+    const generatedIndex = indexByPath(generatedEnvelope.children);
+    let kept = 0;
+    const replacements = [];
+    const walkGenerated = (elements, parentPath) => {
+        const counts = new Map();
+        for (const el of elements) {
+            const n = (counts.get(el.localName) ?? 0) + 1;
+            counts.set(el.localName, n);
+            const step = `${el.localName}[${n}]`;
+            const path = [...parentPath, step];
+            const key = pathKey(path);
+            const currentEl = currentIndex.get(key);
+            if (currentEl === undefined) {
+                continue;
+            }
+            // Leaf element (no children in generated): copy text value if present in current.
+            if (el.children.length === 0) {
+                if (keepValues && currentEl.text !== undefined && el.text !== undefined) {
+                    const currentValue = currentEl.text.value;
+                    const generatedValue = el.text.value;
+                    if (currentValue !== generatedValue) {
+                        replacements.push({
+                            start: el.text.range.start,
+                            end: el.text.range.end,
+                            value: escapeXmlText(currentValue),
+                        });
+                    }
+                    kept += 1;
+                }
+            }
+            else {
+                walkGenerated(el.children, path);
+            }
+            // Attributes: copy matching attribute values from current.
+            if (keepValues) {
+                for (const attr of el.attributes) {
+                    const currentAttr = currentEl.attributes.find((a) => a.name === attr.name);
+                    if (currentAttr !== undefined && currentAttr.value !== attr.value) {
+                        replacements.push({
+                            start: attr.valueRange.start,
+                            end: attr.valueRange.end,
+                            value: escapeXmlAttr(currentAttr.value),
+                        });
+                    }
+                }
+            }
+        }
+    };
+    walkGenerated(generatedEnvelope.children, []);
+    let added = 0;
+    const countAdded = (elements, parentPath) => {
+        const counts = new Map();
+        for (const el of elements) {
+            const n = (counts.get(el.localName) ?? 0) + 1;
+            counts.set(el.localName, n);
+            const step = `${el.localName}[${n}]`;
+            const path = [...parentPath, step];
+            if (currentIndex.has(pathKey(path))) {
+                countAdded(el.children, path);
+            }
+            else {
+                added += 1 + countAll(el.children);
+            }
+        }
+    };
+    countAdded(generatedEnvelope.children, []);
+    const removed = countRemoved(currentEnvelope.children, generatedIndex, []);
+    let mergedXml = applyReplacements(generatedXml, replacements);
+    if (keepHeaders) {
+        const currentHeader = currentEnvelope.children.find((e) => e.localName === 'Header');
+        const generatedHeaderInMerged = scanXml(mergedXml)
+            .elements.find((e) => e.localName === 'Envelope')
+            ?.children.find((e) => e.localName === 'Header');
+        if (currentHeader !== undefined && generatedHeaderInMerged !== undefined) {
+            const headerText = currentXml.slice(currentHeader.range.start, currentHeader.range.end);
+            mergedXml =
+                mergedXml.slice(0, generatedHeaderInMerged.range.start) +
+                    headerText +
+                    mergedXml.slice(generatedHeaderInMerged.range.end);
+        }
+    }
+    return { xml: formatXml(mergedXml).text, kept, added, removed };
+}

package/dist/soap/request-builder.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Builds the complete sample SOAP request for one binding operation — the
+ * envelope the user sees immediately after importing a WSDL.
+ */
+import type { WsdlDefinition } from '../wsdl/model.js';
+import type { QName } from '../wsdl/qname.js';
+import type { GenerateOptions } from '../xsd/sample-generator.js';
+import type { SchemaSet } from '../xsd/schema-set.js';
+import type { BuildProblem } from './build-problems.js';
+import type { SoapEnvelopeVersion } from './envelope.js';
+import type { SoapActionOptions } from './soap-action.js';
+/** Identifies one operation of one binding. */
+export interface OperationRef {
+    readonly bindingName: QName;
+    readonly operationName: string;
+}
+/** The parsed WSDL and its compiled schemas — everything a request is built from. */
+export interface RequestBuildInput {
+    readonly definition: WsdlDefinition;
+    readonly schemaSet: SchemaSet;
+}
+/** A generated request: the envelope plus the transport metadata that must accompany it. */
+export interface GeneratedRequest {
+    readonly envelopeXml: string;
+    readonly soapVersion: SoapEnvelopeVersion;
+    /** The binding's `soapAction`, when it declares one. */
+    readonly soapAction?: string;
+    readonly contentType: string;
+    /** Action-carrying headers (SOAP 1.1's `SOAPAction`); never includes `Content-Type`. */
+    readonly headers: Readonly<Record<string, string>>;
+    /** Everything that could not be built; empty for a fully resolved operation. */
+    readonly problems: readonly BuildProblem[];
+}
+/** Options accepted by {@link buildSampleRequest} beyond the generator's own. */
+export interface RequestBuildOptions extends SoapActionOptions {
+    /** Indent per level; three spaces by default. */
+    readonly indent?: string;
+}
+/**
+ * Builds the sample SOAP request for one binding operation.
+ *
+ * The builder never throws for a modelling problem: it always returns an
+ * envelope (an empty one in the worst case) and reports what went wrong in
+ * {@link GeneratedRequest.problems}, so the UI can show a partial request.
+ *
+ * Every namespace used anywhere in the envelope is declared once on the
+ * `soapenv:Envelope` element with a short mnemonic prefix
+ * (`http://tempuri.org/` → `tem`); the fragments inside carry none.
+ *
+ * Deterministic: identical inputs always produce byte-identical output.
+ *
+ * @param input the parsed WSDL definition and its compiled schema set
+ * @param op which operation of which binding to build
+ * @param genOptions sample-generator options (optional elements, sample values, depth, prefixes)
+ * @param options indent plus SOAP action/`Content-Type` knobs
+ */
+export declare function buildSampleRequest(input: RequestBuildInput, op: OperationRef, genOptions?: Partial<GenerateOptions>, options?: RequestBuildOptions): GeneratedRequest;
+/**
+ * Builds an empty envelope for one binding operation — the "Create Empty"
+ * request. The envelope carries an empty `Header` and `Body`, while the SOAP
+ * version, action and `Content-Type` are exactly those of a sample request.
+ */
+export declare function buildEmptyRequest(input: RequestBuildInput, op: OperationRef, options?: RequestBuildOptions): GeneratedRequest;

package/dist/soap/request-builder.js

@@ -0,0 +1,161 @@
+/**
+ * Builds the complete sample SOAP request for one binding operation — the
+ * envelope the user sees immediately after importing a WSDL.
+ */
+import { findBinding, findMessage, findPortType } from '../wsdl/model.js';
+import { qnameToString } from '../wsdl/qname.js';
+import { buildBody, buildHeaders } from './body-builder.js';
+import { createEnvelope } from './envelope.js';
+import { NamespaceScope } from './namespace-scope.js';
+import { soapActionHeaders } from './soap-action.js';
+function resolveOperation(input, op, problems) {
+    const binding = findBinding(input.definition, op.bindingName);
+    if (binding === undefined) {
+        problems.push({ code: 'unknown-binding', message: `No binding named ${qnameToString(op.bindingName)}` });
+        return { version: '1.1', buildable: false };
+    }
+    const bindingOperation = binding.operations.find((candidate) => candidate.name === op.operationName);
+    if (bindingOperation === undefined) {
+        problems.push({
+            code: 'unknown-operation',
+            message: `Binding ${qnameToString(op.bindingName)} has no operation "${op.operationName}"`,
+        });
+        return { binding, version: binding.soapVersion === '1.2' ? '1.2' : '1.1', buildable: false };
+    }
+    if (binding.soapVersion === 'none') {
+        problems.push({
+            code: 'unsupported-binding',
+            message: `Binding ${qnameToString(op.bindingName)} is not a SOAP binding`,
+        });
+        return { binding, bindingOperation, version: '1.1', buildable: false };
+    }
+    return {
+        binding,
+        bindingOperation,
+        version: binding.soapVersion,
+        ...(bindingOperation.soapAction !== undefined ? { soapAction: bindingOperation.soapAction } : {}),
+        buildable: true,
+    };
+}
+/** Assembles the transport half of a {@link GeneratedRequest}. */
+function transport(version, soapAction, actionOptions) {
+    const { contentType, headers } = soapActionHeaders(version, soapAction, actionOptions ?? {});
+    return { contentType, headers };
+}
+/** The abstract operation behind a binding operation, reporting what is missing. */
+function findAbstractOperation(definition, binding, operationName, problems) {
+    const portType = findPortType(definition, binding.type);
+    if (portType === undefined) {
+        problems.push({
+            code: 'missing-portType',
+            message: `Binding ${qnameToString(binding.name)} refers to unknown portType ${qnameToString(binding.type)}`,
+        });
+        return undefined;
+    }
+    const operation = portType.operations.find((candidate) => candidate.name === operationName);
+    if (operation === undefined) {
+        problems.push({
+            code: 'unknown-operation',
+            message: `portType ${qnameToString(portType.name)} has no operation "${operationName}"`,
+        });
+    }
+    return operation;
+}
+/** The seed namespaces a scope names up-front, in a stable order. */
+function seedNamespaces(input, bindingOperation) {
+    const bodyNamespace = bindingOperation?.input?.body.namespace;
+    return [
+        input.definition.targetNamespace,
+        ...(bodyNamespace !== undefined ? [bodyNamespace] : []),
+        ...input.schemaSet.namespaces,
+    ].filter((uri) => uri !== '');
+}
+/**
+ * Builds the sample SOAP request for one binding operation.
+ *
+ * The builder never throws for a modelling problem: it always returns an
+ * envelope (an empty one in the worst case) and reports what went wrong in
+ * {@link GeneratedRequest.problems}, so the UI can show a partial request.
+ *
+ * Every namespace used anywhere in the envelope is declared once on the
+ * `soapenv:Envelope` element with a short mnemonic prefix
+ * (`http://tempuri.org/` → `tem`); the fragments inside carry none.
+ *
+ * Deterministic: identical inputs always produce byte-identical output.
+ *
+ * @param input the parsed WSDL definition and its compiled schema set
+ * @param op which operation of which binding to build
+ * @param genOptions sample-generator options (optional elements, sample values, depth, prefixes)
+ * @param options indent plus SOAP action/`Content-Type` knobs
+ */
+export function buildSampleRequest(input, op, genOptions, options) {
+    const problems = [];
+    const resolved = resolveOperation(input, op, problems);
+    const indent = options?.indent ?? '   ';
+    if (!resolved.buildable || resolved.binding === undefined || resolved.bindingOperation === undefined) {
+        return {
+            envelopeXml: createEnvelope(resolved.version, { bodyXml: '' }, { indent }),
+            soapVersion: resolved.version,
+            ...(resolved.soapAction !== undefined ? { soapAction: resolved.soapAction } : {}),
+            ...transport(resolved.version, resolved.soapAction, options),
+            problems,
+        };
+    }
+    const { binding, bindingOperation } = resolved;
+    const scope = new NamespaceScope(seedNamespaces(input, bindingOperation), genOptions?.prefixes ?? {});
+    const ctx = {
+        definition: input.definition,
+        schemaSet: input.schemaSet,
+        scope,
+        genOptions: genOptions ?? {},
+        indent,
+        problems,
+    };
+    const headerXml = buildHeaders(ctx, bindingOperation.input?.headers ?? []);
+    let bodyXml = '';
+    const abstract = findAbstractOperation(input.definition, binding, op.operationName, problems);
+    const inputRef = abstract?.input;
+    if (abstract !== undefined && inputRef === undefined) {
+        problems.push({
+            code: 'missing-message',
+            message: `Operation "${op.operationName}" declares no input message`,
+        });
+    }
+    if (inputRef !== undefined) {
+        const message = findMessage(input.definition, inputRef.message);
+        if (message === undefined) {
+            problems.push({
+                code: 'missing-message',
+                message: `Operation "${op.operationName}" refers to unknown message ${qnameToString(inputRef.message)}`,
+            });
+        }
+        else {
+            const style = bindingOperation.style ?? binding.style;
+            const body = bindingOperation.input?.body ?? { use: 'literal' };
+            bodyXml = buildBody(ctx, op.operationName, style, body, message, abstract?.parameterOrder);
+        }
+    }
+    return {
+        envelopeXml: createEnvelope(resolved.version, { headerXml, bodyXml, namespaces: scope.declarations() }, { indent }),
+        soapVersion: resolved.version,
+        ...(resolved.soapAction !== undefined ? { soapAction: resolved.soapAction } : {}),
+        ...transport(resolved.version, resolved.soapAction, options),
+        problems,
+    };
+}
+/**
+ * Builds an empty envelope for one binding operation — the "Create Empty"
+ * request. The envelope carries an empty `Header` and `Body`, while the SOAP
+ * version, action and `Content-Type` are exactly those of a sample request.
+ */
+export function buildEmptyRequest(input, op, options) {
+    const problems = [];
+    const resolved = resolveOperation(input, op, problems);
+    return {
+        envelopeXml: createEnvelope(resolved.version, { bodyXml: '' }, { indent: options?.indent ?? '   ' }),
+        soapVersion: resolved.version,
+        ...(resolved.soapAction !== undefined ? { soapAction: resolved.soapAction } : {}),
+        ...transport(resolved.version, resolved.soapAction, options),
+        problems,
+    };
+}

package/dist/soap/response-parser.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Structural parsing of a SOAP response envelope. Transport concerns (status
+ * codes, redirects, MTOM) belong to the HTTP layer; this module only turns
+ * response XML into the envelope's parts.
+ */
+import type { Element } from '@xmldom/xmldom';
+import type { SoapEnvelopeVersion } from './envelope.js';
+import type { SoapFault } from './fault.js';
+/** The dissected parts of a SOAP response envelope. */
+export interface ParsedSoapResponse {
+    readonly version: SoapEnvelopeVersion;
+    readonly envelope: Element;
+    /** The `Header` element, when the response carries one. */
+    readonly header?: Element;
+    readonly body: Element;
+    /** The `Body`'s element children, in document order (empty for an empty body). */
+    readonly bodyChildren: readonly Element[];
+    /** The parsed fault, when the body carries one. */
+    readonly fault?: SoapFault;
+}
+/**
+ * Parses a SOAP response envelope into its header, body and fault.
+ *
+ * @param xml the raw response body
+ * @throws {WirebenchError} `xml-parse-error` (propagated from {@link parseXml}) for malformed XML
+ * @throws {WirebenchError} `not-a-soap-envelope` when the root is not an `Envelope` in either SOAP namespace,
+ *   or when such an envelope has no `Body`; the caller decides how to surface a non-SOAP response
+ */
+export declare function parseSoapResponse(xml: string): ParsedSoapResponse;

package/dist/soap/response-parser.js

@@ -0,0 +1,71 @@
+/**
+ * Structural parsing of a SOAP response envelope. Transport concerns (status
+ * codes, redirects, MTOM) belong to the HTTP layer; this module only turns
+ * response XML into the envelope's parts.
+ */
+import { WirebenchError } from '../errors.js';
+import { parseXml } from '../xml/parse.js';
+import { detectEnvelopeVersion, envelopeNamespace } from './envelope.js';
+import { parseFault } from './fault.js';
+/** Element children of `parent` in the given namespace, in document order. */
+function childElementsNS(parent, namespaceUri, localName) {
+    const result = [];
+    for (let node = parent.firstChild; node !== null; node = node.nextSibling) {
+        if (node.nodeType !== 1) {
+            continue;
+        }
+        const element = node;
+        if (element.namespaceURI !== namespaceUri) {
+            continue;
+        }
+        if (localName === undefined || element.localName === localName) {
+            result.push(element);
+        }
+    }
+    return result;
+}
+/** Every element child of `parent`, in document order. */
+function allChildElements(parent) {
+    const result = [];
+    for (let node = parent.firstChild; node !== null; node = node.nextSibling) {
+        if (node.nodeType === 1) {
+            result.push(node);
+        }
+    }
+    return result;
+}
+/**
+ * Parses a SOAP response envelope into its header, body and fault.
+ *
+ * @param xml the raw response body
+ * @throws {WirebenchError} `xml-parse-error` (propagated from {@link parseXml}) for malformed XML
+ * @throws {WirebenchError} `not-a-soap-envelope` when the root is not an `Envelope` in either SOAP namespace,
+ *   or when such an envelope has no `Body`; the caller decides how to surface a non-SOAP response
+ */
+export function parseSoapResponse(xml) {
+    const doc = parseXml(xml);
+    const version = detectEnvelopeVersion(doc);
+    const envelope = doc.documentElement;
+    if (version === undefined || envelope === null) {
+        throw new WirebenchError('not-a-soap-envelope', 'Response is not a SOAP Envelope', {
+            details: { rootTag: envelope?.tagName ?? null, rootNamespace: envelope?.namespaceURI ?? null },
+        });
+    }
+    const ns = envelopeNamespace(version);
+    const body = childElementsNS(envelope, ns, 'Body')[0];
+    if (body === undefined) {
+        throw new WirebenchError('not-a-soap-envelope', 'SOAP Envelope has no Body element', {
+            details: { version },
+        });
+    }
+    const header = childElementsNS(envelope, ns, 'Header')[0];
+    const fault = parseFault(doc);
+    return {
+        version,
+        envelope,
+        ...(header !== undefined ? { header } : {}),
+        body,
+        bodyChildren: allChildElements(body),
+        ...(fault !== undefined ? { fault } : {}),
+    };
+}

package/dist/soap/soap-action.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The transport-level naming of a SOAP operation: SOAP 1.1's `SOAPAction`
+ * header versus SOAP 1.2's `action` media-type parameter.
+ */
+import type { SoapEnvelopeVersion } from './envelope.js';
+/** Knobs for {@link soapActionHeaders}. */
+export interface SoapActionOptions {
+    /** Suppress the action entirely (some servers reject an unexpected `SOAPAction`). */
+    readonly skipSoapAction?: boolean;
+    /** Charset for the `Content-Type`; `UTF-8` by default, and used verbatim. */
+    readonly charset?: string;
+}
+/** The `Content-Type` and any extra request headers naming the operation. */
+export interface SoapActionHeaders {
+    readonly contentType: string;
+    /** Additional headers to send; the `Content-Type` is *not* repeated here. */
+    readonly headers: Readonly<Record<string, string>>;
+}
+/**
+ * Computes the `Content-Type` and action-carrying headers for a request.
+ *
+ * SOAP 1.1 carries the action in a mandatory, always double-quoted `SOAPAction`
+ * header (an absent action is the empty quoted string `""`, per WSDL 1.1
+ * §3.5). SOAP 1.2 folds it into the `application/soap+xml` media type as an
+ * `action` parameter and defines no `SOAPAction` header at all.
+ *
+ * @param version the SOAP version of the envelope being sent
+ * @param soapAction the binding's `soapAction`, if any
+ * @param opts `skipSoapAction` omits the action in either version
+ */
+export declare function soapActionHeaders(version: SoapEnvelopeVersion, soapAction: string | undefined, opts?: SoapActionOptions): SoapActionHeaders;

package/dist/soap/soap-action.js

@@ -0,0 +1,28 @@
+/**
+ * The transport-level naming of a SOAP operation: SOAP 1.1's `SOAPAction`
+ * header versus SOAP 1.2's `action` media-type parameter.
+ */
+/**
+ * Computes the `Content-Type` and action-carrying headers for a request.
+ *
+ * SOAP 1.1 carries the action in a mandatory, always double-quoted `SOAPAction`
+ * header (an absent action is the empty quoted string `""`, per WSDL 1.1
+ * §3.5). SOAP 1.2 folds it into the `application/soap+xml` media type as an
+ * `action` parameter and defines no `SOAPAction` header at all.
+ *
+ * @param version the SOAP version of the envelope being sent
+ * @param soapAction the binding's `soapAction`, if any
+ * @param opts `skipSoapAction` omits the action in either version
+ */
+export function soapActionHeaders(version, soapAction, opts = {}) {
+    const charset = opts.charset ?? 'UTF-8';
+    const skip = opts.skipSoapAction === true;
+    if (version === '1.1') {
+        return {
+            contentType: `text/xml;charset=${charset}`,
+            headers: skip ? {} : { SOAPAction: `"${soapAction ?? ''}"` },
+        };
+    }
+    const action = !skip && soapAction !== undefined && soapAction.length > 0 ? `;action="${soapAction}"` : '';
+    return { contentType: `application/soap+xml;charset=${charset}${action}`, headers: {} };
+}

package/dist/soap/transforms.d.ts

@@ -0,0 +1,52 @@
+/**
+ * The envelope transforms applied on the way out, per request property:
+ * "Remove Empty Content", "Strip Whitespaces", "Pretty Print" and "Entitize Properties".
+ *
+ * All four are text transforms over a tolerant tokenizer, never a DOM round trip: an envelope
+ * a user hand-edited may not be well formed, and a transform that throws (or silently rewrites
+ * attribute quoting) on the way to the wire is worse than one that does nothing. Every function
+ * here returns its input unchanged when it cannot understand the document.
+ *
+ * Entitizing is the odd one out. It escapes the values substituted by property expansion,
+ * which cannot be identified after the fact — by the time an envelope is a string, a `&` that
+ * came from a property is indistinguishable from one the user typed. So {@link entitizeValue}
+ * is applied *during* expansion instead (see `project/properties.ts`'s `entitize` option), and
+ * lives here alongside its siblings.
+ */
+/**
+ * "Remove Empty Content": drops every element that has no attributes and whose whole
+ * content is empty, whitespace, or `?` placeholders — recursively, so a parent left with
+ * nothing but removed children goes too. The `Envelope`/`Header`/`Body` wrappers are never
+ * removed, however empty they are.
+ *
+ * @param xml the envelope text
+ * @returns the transformed envelope, or `xml` unchanged when it could not be parsed
+ */
+export declare function removeEmptyContent(xml: string): string;
+/**
+ * "Strip Whitespaces": drops whitespace-only text nodes between elements and trims
+ * the leading/trailing whitespace of every other text node. CDATA sections, comments and
+ * processing instructions are left exactly as they are.
+ *
+ * @param xml the envelope text
+ * @returns the transformed envelope, or `xml` unchanged when it could not be tokenized
+ */
+export declare function stripWhitespaces(xml: string): string;
+/**
+ * "Pretty Print": reformats the envelope with the given indent width.
+ *
+ * @param xml the envelope text
+ * @param indentWidth spaces per nesting level; defaults to 3, the editor's default tab size
+ * @returns the formatted envelope, or `xml` unchanged when it could not be formatted
+ */
+export declare function prettyPrint(xml: string, indentWidth?: number): string;
+/**
+ * "Entitize Properties", applied to one substituted property value: escapes the three
+ * characters that would otherwise be read as markup once the value lands inside an envelope.
+ *
+ * `"` and `'` are deliberately left alone: expansion targets element content far more often
+ * than an attribute value, and escaping quotes there would show up as `"` in the payload.
+ *
+ * @param value the expanded property value
+ */
+export declare function entitizeValue(value: string): string;