@wirebench/engine 2.2.1 → 3.1.0-rc.1

package/dist/soap/curl.d.ts

@@ -0,0 +1,20 @@
+/**
+ * A SOAP send as a `curl` command, and a pasted `curl` command back as a partial SOAP send input.
+ *
+ * The command itself — the quoting, the line continuations, the two shells — is `http/curl.ts`'s
+ * {@link toCurl}; this file builds its description from a {@link SoapSendInput}, as `rest/curl.ts`
+ * does from a REST one.
+ */
+import type { ToCurlOptions } from '../http/curl.js';
+import type { SoapSendInput } from './types.js';
+/** Builds a `curl` command reproducing a SOAP send — headers, envelope and all. */
+export declare function soapToCurl(input: SoapSendInput & {
+    readonly contentType?: string;
+}, options?: ToCurlOptions): string;
+/** Result of {@link fromCurl}. */
+export interface FromCurlResult {
+    readonly input: Partial<SoapSendInput>;
+    readonly problems: readonly string[];
+}
+/** Parses a pasted `curl` command back into a partial {@link SoapSendInput}. */
+export declare function fromCurl(text: string): FromCurlResult;

package/dist/soap/curl.js

@@ -0,0 +1,161 @@
+/**
+ * A SOAP send as a `curl` command, and a pasted `curl` command back as a partial SOAP send input.
+ *
+ * The command itself — the quoting, the line continuations, the two shells — is `http/curl.ts`'s
+ * {@link toCurl}; this file builds its description from a {@link SoapSendInput}, as `rest/curl.ts`
+ * does from a REST one.
+ */
+import { expandBundles, takesNoValue } from '../http/curl-flags.js';
+import { toCurl } from '../http/curl.js';
+import { findHeredoc, findHereString } from '../http/heredoc.js';
+import { soapActionHeaders } from './soap-action.js';
+/** Builds a `curl` command reproducing a SOAP send — headers, envelope and all. */
+export function soapToCurl(input, options = {}) {
+    const actionHeaders = soapActionHeaders(input.soapVersion, input.soapAction, input.skipSoapAction !== undefined ? { skipSoapAction: input.skipSoapAction } : {});
+    const contentType = input.contentType ?? input.headers?.['Content-Type'] ?? actionHeaders.contentType;
+    const headers = [{ name: 'Content-Type', value: contentType }];
+    if (input.soapVersion === '1.1' && input.headers?.['SOAPAction'] === undefined) {
+        headers.push({ name: 'SOAPAction', value: `"${input.soapAction ?? ''}"` });
+    }
+    for (const [name, value] of Object.entries(input.headers ?? {})) {
+        if (name === 'Content-Type')
+            continue;
+        headers.push({ name, value });
+    }
+    return toCurl({ method: 'POST', url: input.endpoint, headers, body: { kind: 'raw', text: input.envelopeXml } }, options);
+}
+/** Splits a command line into tokens, respecting single/double quoted spans (no `$'…'` support). */
+function tokenize(text) {
+    const tokens = [];
+    let i = 0;
+    const len = text.length;
+    while (i < len) {
+        while (i < len && /\s/.test(text[i]))
+            i += 1;
+        if (i >= len)
+            break;
+        let token = '';
+        while (i < len && !/\s/.test(text[i])) {
+            const ch = text[i];
+            if (ch === "'" || ch === '"') {
+                const quote = ch;
+                i += 1;
+                const start = i;
+                while (i < len && text[i] !== quote)
+                    i += 1;
+                token += text.slice(start, i);
+                i += 1;
+            }
+            else if (ch === '\\' && i + 1 < len) {
+                token += text[i + 1];
+                i += 2;
+            }
+            else if (ch === '`' || (ch === '\\' && text[i + 1] === '\n')) {
+                // line continuation markers; skip
+                i += 1;
+            }
+            else {
+                token += ch;
+                i += 1;
+            }
+        }
+        if (token.length > 0)
+            tokens.push(token);
+    }
+    return tokens;
+}
+/** Parses a pasted `curl` command back into a partial {@link SoapSendInput}. */
+export function fromCurl(text) {
+    const problems = [];
+    // Pull out a heredoc/here-string body (`<<'EOF' ... EOF` or `@'...'@`) before line-splicing and
+    // tokenizing the rest — its content is verbatim and may contain anything, including newlines.
+    let heredocData;
+    let withoutHeredoc = text;
+    const embedded = findHeredoc(text) ?? findHereString(text);
+    if (embedded !== undefined) {
+        heredocData = embedded.body;
+        withoutHeredoc = text.slice(0, embedded.start) + text.slice(embedded.end);
+    }
+    const normalized = withoutHeredoc
+        .replace(/\\\r?\n/g, ' ')
+        .replace(/`\r?\n/g, ' ')
+        .trim();
+    const tokens = expandBundles(tokenize(normalized));
+    let endpoint;
+    let envelopeXml;
+    const headers = {};
+    let i = 0;
+    if (tokens[0] === 'curl' || tokens[0] === 'curl.exe')
+        i += 1;
+    while (i < tokens.length) {
+        const tok = tokens[i];
+        if (tok === '-X' || tok === '--request') {
+            i += 2;
+            continue;
+        }
+        if (tok === '-H' || tok === '--header') {
+            const header = tokens[i + 1] ?? '';
+            const colon = header.indexOf(':');
+            if (colon !== -1) {
+                const key = header.slice(0, colon).trim();
+                const value = header.slice(colon + 1).trim();
+                headers[key] = value;
+            }
+            i += 2;
+            continue;
+        }
+        if (tok === '-d' || tok === '--data' || tok === '--data-binary' || tok === '--data-raw') {
+            const data = tokens[i + 1] ?? '';
+            if ((data === '@-' || data === '') && heredocData !== undefined) {
+                envelopeXml = heredocData;
+            }
+            else if (data.startsWith('@')) {
+                problems.push('data-from-file-unsupported');
+            }
+            else {
+                envelopeXml = data;
+            }
+            i += 2;
+            continue;
+        }
+        if (tok === '--url') {
+            endpoint = tokens[i + 1];
+            i += 2;
+            continue;
+        }
+        if (tok === '-u' || tok === '--user') {
+            problems.push('basic-auth-ignored');
+            i += 2;
+            continue;
+        }
+        if (tok.startsWith('-')) {
+            // A flag with no field here: skip its value too, unless it is one that takes none.
+            problems.push(`ignored-flag:${tok}`);
+            i += takesNoValue(tok) ? 1 : 2;
+            continue;
+        }
+        // bare token: the URL
+        if (endpoint === undefined) {
+            endpoint = tok;
+        }
+        i += 1;
+    }
+    const soapActionHeader = headers['SOAPAction'];
+    let soapAction;
+    if (soapActionHeader !== undefined) {
+        soapAction = soapActionHeader.replace(/^"|"$/g, '');
+    }
+    const contentType = headers['Content-Type'];
+    const soapVersion = contentType?.includes('application/soap+xml') === true ? '1.2' : '1.1';
+    const extraHeaders = { ...headers };
+    delete extraHeaders['SOAPAction'];
+    delete extraHeaders['Content-Type'];
+    const input = {
+        ...(endpoint !== undefined ? { endpoint } : {}),
+        ...(envelopeXml !== undefined ? { envelopeXml } : {}),
+        soapVersion,
+        ...(soapAction !== undefined ? { soapAction } : {}),
+        ...(Object.keys(extraHeaders).length > 0 ? { headers: extraHeaders } : {}),
+    };
+    return { input, problems };
+}

package/dist/soap/expand.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Property expansion over a SOAP send input: the endpoint, the envelope, the SOAP action, the
+ * headers, the attachments and the WS-Addressing fields.
+ *
+ * The expansion itself is `project/properties.ts`'s {@link expand}; this file knows which fields of
+ * a {@link SoapSendInput} take it, as `rest/expand.ts`, `grpc/expand.ts` and `ws/expand.ts` do for
+ * theirs.
+ */
+import type { ExpandOptions, PropertyScopes, UnresolvedRef } from '../project/properties.js';
+import type { SoapSendInput } from './types.js';
+/**
+ * Expands the endpoint, envelope, soap action, and every header name/value of a
+ * {@link SoapSendInput}. Header *names* are expanded too, so two headers whose names expand to
+ * the same string collapse into one entry (last-write-wins, per `Object.entries` insertion
+ * order — same as any other JS object key collision).
+ *
+ * Attachments are expanded as well, in the two places a property can reasonably appear: the
+ * display/file name that ends up in `Content-Disposition`, and the path of a file-backed
+ * attachment. Content-IDs are left alone — they are generated, not authored.
+ */
+export declare function expandSendInput(input: SoapSendInput, scopes: PropertyScopes, options?: ExpandOptions): {
+    input: SoapSendInput;
+    unresolved: UnresolvedRef[];
+};

package/dist/soap/expand.js

@@ -0,0 +1,95 @@
+/**
+ * Property expansion over a SOAP send input: the endpoint, the envelope, the SOAP action, the
+ * headers, the attachments and the WS-Addressing fields.
+ *
+ * The expansion itself is `project/properties.ts`'s {@link expand}; this file knows which fields of
+ * a {@link SoapSendInput} take it, as `rest/expand.ts`, `grpc/expand.ts` and `ws/expand.ts` do for
+ * theirs.
+ */
+import { expand } from '../project/properties.js';
+import { assertNoControlCharacters, assertOriginIndependent, escapeXmlValue, expandWithSequenceEscaped, } from '../project/sequence-guards.js';
+/**
+ * Expands the endpoint, envelope, soap action, and every header name/value of a
+ * {@link SoapSendInput}. Header *names* are expanded too, so two headers whose names expand to
+ * the same string collapse into one entry (last-write-wins, per `Object.entries` insertion
+ * order — same as any other JS object key collision).
+ *
+ * Attachments are expanded as well, in the two places a property can reasonably appear: the
+ * display/file name that ends up in `Content-Disposition`, and the path of a file-backed
+ * attachment. Content-IDs are left alone — they are generated, not authored.
+ */
+export function expandSendInput(input, scopes, options) {
+    const unresolved = [];
+    /** Expands `text`; `place`, when given, names a line-oriented field a Sequence value must not break. */
+    function run(text, place) {
+        const result = expand(text, scopes, { ...options, entitize: false });
+        unresolved.push(...result.unresolved);
+        if (place !== undefined) {
+            assertNoControlCharacters(place, result, scopes);
+        }
+        return result.text;
+    }
+    // The endpoint is where the envelope, and every credential with it, goes (ADR-0015).
+    assertOriginIndependent('The endpoint', (s) => expand(input.endpoint, s).text, scopes);
+    const endpoint = run(input.endpoint, 'The endpoint');
+    const envelopeXml = expandEnvelope(input.envelopeXml, scopes, options, input.entitize, unresolved);
+    const soapAction = input.soapAction !== undefined ? run(input.soapAction, 'The SOAP action') : undefined;
+    let headers;
+    if (input.headers !== undefined) {
+        headers = {};
+        for (const [name, value] of Object.entries(input.headers)) {
+            headers[run(name, 'A header name')] = run(value, `The ${name} header`);
+        }
+    }
+    const attachments = input.attachments?.map((attachment) => ({
+        ...attachment,
+        name: run(attachment.name),
+        source: attachment.source.kind === 'path'
+            ? { kind: 'path', path: run(attachment.source.path) }
+            : attachment.source,
+    }));
+    // The explicit WS-Addressing fields are user-typed strings just like the endpoint or a
+    // header value, and may carry the same `${#Env#…}`/`${#Global#…}` references — so they go
+    // through the same scopes rather than reaching the wire verbatim.
+    const wsa = input.wsa !== undefined
+        ? {
+            ...input.wsa,
+            config: {
+                ...input.wsa.config,
+                ...(input.wsa.config.to !== undefined ? { to: run(input.wsa.config.to, 'wsa:To') } : {}),
+                ...(input.wsa.config.action !== undefined ? { action: run(input.wsa.config.action, 'wsa:Action') } : {}),
+                ...(input.wsa.config.replyTo !== undefined
+                    ? { replyTo: run(input.wsa.config.replyTo, 'wsa:ReplyTo') }
+                    : {}),
+                ...(input.wsa.config.from !== undefined ? { from: run(input.wsa.config.from, 'wsa:From') } : {}),
+                ...(input.wsa.config.faultTo !== undefined
+                    ? { faultTo: run(input.wsa.config.faultTo, 'wsa:FaultTo') }
+                    : {}),
+            },
+        }
+        : undefined;
+    return {
+        input: {
+            ...input,
+            endpoint,
+            envelopeXml,
+            ...(soapAction !== undefined ? { soapAction } : {}),
+            ...(headers !== undefined ? { headers } : {}),
+            ...(attachments !== undefined ? { attachments } : {}),
+            ...(wsa !== undefined ? { wsa } : {}),
+        },
+        unresolved,
+    };
+}
+/**
+ * The envelope, expanded. Only the envelope is entitized: escaping a header value or an endpoint
+ * would corrupt it. A Sequence value is XML-escaped here whatever the request's own setting, quotes
+ * included, because it came from a response and could otherwise add elements or attributes to the
+ * envelope (ADR-0015).
+ */
+function expandEnvelope(envelopeXml, scopes, options, requested, unresolved) {
+    const entitize = options?.entitize ?? requested ?? false;
+    const result = expand(envelopeXml, scopes, { ...options, entitize });
+    unresolved.push(...result.unresolved);
+    return expandWithSequenceEscaped((s) => expand(envelopeXml, s, { ...options, entitize }).text, scopes, escapeXmlValue);
+}

package/dist/soap/files.d.ts

@@ -0,0 +1,384 @@
+/**
+ * The SOAP files of a project folder: `interfaces/<slug>/interface.yaml` and each
+ * `operations/<slug>/<name>.request.yaml` under it (spec §3.2). The shared pieces and the
+ * strictness policy are `project/schema-parts.ts`'s.
+ */
+import { z } from 'zod';
+/** `interfaces/<slug>/interface.yaml`. */
+export declare const interfaceFileSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"soap">;
+    id: z.ZodString;
+    name: z.ZodString;
+    order: z.ZodNumber;
+    definitionUrl: z.ZodString;
+    cacheDefinition: z.ZodBoolean;
+    targetNamespace: z.ZodOptional<z.ZodString>;
+    endpoints: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        url: z.ZodString;
+        auth: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodEnum<{
+                none: "none";
+                basic: "basic";
+                ntlm: "ntlm";
+            }>;
+            username: z.ZodOptional<z.ZodString>;
+            passwordRef: z.ZodOptional<z.ZodString>;
+            passwordEnv: z.ZodOptional<z.ZodString>;
+            domain: z.ZodOptional<z.ZodString>;
+            workstation: z.ZodOptional<z.ZodString>;
+            preemptive: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$loose>, z.ZodObject<{
+            type: z.ZodLiteral<"bearer">;
+            tokenRef: z.ZodOptional<z.ZodString>;
+            tokenEnv: z.ZodOptional<z.ZodString>;
+            scheme: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>, z.ZodObject<{
+            type: z.ZodLiteral<"api-key">;
+            name: z.ZodString;
+            valueRef: z.ZodOptional<z.ZodString>;
+            valueEnv: z.ZodOptional<z.ZodString>;
+            in: z.ZodEnum<{
+                header: "header";
+                query: "query";
+            }>;
+        }, z.core.$loose>, z.ZodObject<{
+            type: z.ZodLiteral<"oauth2">;
+            grant: z.ZodEnum<{
+                "client-credentials": "client-credentials";
+                "authorization-code": "authorization-code";
+            }>;
+            tokenUrl: z.ZodString;
+            authorizationUrl: z.ZodOptional<z.ZodString>;
+            clientId: z.ZodString;
+            clientSecretRef: z.ZodOptional<z.ZodString>;
+            clientSecretEnv: z.ZodOptional<z.ZodString>;
+            scopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            audience: z.ZodOptional<z.ZodString>;
+            clientAuth: z.ZodDefault<z.ZodEnum<{
+                basic: "basic";
+                body: "body";
+            }>>;
+            pkce: z.ZodDefault<z.ZodBoolean>;
+            refreshTokenRef: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>]>>;
+        authMode: z.ZodEnum<{
+            override: "override";
+            complement: "complement";
+        }>;
+        trustInvalid: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>;
+    defaultEndpointId: z.ZodOptional<z.ZodString>;
+    wsa: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        version: z.ZodOptional<z.ZodEnum<{
+            "2005/08": "2005/08";
+            "2004/08": "2004/08";
+        }>>;
+        mustUnderstand: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            true: "true";
+            false: "false";
+        }>>;
+        action: z.ZodOptional<z.ZodString>;
+        to: z.ZodOptional<z.ZodString>;
+        messageId: z.ZodOptional<z.ZodString>;
+        replyTo: z.ZodOptional<z.ZodString>;
+        from: z.ZodOptional<z.ZodString>;
+        faultTo: z.ZodOptional<z.ZodString>;
+        relatesTo: z.ZodOptional<z.ZodString>;
+        relationshipType: z.ZodOptional<z.ZodString>;
+        addDefaultAction: z.ZodOptional<z.ZodBoolean>;
+        addDefaultTo: z.ZodOptional<z.ZodBoolean>;
+        generateMessageId: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>;
+    auth: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodEnum<{
+            none: "none";
+            basic: "basic";
+            ntlm: "ntlm";
+        }>;
+        username: z.ZodOptional<z.ZodString>;
+        passwordRef: z.ZodOptional<z.ZodString>;
+        passwordEnv: z.ZodOptional<z.ZodString>;
+        domain: z.ZodOptional<z.ZodString>;
+        workstation: z.ZodOptional<z.ZodString>;
+        preemptive: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"bearer">;
+        tokenRef: z.ZodOptional<z.ZodString>;
+        tokenEnv: z.ZodOptional<z.ZodString>;
+        scheme: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"api-key">;
+        name: z.ZodString;
+        valueRef: z.ZodOptional<z.ZodString>;
+        valueEnv: z.ZodOptional<z.ZodString>;
+        in: z.ZodEnum<{
+            header: "header";
+            query: "query";
+        }>;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"oauth2">;
+        grant: z.ZodEnum<{
+            "client-credentials": "client-credentials";
+            "authorization-code": "authorization-code";
+        }>;
+        tokenUrl: z.ZodString;
+        authorizationUrl: z.ZodOptional<z.ZodString>;
+        clientId: z.ZodString;
+        clientSecretRef: z.ZodOptional<z.ZodString>;
+        clientSecretEnv: z.ZodOptional<z.ZodString>;
+        scopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        audience: z.ZodOptional<z.ZodString>;
+        clientAuth: z.ZodDefault<z.ZodEnum<{
+            basic: "basic";
+            body: "body";
+        }>>;
+        pkce: z.ZodDefault<z.ZodBoolean>;
+        refreshTokenRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>]>>;
+    operations: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        bindingName: z.ZodString;
+        slug: z.ZodString;
+        order: z.ZodNumber;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+/** `interfaces/<slug>/operations/<slug>/<name>.request.yaml` (the envelope lives in the sibling `.xml`). */
+export declare const requestFileSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"soap">;
+    id: z.ZodString;
+    name: z.ZodString;
+    order: z.ZodNumber;
+    description: z.ZodOptional<z.ZodString>;
+    endpointId: z.ZodOptional<z.ZodString>;
+    endpointUrl: z.ZodOptional<z.ZodString>;
+    soapVersion: z.ZodEnum<{
+        1.1: "1.1";
+        1.2: "1.2";
+    }>;
+    soapAction: z.ZodOptional<z.ZodString>;
+    headers: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$loose>>;
+    attachments: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        contentType: z.ZodString;
+        size: z.ZodNumber;
+        part: z.ZodOptional<z.ZodString>;
+        type: z.ZodEnum<{
+            UNKNOWN: "UNKNOWN";
+            XOP: "XOP";
+            MIME: "MIME";
+            SWAREF: "SWAREF";
+            CONTENT: "CONTENT";
+        }>;
+        contentId: z.ZodString;
+        cached: z.ZodBoolean;
+        source: z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"cache">;
+            sha256: z.ZodString;
+        }, z.core.$loose>, z.ZodObject<{
+            kind: z.ZodLiteral<"path">;
+            path: z.ZodString;
+        }, z.core.$loose>]>;
+    }, z.core.$loose>>;
+    auth: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodEnum<{
+            none: "none";
+            basic: "basic";
+            ntlm: "ntlm";
+        }>;
+        username: z.ZodOptional<z.ZodString>;
+        passwordRef: z.ZodOptional<z.ZodString>;
+        passwordEnv: z.ZodOptional<z.ZodString>;
+        domain: z.ZodOptional<z.ZodString>;
+        workstation: z.ZodOptional<z.ZodString>;
+        preemptive: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"bearer">;
+        tokenRef: z.ZodOptional<z.ZodString>;
+        tokenEnv: z.ZodOptional<z.ZodString>;
+        scheme: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"api-key">;
+        name: z.ZodString;
+        valueRef: z.ZodOptional<z.ZodString>;
+        valueEnv: z.ZodOptional<z.ZodString>;
+        in: z.ZodEnum<{
+            header: "header";
+            query: "query";
+        }>;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"oauth2">;
+        grant: z.ZodEnum<{
+            "client-credentials": "client-credentials";
+            "authorization-code": "authorization-code";
+        }>;
+        tokenUrl: z.ZodString;
+        authorizationUrl: z.ZodOptional<z.ZodString>;
+        clientId: z.ZodString;
+        clientSecretRef: z.ZodOptional<z.ZodString>;
+        clientSecretEnv: z.ZodOptional<z.ZodString>;
+        scopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        audience: z.ZodOptional<z.ZodString>;
+        clientAuth: z.ZodDefault<z.ZodEnum<{
+            basic: "basic";
+            body: "body";
+        }>>;
+        pkce: z.ZodDefault<z.ZodBoolean>;
+        refreshTokenRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>]>>;
+    wsa: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        version: z.ZodOptional<z.ZodEnum<{
+            "2005/08": "2005/08";
+            "2004/08": "2004/08";
+        }>>;
+        mustUnderstand: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            true: "true";
+            false: "false";
+        }>>;
+        action: z.ZodOptional<z.ZodString>;
+        to: z.ZodOptional<z.ZodString>;
+        messageId: z.ZodOptional<z.ZodString>;
+        replyTo: z.ZodOptional<z.ZodString>;
+        from: z.ZodOptional<z.ZodString>;
+        faultTo: z.ZodOptional<z.ZodString>;
+        relatesTo: z.ZodOptional<z.ZodString>;
+        relationshipType: z.ZodOptional<z.ZodString>;
+        addDefaultAction: z.ZodOptional<z.ZodBoolean>;
+        addDefaultTo: z.ZodOptional<z.ZodBoolean>;
+        generateMessageId: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>;
+    wssOutgoingRef: z.ZodOptional<z.ZodString>;
+    wssIncomingRef: z.ZodOptional<z.ZodString>;
+    properties: z.ZodObject<{
+        encoding: z.ZodString;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+        bindAddress: z.ZodOptional<z.ZodString>;
+        followRedirects: z.ZodBoolean;
+        skipSoapAction: z.ZodBoolean;
+        enableMtom: z.ZodBoolean;
+        forceMtom: z.ZodBoolean;
+        inlineResponseAttachments: z.ZodBoolean;
+        expandMtomAttachments: z.ZodBoolean;
+        disableMultiparts: z.ZodBoolean;
+        encodeAttachments: z.ZodBoolean;
+        enableInlineFiles: z.ZodBoolean;
+        removeEmptyContent: z.ZodBoolean;
+        entitizeProperties: z.ZodBoolean;
+        prettyPrint: z.ZodBoolean;
+        stripWhitespaces: z.ZodBoolean;
+        dumpFile: z.ZodOptional<z.ZodString>;
+        maxSizeBytes: z.ZodOptional<z.ZodNumber>;
+        wssPasswordType: z.ZodOptional<z.ZodEnum<{
+            text: "text";
+            digest: "digest";
+        }>>;
+        wssTimeToLive: z.ZodOptional<z.ZodNumber>;
+        sslKeystoreRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+    assertions: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"status">;
+        equals: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodNumber, z.ZodNumber, z.ZodString, z.ZodEnum<{
+            [x: string]: string;
+        }>]>, z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodNumber, z.ZodString, z.ZodEnum<{
+            [x: string]: string;
+        }>]>>]>;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"soap-fault">;
+        expect: z.ZodDefault<z.ZodEnum<{
+            none: "none";
+            present: "present";
+        }>>;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"match">;
+        language: z.ZodEnum<{
+            xpath: "xpath";
+            xquery: "xquery";
+            jsonpath: "jsonpath";
+        }>;
+        expression: z.ZodString;
+        namespaces: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        equals: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        matches: z.ZodOptional<z.ZodString>;
+        exists: z.ZodOptional<z.ZodBoolean>;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"schema">;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"sla">;
+        maxMs: z.ZodNumber;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"callback">;
+        catchUrl: z.ZodString;
+        withinMs: z.ZodDefault<z.ZodNumber>;
+        match: z.ZodDefault<z.ZodObject<{
+            method: z.ZodOptional<z.ZodString>;
+            path: z.ZodOptional<z.ZodString>;
+            pathMatches: z.ZodOptional<z.ZodString>;
+            headers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                equals: z.ZodOptional<z.ZodString>;
+                matches: z.ZodOptional<z.ZodString>;
+                exists: z.ZodOptional<z.ZodBoolean>;
+                name: z.ZodString;
+            }, z.core.$loose>>>;
+            body: z.ZodOptional<z.ZodObject<{
+                equals: z.ZodOptional<z.ZodString>;
+                matches: z.ZodOptional<z.ZodString>;
+                exists: z.ZodOptional<z.ZodBoolean>;
+                language: z.ZodEnum<{
+                    xpath: "xpath";
+                    jsonpath: "jsonpath";
+                }>;
+                path: z.ZodString;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>;
+        expect: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            body: z.ZodOptional<z.ZodObject<{
+                equals: z.ZodOptional<z.ZodString>;
+                matches: z.ZodOptional<z.ZodString>;
+                exists: z.ZodOptional<z.ZodBoolean>;
+                language: z.ZodEnum<{
+                    xpath: "xpath";
+                    jsonpath: "jsonpath";
+                }>;
+                path: z.ZodString;
+            }, z.core.$loose>>;
+            header: z.ZodOptional<z.ZodObject<{
+                equals: z.ZodOptional<z.ZodString>;
+                matches: z.ZodOptional<z.ZodString>;
+                exists: z.ZodOptional<z.ZodBoolean>;
+                name: z.ZodString;
+            }, z.core.$loose>>;
+            signature: z.ZodOptional<z.ZodLiteral<"verified">>;
+        }, z.core.$loose>>>;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], "type">>>;
+    orphaned: z.ZodOptional<z.ZodBoolean>;
+    scripts: z.ZodOptional<z.ZodObject<{
+        pre: z.ZodOptional<z.ZodString>;
+        post: z.ZodOptional<z.ZodString>;
+        api: z.ZodDefault<z.ZodEnum<{
+            wirebench: "wirebench";
+            postman: "postman";
+        }>>;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        secrets: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+/** An interface document as persisted. */
+export type InterfaceFile = z.infer<typeof interfaceFileSchema>;
+/** A request document as persisted (envelope excluded). */
+export type RequestFile = z.infer<typeof requestFileSchema>;