@wirebench/engine 2.1.1

package/dist/soap/legacy-project/parse.js

@@ -0,0 +1,325 @@
+/**
+ * Reads the text of a legacy single-XML SOAP project file into a {@link LegacyProject}.
+ *
+ * Tolerant by design: every optional element may be missing, and anything unexpected is skipped
+ * rather than fatal. Only a document that is not well-formed, is not this format, or is encrypted
+ * is rejected, with a {@link LegacyProjectError}.
+ */
+import { gunzipSync } from 'node:zlib';
+import { LegacyProjectError, WirebenchError } from '../../errors.js';
+import { parseXmlDetailed } from '../../xml/parse.js';
+import { serializeXml } from '../../xml/serialize.js';
+import { LEGACY_PROJECT_NAMESPACE, LEGACY_PROJECT_ROOT } from './format.js';
+const NS = LEGACY_PROJECT_NAMESPACE;
+/** The direct child elements of `parent` in the format's namespace, optionally only those called `localName`. */
+function children(parent, localName) {
+    const found = [];
+    for (let node = parent.firstChild; node !== null; node = node.nextSibling) {
+        if (node.nodeType !== 1) {
+            continue;
+        }
+        const element = node;
+        if (element.namespaceURI === NS && (localName === undefined || element.localName === localName)) {
+            found.push(element);
+        }
+    }
+    return found;
+}
+function child(parent, localName) {
+    return children(parent, localName)[0];
+}
+/** The text of the named child, or `undefined` when the child is missing. */
+function childText(parent, localName) {
+    const element = child(parent, localName);
+    return element === undefined ? undefined : (element.textContent ?? '');
+}
+/** An attribute's value, with an empty string treated as absent. */
+function attr(element, name) {
+    const value = element.getAttribute(name);
+    return value === null || value === '' ? undefined : value;
+}
+function nonEmpty(value) {
+    return value === undefined || value.trim() === '' ? undefined : value;
+}
+function readProperties(elements) {
+    const properties = [];
+    for (const element of elements) {
+        const name = nonEmpty(childText(element, 'name'))?.trim();
+        if (name !== undefined) {
+            properties.push({ name, value: childText(element, 'value') ?? '' });
+        }
+    }
+    return properties;
+}
+/**
+ * A cache part's document. It is held either as text (usually a CDATA section) or inline as the
+ * content element's single child element, which is serialized back to text.
+ */
+function partContent(content) {
+    for (let node = content.firstChild; node !== null; node = node.nextSibling) {
+        if (node.nodeType === 1) {
+            return serializeXml(node);
+        }
+    }
+    return (content.textContent ?? '').trim();
+}
+function readCache(iface) {
+    const cache = child(iface, 'definitionCache');
+    if (cache === undefined) {
+        return undefined;
+    }
+    const parts = [];
+    for (const part of children(cache, 'part')) {
+        const url = nonEmpty(childText(part, 'url'))?.trim();
+        const content = child(part, 'content');
+        if (url !== undefined && content !== undefined) {
+            parts.push({ url, content: partContent(content) });
+        }
+    }
+    if (parts.length === 0) {
+        return undefined;
+    }
+    const rootPart = attr(cache, 'rootPart');
+    return { ...(rootPart !== undefined ? { rootPart } : {}), parts };
+}
+/** Decodes a `request` element: plain text, or base64 of a gzip stream when `compression` is set. */
+function readEnvelope(request) {
+    if (request === undefined) {
+        return { envelopeProblem: 'it has no request body' };
+    }
+    const text = request.textContent ?? '';
+    const compression = attr(request, 'compression');
+    if (compression === undefined) {
+        return { envelope: text };
+    }
+    try {
+        return { envelope: gunzipSync(Buffer.from(text.trim(), 'base64')).toString('utf8') };
+    }
+    catch {
+        return { envelopeProblem: `its body is compressed as "${compression}", which could not be decoded` };
+    }
+}
+function readCredentials(call) {
+    const credentials = child(call, 'credentials');
+    if (credentials === undefined) {
+        return { hadPassword: false };
+    }
+    const username = nonEmpty(childText(credentials, 'username'));
+    const domain = nonEmpty(childText(credentials, 'domain'));
+    const authType = nonEmpty(childText(credentials, 'authType'));
+    return {
+        ...(username !== undefined ? { username } : {}),
+        ...(domain !== undefined ? { domain } : {}),
+        hadPassword: nonEmpty(childText(credentials, 'password')) !== undefined,
+        ...(authType !== undefined ? { authType } : {}),
+    };
+}
+function readCall(call, index) {
+    const endpoint = nonEmpty(childText(call, 'endpoint'))?.trim();
+    const encoding = nonEmpty(childText(call, 'encoding'))?.trim();
+    const timeout = attr(call, 'timeout');
+    const timeoutMs = timeout !== undefined && /^\d+$/.test(timeout.trim()) ? Number(timeout.trim()) : undefined;
+    const wssRefs = [attr(call, 'outgoingWss'), attr(call, 'incomingWss')].filter((ref) => ref !== undefined);
+    return {
+        name: attr(call, 'name') ?? `Request ${String(index + 1)}`,
+        ...(endpoint !== undefined ? { endpoint } : {}),
+        ...readEnvelope(child(call, 'request')),
+        ...(encoding !== undefined ? { encoding } : {}),
+        ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+        credentials: readCredentials(call),
+        useWsAddressing: attr(call, 'useWsAddressing') === 'true',
+        assertions: children(call, 'assertion').length,
+        attachments: children(call, 'attachment').length,
+        wssRefs,
+    };
+}
+function readOperation(operation, index) {
+    const name = attr(operation, 'name') ?? attr(operation, 'bindingOperationName') ?? `Operation ${String(index + 1)}`;
+    const action = attr(operation, 'action');
+    return {
+        name,
+        bindingOperationName: attr(operation, 'bindingOperationName') ?? name,
+        ...(action !== undefined ? { action } : {}),
+        calls: children(operation, 'call').map(readCall),
+    };
+}
+function readInterface(iface, index) {
+    const definitionUrl = attr(iface, 'definition');
+    const bindingName = attr(iface, 'bindingName');
+    const cache = readCache(iface);
+    const endpointsElement = child(iface, 'endpoints');
+    const endpoints = endpointsElement === undefined
+        ? []
+        : children(endpointsElement, 'endpoint')
+            .map((endpoint) => (endpoint.textContent ?? '').trim())
+            .filter((url) => url !== '');
+    return {
+        name: attr(iface, 'name') ?? `Interface ${String(index + 1)}`,
+        ...(definitionUrl !== undefined ? { definitionUrl } : {}),
+        ...(bindingName !== undefined ? { bindingName } : {}),
+        soapVersion: attr(iface, 'soapVersion') === '1_2' ? '1.2' : '1.1',
+        ...(cache !== undefined ? { cache } : {}),
+        endpoints: [...new Set(endpoints)],
+        operations: children(iface, 'operation').map(readOperation),
+    };
+}
+function readEnvironment(environment, index) {
+    const endpoints = [];
+    for (const service of children(environment, 'service')) {
+        const interfaceName = attr(service, 'name');
+        const url = nonEmpty(childText(service, 'endpoint'))?.trim();
+        if (interfaceName !== undefined && url !== undefined) {
+            endpoints.push({ interfaceName, url });
+        }
+    }
+    return {
+        name: attr(environment, 'name') ?? `Environment ${String(index + 1)}`,
+        properties: readProperties(children(environment, 'property')),
+        endpoints,
+    };
+}
+/** Names of the named elements from just below the root down to (and including) `element`. */
+function ownerPathOf(element, root) {
+    const path = [];
+    for (let node = element; node !== null && node !== root; node = node.parentNode) {
+        if (node.nodeType === 1) {
+            const name = attr(node, 'name');
+            if (name !== undefined) {
+                path.unshift(name);
+            }
+        }
+    }
+    return path;
+}
+/**
+ * Every script in the document: each element in the format's namespace whose local name ends in
+ * `Script` and has text, and the `script` body of each script test step.
+ */
+function collectScripts(root) {
+    const scripts = [];
+    const visit = (element) => {
+        for (let node = element.firstChild; node !== null; node = node.nextSibling) {
+            if (node.nodeType !== 1) {
+                continue;
+            }
+            const current = node;
+            const isHook = current.namespaceURI === NS && /Script$/.test(current.localName ?? '');
+            const isStepScript = current.localName === 'script' &&
+                current.parentNode?.nodeType === 1 &&
+                current.parentNode.localName === 'config';
+            if (isHook || isStepScript) {
+                const source = current.textContent ?? '';
+                if (source.trim() !== '') {
+                    const language = attr(current, 'language');
+                    const owner = current.parentNode;
+                    scripts.push({
+                        ownerPath: ownerPathOf(isStepScript ? owner.parentNode : owner, root),
+                        element: current.localName ?? 'script',
+                        ...(language !== undefined ? { language } : {}),
+                        source,
+                    });
+                }
+                continue;
+            }
+            visit(current);
+        }
+    };
+    visit(root);
+    return scripts;
+}
+function hasChildElements(element) {
+    if (element === undefined) {
+        return false;
+    }
+    for (let node = element.firstChild; node !== null; node = node.nextSibling) {
+        if (node.nodeType === 1) {
+            return true;
+        }
+    }
+    return false;
+}
+/** Everything under the root that holds user work v1 does not map, for the import report. */
+function collectUnmapped(root) {
+    const unmapped = [];
+    for (const iface of children(root, 'interface')) {
+        const type = attr(iface, 'type');
+        if (type !== 'wsdl') {
+            unmapped.push({
+                ownerPath: [attr(iface, 'name') ?? 'Unnamed service'],
+                message: `A ${type ?? 'non-SOAP'} service is not imported; only SOAP interfaces are.`,
+            });
+        }
+    }
+    for (const suite of children(root, 'testSuite')) {
+        const cases = children(suite, 'testCase').length;
+        unmapped.push({
+            ownerPath: [attr(suite, 'name') ?? 'Unnamed test suite'],
+            message: `Test suite with ${String(cases)} test case${cases === 1 ? '' : 's'} is not imported.`,
+        });
+    }
+    for (const kind of ['mockService', 'restMockService']) {
+        for (const mock of children(root, kind)) {
+            unmapped.push({
+                ownerPath: [attr(mock, 'name') ?? 'Unnamed mock service'],
+                message: 'Mock service is not imported.',
+            });
+        }
+    }
+    const containers = [
+        ['wssContainer', 'WS-Security configurations and keystores are not imported; set them up under WS-Security.'],
+        ['databaseConnectionContainer', 'Database connections are not imported.'],
+        ['oAuth2ProfileContainer', 'OAuth 2.0 profiles are not imported.'],
+        ['oAuth1ProfileContainer', 'OAuth 1.0 profiles are not imported.'],
+        ['requirements', 'Requirements are not imported.'],
+    ];
+    for (const [localName, message] of containers) {
+        if (hasChildElements(child(root, localName))) {
+            unmapped.push({ ownerPath: [], message });
+        }
+    }
+    return unmapped;
+}
+/**
+ * Parses `text` as a legacy single-XML SOAP project.
+ *
+ * @throws LegacyProjectError `legacy-malformed` when the XML is not well-formed or declares a DTD,
+ *   `legacy-not-a-project` when it is some other document, and `legacy-encrypted` when the project
+ *   was saved encrypted.
+ */
+export function parseLegacyProject(text, location) {
+    if (/<!DOCTYPE/i.test(text)) {
+        throw new LegacyProjectError('legacy-malformed', 'The project file declares a DTD, which is not accepted', {
+            ...(location !== undefined ? { details: { location } } : {}),
+        });
+    }
+    let root;
+    try {
+        root = parseXmlDetailed(text, location !== undefined ? { location } : undefined).document.documentElement;
+    }
+    catch (cause) {
+        const message = cause instanceof WirebenchError ? cause.message : 'The file is not well-formed XML';
+        throw new LegacyProjectError('legacy-malformed', `The project file is not well-formed XML: ${message}`, {
+            cause,
+            ...(cause instanceof WirebenchError && cause.details !== undefined ? { details: cause.details } : {}),
+        });
+    }
+    if (root === null || root.namespaceURI !== NS || root.localName !== LEGACY_PROJECT_ROOT) {
+        throw new LegacyProjectError('legacy-not-a-project', 'The file is not a legacy SOAP project');
+    }
+    if (nonEmpty(childText(root, 'encryptedContent')) !== undefined) {
+        throw new LegacyProjectError('legacy-encrypted', 'The project was saved encrypted. Open it in the tool that wrote it, save it without a password, and import that copy.');
+    }
+    const description = nonEmpty(childText(root, 'description'));
+    const propertiesElement = child(root, 'properties');
+    return {
+        name: attr(root, 'name') ?? 'Imported project',
+        ...(description !== undefined ? { description } : {}),
+        properties: propertiesElement === undefined ? [] : readProperties(children(propertiesElement, 'property')),
+        interfaces: children(root, 'interface')
+            .filter((iface) => attr(iface, 'type') === 'wsdl')
+            .map(readInterface),
+        environments: children(root, 'environment').map(readEnvironment),
+        scripts: collectScripts(root),
+        unmapped: collectUnmapped(root),
+    };
+}

package/dist/soap/mime/cid-scan.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Finding the `cid:` references an envelope makes, without a DOM.
+ *
+ * Both MTOM and SwA key off the same syntactic rule: an element whose text
+ * content is *exactly* a `cid:` reference points at an attachment. Anything else — a
+ * sentence that merely mentions `cid:`, an attribute, a mixed-content element — is left
+ * alone. The tolerant scanner is used (rather than a strict parse) because a request being
+ * edited is frequently not yet well-formed, and a half-typed envelope must still send.
+ */
+import { type ScannedElement, type TextRange } from '../../xsd/xml-scan.js';
+/** One `cid:` reference found in an envelope, with the range of the text that carries it. */
+export interface CidReference {
+    /** The reference without its `cid:` scheme, e.g. `A1@wirebench`. */
+    readonly cid: string;
+    /** Range of the element's text content, ready to be spliced over. */
+    readonly range: TextRange;
+}
+/** What {@link findCidReferences} found. */
+export interface CidScan {
+    readonly references: readonly CidReference[];
+    /** False when the envelope was too malformed to scan; callers then leave it untouched. */
+    readonly scannable: boolean;
+}
+/** Visits every element of a scanned envelope, depth first, parents before children. */
+export declare function forEachScannedElement(elements: readonly ScannedElement[], visit: (element: ScannedElement) => void): void;
+/**
+ * Every element whose entire text content is a `cid:` reference, in document order.
+ *
+ * @param envelopeXml the envelope to scan
+ */
+export declare function findCidReferences(envelopeXml: string): CidScan;
+/** Replaces `[start, end)` ranges in `text`, applying them right to left so offsets stay valid. */
+export declare function spliceRanges(text: string, edits: readonly {
+    readonly range: TextRange;
+    readonly text: string;
+}[]): string;

package/dist/soap/mime/cid-scan.js

@@ -0,0 +1,52 @@
+/**
+ * Finding the `cid:` references an envelope makes, without a DOM.
+ *
+ * Both MTOM and SwA key off the same syntactic rule: an element whose text
+ * content is *exactly* a `cid:` reference points at an attachment. Anything else — a
+ * sentence that merely mentions `cid:`, an attribute, a mixed-content element — is left
+ * alone. The tolerant scanner is used (rather than a strict parse) because a request being
+ * edited is frequently not yet well-formed, and a half-typed envelope must still send.
+ */
+import { scanXml } from '../../xsd/xml-scan.js';
+const CID_TEXT = /^cid:(.+)$/;
+function walk(elements, visit) {
+    for (const element of elements) {
+        visit(element);
+        walk(element.children, visit);
+    }
+}
+/** Visits every element of a scanned envelope, depth first, parents before children. */
+export function forEachScannedElement(elements, visit) {
+    walk(elements, visit);
+}
+/**
+ * Every element whose entire text content is a `cid:` reference, in document order.
+ *
+ * @param envelopeXml the envelope to scan
+ */
+export function findCidReferences(envelopeXml) {
+    const scan = scanXml(envelopeXml);
+    if (scan.problems.length > 0) {
+        return { references: [], scannable: false };
+    }
+    const references = [];
+    forEachScannedElement(scan.elements, (element) => {
+        const text = element.text;
+        if (text === undefined) {
+            return;
+        }
+        const match = CID_TEXT.exec(text.value.trim());
+        if (match?.[1] !== undefined) {
+            references.push({ cid: match[1], range: text.range });
+        }
+    });
+    return { references, scannable: true };
+}
+/** Replaces `[start, end)` ranges in `text`, applying them right to left so offsets stay valid. */
+export function spliceRanges(text, edits) {
+    let out = text;
+    for (const edit of [...edits].sort((a, b) => b.range.start - a.range.start)) {
+        out = out.slice(0, edit.range.start) + edit.text + out.slice(edit.range.end);
+    }
+    return out;
+}

package/dist/soap/mime/inline-files.d.ts

@@ -0,0 +1,39 @@
+/**
+ * "Enable Inline Files": an element whose text is exactly `file:<path>` has that
+ * file's bytes substituted, base64-encoded, at send time.
+ *
+ * The decision is syntactic, not schema-driven, so a
+ * request can carry a file reference before its schema is even known. A reference that
+ * cannot be read is reported and left verbatim in the envelope rather than failing the
+ * send: the server's own error is usually more informative than a client-side abort.
+ */
+/** Knobs for {@link inlineFiles}. */
+export interface InlineFilesOptions {
+    /** The request's "Enable Inline Files" property; nothing happens when false. */
+    readonly enabled: boolean;
+    /** Reads one file, rejecting when it does not exist. */
+    readonly resolveFile: (path: string) => Promise<Uint8Array>;
+    /** Project resource root; relative references are tried against it first. */
+    readonly resourceRoot?: string;
+}
+/** A file reference that could not be read. */
+export interface InlineFileProblem {
+    readonly code: 'inline-file-missing';
+    readonly message: string;
+    /** The path as written in the envelope. */
+    readonly path: string;
+}
+/** What {@link inlineFiles} produced. */
+export interface InlinedFiles {
+    readonly envelopeXml: string;
+    /** How many references were replaced. */
+    readonly inlined: number;
+    readonly problems: readonly InlineFileProblem[];
+}
+/**
+ * Replaces every `file:` reference in `envelopeXml` with the base64 of the file it names.
+ *
+ * @param envelopeXml the envelope to rewrite
+ * @param options whether the feature is on, how to read a file, and the resource root
+ */
+export declare function inlineFiles(envelopeXml: string, options: InlineFilesOptions): Promise<InlinedFiles>;

package/dist/soap/mime/inline-files.js

@@ -0,0 +1,71 @@
+/**
+ * "Enable Inline Files": an element whose text is exactly `file:<path>` has that
+ * file's bytes substituted, base64-encoded, at send time.
+ *
+ * The decision is syntactic, not schema-driven, so a
+ * request can carry a file reference before its schema is even known. A reference that
+ * cannot be read is reported and left verbatim in the envelope rather than failing the
+ * send: the server's own error is usually more informative than a client-side abort.
+ */
+import { isAbsolute, join } from 'node:path';
+import { scanXml } from '../../xsd/xml-scan.js';
+import { forEachScannedElement, spliceRanges } from './cid-scan.js';
+const FILE_TEXT = /^file:(.+)$/;
+/** The paths a reference may resolve to, most specific first. */
+function candidatePaths(reference, resourceRoot) {
+    const path = reference.startsWith('//') ? reference.slice(2) : reference;
+    if (isAbsolute(path) || resourceRoot === undefined) {
+        return [path];
+    }
+    return [join(resourceRoot, path), path];
+}
+/**
+ * Replaces every `file:` reference in `envelopeXml` with the base64 of the file it names.
+ *
+ * @param envelopeXml the envelope to rewrite
+ * @param options whether the feature is on, how to read a file, and the resource root
+ */
+export async function inlineFiles(envelopeXml, options) {
+    if (!options.enabled) {
+        return { envelopeXml, inlined: 0, problems: [] };
+    }
+    const scan = scanXml(envelopeXml);
+    if (scan.problems.length > 0) {
+        return { envelopeXml, inlined: 0, problems: [] };
+    }
+    const references = [];
+    forEachScannedElement(scan.elements, (element) => {
+        const text = element.text;
+        if (text === undefined) {
+            return;
+        }
+        const match = FILE_TEXT.exec(text.value.trim());
+        if (match?.[1] !== undefined) {
+            references.push({ path: match[1], range: text.range });
+        }
+    });
+    const edits = [];
+    const problems = [];
+    for (const reference of references) {
+        let bytes;
+        for (const candidate of candidatePaths(reference.path, options.resourceRoot)) {
+            try {
+                bytes = await options.resolveFile(candidate);
+                break;
+            }
+            catch {
+                bytes = undefined;
+            }
+        }
+        if (bytes === undefined) {
+            problems.push({
+                code: 'inline-file-missing',
+                message: `Inline file "${reference.path}" could not be read; the reference was left in the request`,
+                path: reference.path,
+            });
+            continue;
+        }
+        edits.push({ range: reference.range, text: Buffer.from(bytes).toString('base64') });
+    }
+    return { envelopeXml: spliceRanges(envelopeXml, edits), inlined: edits.length, problems };
+}

package/dist/soap/mime/mtom.d.ts

@@ -0,0 +1,74 @@
+/**
+ * MTOM/XOP (SOAP Message Transmission Optimization Mechanism).
+ *
+ * Outgoing, this implements the rule the request editor exposes: an element
+ * whose text is exactly `cid:<content-id>` names an attachment, and enabling MTOM replaces
+ * that text with an `<xop:Include>` while the bytes travel unencoded in their own MIME
+ * part. Nothing is inferred from the schema — a base64Binary element that does not carry a
+ * `cid:` reference is left alone, and a `cid:` reference naming no attachment stays as it
+ * is (the server may know what it means).
+ *
+ * Incoming, an `<xop:Include>` can either be expanded back into base64 inside the envelope
+ * ("Expand MTOM Attachments") or left in place with the part listed alongside.
+ */
+import type { Attachment } from '../../project/model.js';
+import { type ParsedMultipart } from './multipart.js';
+import type { AttachmentResolver, MultipartPart, ResponseAttachment } from './types.js';
+/** The XOP namespace, whose `Include` element replaces optimised content. */
+export declare const XOP_NS = "http://www.w3.org/2004/08/xop/include";
+/** Knobs for {@link prepareMtomRequest}. */
+export interface MtomOptions {
+    /** "Force MTOM": package as MTOM even when nothing was optimised. */
+    readonly force: boolean;
+    readonly resolver: AttachmentResolver;
+}
+/** What {@link prepareMtomRequest} produced. */
+export interface PreparedMtom {
+    /** The envelope with every resolved `cid:` reference replaced by an `xop:Include`. */
+    readonly envelopeXml: string;
+    readonly parts: readonly MultipartPart[];
+    /** True when the message must be packaged as an MTOM `multipart/related`. */
+    readonly used: boolean;
+    /** Ids of the attachments that became XOP parts; the rest fall through to SwA. */
+    readonly consumedIds: readonly string[];
+}
+/** What {@link expandMtomResponse} produced. */
+export interface ExpandedMtom {
+    readonly envelopeXml: string;
+    readonly attachments: readonly ResponseAttachment[];
+    /** Content-IDs whose bytes were written into the envelope as base64. */
+    readonly inlinedContentIds: readonly string[];
+}
+/**
+ * Turns a SOAP content type into the XOP root part's content type.
+ *
+ * The SOAP media type moves into the `type` parameter (so the receiver knows what the
+ * package encodes) and any SOAP 1.2 `action` parameter is kept, at the end, on the root
+ * part itself — the multipart's own `Content-Type` has no room for it.
+ *
+ * @param soapContentType e.g. `text/xml;charset=UTF-8` or `application/soap+xml;charset=UTF-8;action="urn:Add"`
+ */
+export declare function xopContentType(soapContentType: string): string;
+/**
+ * Rewrites `envelopeXml` for MTOM and resolves the bytes of every attachment it optimises.
+ *
+ * @param envelopeXml the envelope as it would otherwise be sent
+ * @param attachments the request's attachments
+ * @param options `force` packaging and the resolver that reads attachment bytes
+ */
+export declare function prepareMtomRequest(envelopeXml: string, attachments: readonly Attachment[], options: MtomOptions): Promise<PreparedMtom>;
+/**
+ * Expands (or merely lists) the XOP parts of a `multipart/related` response.
+ *
+ * With `inline` set, every `<xop:Include>` whose part is present is replaced by that
+ * part's base64, which is what the receiver's own XML tooling would have seen; the parts
+ * stay listed so the caller can still show and save them. Without it the envelope is
+ * returned as received.
+ *
+ * @param parsed the parsed multipart response
+ * @param options `inline` expansion, and the already charset-decoded root text when the caller has it
+ */
+export declare function expandMtomResponse(parsed: ParsedMultipart, options: {
+    readonly inline: boolean;
+    readonly envelopeXml?: string;
+}): ExpandedMtom;