@wirebench/engine 2.2.1 → 3.1.0-rc.1

package/dist/assert/capture-source.js

@@ -0,0 +1,89 @@
+/**
+ * Where a callback assertion reads captures from (callback-assertion spec §2.2). The engine never
+ * talks to a server: a host (the desktop's main process, the CLI) hands a run a `CaptureSource`.
+ * `captureSourceOver` builds one from the three reads of the webhook-capture manage API, so the two
+ * hosts share the paging, the oldest-first order and the decoding, and differ only in how they
+ * authenticate.
+ */
+import { WirebenchError } from '../errors.js';
+import { HOOKS_LIMITS } from '../server-api/hooks.js';
+/** Below every ULID: `after` from here reads a hook's captures from its first. */
+export const FIRST_CAPTURE_CURSOR = '00000000000000000000000000';
+/** A wait never reads more than this many pages of 200 per poll: a flood is not worth following. */
+const MAX_PAGES_PER_POLL = 25;
+function decodedPath(subpath) {
+    const path = subpath === '' ? '/' : subpath;
+    try {
+        return decodeURIComponent(path);
+    }
+    catch {
+        // A sender's malformed escape stays as it arrived: `path` then compares against what was sent.
+        return path;
+    }
+}
+export function captureSummaryView(summary) {
+    const signature = summary.signature ?? null;
+    return {
+        id: summary.id,
+        receivedAt: summary.receivedAt,
+        method: summary.method,
+        path: decodedPath(summary.subpath),
+        signature: signature === null
+            ? null
+            : { verdict: signature.verdict, ...(signature.reason !== undefined ? { reason: signature.reason } : {}) },
+    };
+}
+export function captureDetailView(capture) {
+    return {
+        ...captureSummaryView(capture),
+        headers: capture.headers,
+        bodyText: Buffer.from(capture.body, 'base64').toString('utf8'),
+        truncated: capture.truncated,
+    };
+}
+/** A `CaptureSource` over the manage API. The hook list is read once per source, which is once per run. */
+export function captureSourceOver(reads) {
+    let hooks;
+    return {
+        async resolve(catchUrl) {
+            hooks ??= reads.hooks();
+            let list;
+            try {
+                list = await hooks;
+            }
+            catch (error) {
+                hooks = undefined; // the next assertion asks again
+                throw error;
+            }
+            const wanted = catchUrl.trim().toLowerCase();
+            const found = list.find((hook) => hook.name.trim().toLowerCase() === wanted);
+            return found === undefined ? undefined : { hookId: found.id };
+        },
+        async cursor(hookId) {
+            const [newest] = await reads.captures(hookId, { limit: 1 });
+            return newest?.id ?? null;
+        },
+        async after(hookId, cursor) {
+            const out = [];
+            let from = cursor ?? FIRST_CAPTURE_CURSOR;
+            for (let page = 0; page < MAX_PAGES_PER_POLL; page += 1) {
+                const newestFirst = await reads.captures(hookId, { after: from, limit: HOOKS_LIMITS.maxPageSize });
+                const oldestFirst = [...newestFirst].reverse();
+                out.push(...oldestFirst.map(captureSummaryView));
+                const last = oldestFirst.at(-1);
+                if (last === undefined || newestFirst.length < HOOKS_LIMITS.maxPageSize)
+                    break;
+                from = last.id;
+            }
+            return out;
+        },
+        async detail(hookId, captureId) {
+            return captureDetailView(await reads.capture(hookId, captureId));
+        },
+    };
+}
+/** A source for a host that cannot read captures: every callback assertion errors with `message`. */
+export function unavailableCaptureSource(message) {
+    const refuse = () => Promise.reject(new WirebenchError('callback-source-unavailable', message));
+    return { resolve: refuse, cursor: refuse, after: refuse, detail: refuse };
+}

package/dist/assert/check.d.ts

@@ -0,0 +1,8 @@
+import type { Assertion, AssertionResult, AssertionSubject } from './model.js';
+/**
+ * Checks `assertions` against `subject`, in order. A run's default SLA joins them when the request
+ * has no `sla` of its own. Callback assertions are left out: only a run waits for a callback.
+ */
+export declare function checkRequestAssertions(subject: AssertionSubject, assertions: readonly Assertion[], options?: {
+    readonly defaultSlaMs?: number;
+}): Promise<AssertionResult[]>;

package/dist/assert/check.js

@@ -0,0 +1,18 @@
+/**
+ * A request's own assertions checked against what came back (request-assertions spec §4): the one
+ * check a run and the desktop's editor Send share.
+ */
+import { isCallbackAssertion } from './callback.js';
+import { evaluateAssertions } from './index.js';
+/**
+ * Checks `assertions` against `subject`, in order. A run's default SLA joins them when the request
+ * has no `sla` of its own. Callback assertions are left out: only a run waits for a callback.
+ */
+export async function checkRequestAssertions(subject, assertions, options = {}) {
+    const withDefault = options.defaultSlaMs !== undefined && !assertions.some((a) => a.type === 'sla')
+        ? [...assertions, { type: 'sla', maxMs: options.defaultSlaMs }]
+        : assertions;
+    return [
+        ...(await evaluateAssertions(subject, withDefault.filter((a) => !isCallbackAssertion(a)))),
+    ];
+}

package/dist/assert/header.d.ts

@@ -0,0 +1,5 @@
+import type { AssertionResult, AssertionSubject, HeaderAssertion } from './model.js';
+/** The first value of `name` among `headers`, compared without regard to case. */
+export declare function firstHeaderValue(headers: readonly (readonly [string, string])[] | undefined, name: string): string | undefined;
+/** Checks one response header: that it exists, equals a value, or matches a pattern. */
+export declare function evaluateHeader(subject: AssertionSubject, assertion: HeaderAssertion): Promise<AssertionResult>;

package/dist/assert/header.js

@@ -0,0 +1,48 @@
+import { matchRegexWithTimeout } from '../xpath/evaluate-async.js';
+/** Long enough to read, short enough that a report stays a report. */
+const MAX_ACTUAL_CHARS = 200;
+function truncate(text) {
+    return text.length > MAX_ACTUAL_CHARS ? `${text.slice(0, MAX_ACTUAL_CHARS)}…` : text;
+}
+/** The first value of `name` among `headers`, compared without regard to case. */
+export function firstHeaderValue(headers, name) {
+    const wanted = name.toLowerCase();
+    return headers?.find(([key]) => key.toLowerCase() === wanted)?.[1];
+}
+/** Checks one response header: that it exists, equals a value, or matches a pattern. */
+export async function evaluateHeader(subject, assertion) {
+    const base = { type: 'header', label: assertion.name ?? `header ${assertion.header}` };
+    const actual = firstHeaderValue(subject.headers, assertion.header);
+    if (assertion.exists !== undefined) {
+        const found = actual !== undefined;
+        return found === assertion.exists
+            ? { ...base, outcome: 'passed' }
+            : {
+                ...base,
+                outcome: 'failed',
+                expected: assertion.exists ? 'present' : 'absent',
+                actual: found ? 'present' : 'absent',
+            };
+    }
+    if (actual === undefined) {
+        return {
+            ...base,
+            outcome: 'failed',
+            expected: assertion.matches !== undefined ? `/${assertion.matches}/` : String(assertion.equals),
+            actual: 'absent',
+        };
+    }
+    if (assertion.matches !== undefined) {
+        const matched = await matchRegexWithTimeout(assertion.matches, actual);
+        if (matched.kind === 'error') {
+            return { ...base, outcome: 'errored', message: matched.message };
+        }
+        return matched.matched
+            ? { ...base, outcome: 'passed' }
+            : { ...base, outcome: 'failed', expected: `/${assertion.matches}/`, actual: truncate(actual) };
+    }
+    const expected = String(assertion.equals);
+    return actual === expected
+        ? { ...base, outcome: 'passed' }
+        : { ...base, outcome: 'failed', expected, actual: truncate(actual) };
+}

package/dist/assert/index.d.ts

@@ -1,4 +1,4 @@
-import type { Assertion, AssertionResult, AssertionSubject } from './model.js';
+import type { AssertionResult, AssertionSubject, StepAssertion } from './model.js';
 /** Evaluates every assertion, in order. One failing or erroring never stops the rest. */
-export declare function evaluateAssertions(subject: AssertionSubject, assertions: readonly Assertion[]): Promise<AssertionResult[]>;
+export declare function evaluateAssertions(subject: AssertionSubject, assertions: readonly StepAssertion[]): Promise<AssertionResult[]>;
 export type * from './model.js';

package/dist/assert/index.js

@@ -1,4 +1,6 @@
+import { callbackLabel } from './model.js';
 import { evaluateContract } from './contract.js';
+import { evaluateHeader } from './header.js';
 import { evaluateMatch } from './match.js';
 import { evaluateSla } from './sla.js';
 import { evaluateSoapFault } from './soap-fault.js';
@@ -15,6 +17,16 @@ function evaluateOne(subject, assertion) {
             return evaluateMatch(subject, assertion);
         case 'schema':
             return evaluateContract(subject, assertion);
+        case 'header':
+            return evaluateHeader(subject, assertion);
+        case 'callback':
+            // Waiting needs the send's moment and a capture source: only a run has them (`assert/callback.ts`).
+            return {
+                type: 'callback',
+                label: callbackLabel(assertion),
+                outcome: 'errored',
+                message: 'a callback assertion is checked by a run, after its send',
+            };
     }
 }
 /** Evaluates every assertion, in order. One failing or erroring never stops the rest. */

package/dist/assert/match.d.ts

@@ -1,3 +1,9 @@
+import type { QueryResult } from '../xpath/evaluate.js';
 import type { AssertionResult, AssertionSubject, MatchAssertion } from './model.js';
+/**
+ * The result as one string: the first item's text, which is what a scalar comparison means. Shared
+ * with sequence transfers, which lift a value the same way a `match` reads one.
+ */
+export declare function firstText(result: QueryResult): string | undefined;
 /** Evaluates an XPath/XQuery/JSONPath expression against the response and checks its result. */
 export declare function evaluateMatch(subject: AssertionSubject, assertion: MatchAssertion): Promise<AssertionResult>;

package/dist/assert/match.js

@@ -1,11 +1,14 @@
-import { evaluateWithTimeout } from '../xpath/evaluate-async.js';
+import { evaluateWithTimeout, matchRegexWithTimeout } from '../xpath/evaluate-async.js';
 /** Long enough to read, short enough that a report stays a report. */
 const MAX_ACTUAL_CHARS = 200;
 function truncate(text) {
     return text.length > MAX_ACTUAL_CHARS ? `${text.slice(0, MAX_ACTUAL_CHARS)}…` : text;
 }
-/** The result as one string: the first item's text, which is what a scalar comparison means. */
-function firstText(result) {
+/**
+ * The result as one string: the first item's text, which is what a scalar comparison means. Shared
+ * with sequence transfers, which lift a value the same way a `match` reads one.
+ */
+export function firstText(result) {
     if (result.kind === 'nodes') {
         return result.items[0]?.text;
     }
@@ -47,7 +50,13 @@ export async function evaluateMatch(subject, assertion) {
     }
     const actual = firstText(result) ?? '';
     if (assertion.matches !== undefined) {
-        return new RegExp(assertion.matches).test(actual)
+        // On the worker, never here: the pattern comes from a file, and a backtracking one would block
+        // this thread (the desktop's main process, for a sequence) for as long as it runs.
+        const matched = await matchRegexWithTimeout(assertion.matches, actual);
+        if (matched.kind === 'error') {
+            return { ...base, outcome: 'errored', message: matched.message };
+        }
+        return matched.matched
             ? { ...base, outcome: 'passed' }
             : { ...base, outcome: 'failed', expected: `/${assertion.matches}/`, actual: truncate(actual) };
     }

package/dist/assert/model.d.ts

@@ -41,11 +41,100 @@ export interface SlaAssertion {
     readonly maxMs: number;
     readonly name?: string;
 }
+/** Bounds on a callback assertion (spec §2.1) and the engine's poll interval (§2.3). */
+export declare const CALLBACK_LIMITS: Readonly<{
+    defaultWithinMs: 30000;
+    minWithinMs: 1000;
+    maxWithinMs: 300000;
+    /** How often a waiting callback asks for new captures. A constant; tests inject their own. */
+    pollIntervalMs: 1000;
+    /** A catch URL's name, as the server bounds it (`HOOKS_LIMITS.maxNameLength`). */
+    maxCatchUrlLength: 100;
+    maxHeaderChecks: 20;
+    maxExpectChecks: 20;
+}>;
+/** One header of a capture: its name ignores case; exactly one of `equals`, `matches`, `exists`. */
+export interface CallbackHeaderCheck {
+    readonly name: string;
+    readonly equals?: string;
+    readonly matches?: string;
+    readonly exists?: boolean;
+}
+/** An expression over a capture's body text; exactly one of `equals`, `matches`, `exists`. */
+export interface CallbackBodyCheck {
+    readonly language: 'jsonpath' | 'xpath';
+    readonly path: string;
+    readonly equals?: string;
+    readonly matches?: string;
+    readonly exists?: boolean;
+}
+/** What picks the capture (spec §2.3): every part given must hold. */
+export interface CallbackMatch {
+    /** Compared without regard to case. */
+    readonly method?: string;
+    /** Exact, against the decoded subpath (leading `/`). At most one of `path` and `pathMatches`. */
+    readonly path?: string;
+    readonly pathMatches?: string;
+    readonly headers?: readonly CallbackHeaderCheck[];
+    readonly body?: CallbackBodyCheck;
+}
+/** What is checked on the matched capture; every check is reported. */
+export type CallbackCheck = {
+    readonly body: CallbackBodyCheck;
+} | {
+    readonly header: CallbackHeaderCheck;
+} | {
+    readonly signature: 'verified';
+};
+/**
+ * Waits after the send for the first capture at `catchUrl` that fits `match`, then checks it with
+ * `expect` (spec §2). Only a run evaluates it: a desktop Send and `evaluateAssertions` alone cannot.
+ */
+export interface CallbackAssertion {
+    readonly type: 'callback';
+    /** The catch URL's name in the server workspace (unique there, case-insensitive). */
+    readonly catchUrl: string;
+    /** How long to wait after the send finished: {@link CALLBACK_LIMITS}. */
+    readonly withinMs: number;
+    readonly match: CallbackMatch;
+    readonly expect: readonly CallbackCheck[];
+    readonly name?: string;
+}
 /** The union of every declarative check a request file may carry under `assertions:`. */
-export type Assertion = StatusAssertion | SoapFaultAssertion | MatchAssertion | SchemaAssertion | SlaAssertion;
+export type Assertion = StatusAssertion | SoapFaultAssertion | MatchAssertion | SchemaAssertion | SlaAssertion | CallbackAssertion;
+/** The label of a callback assertion's result: its `name`, else the catch URL it waits on. */
+export declare function callbackLabel(assertion: CallbackAssertion): string;
+/**
+ * Checks a response header (gRPC: response metadata, then trailers). Name matching ignores case; the
+ * first value found is compared.
+ *
+ * A sequence step may carry it; a request file may not (it reads the response, which a request file's own
+ * assertions already cover by `match`).
+ */
+export interface HeaderAssertion {
+    readonly type: 'header';
+    readonly header: string;
+    readonly equals?: string;
+    readonly matches?: string;
+    readonly exists?: boolean;
+    readonly name?: string;
+}
+/** What a sequence step may assert: the request catalogue plus {@link HeaderAssertion}. */
+export type StepAssertion = Assertion | HeaderAssertion;
+/**
+ * A protocol's status codes by name, for a subject whose statuses have names (gRPC's `NOT_FOUND`).
+ *
+ * @internal Exported for the engine's own hosts; not yet a plugin API (ADR-0017).
+ */
+export interface StatusNames {
+    readonly byName: ReadonlyMap<string, number>;
+    /** The name of a code, including one the protocol does not define. */
+    nameOf(code: number): string;
+}
 /** What an assertion looks at — protocol-neutral, built by the runner from an exchange. */
 export interface AssertionSubject {
-    readonly protocol: 'soap' | 'rest';
+    /** The `kind` of the protocol module that built the subject. */
+    readonly protocol: string;
     readonly status: number;
     readonly durationMs: number;
     /** Decoded response text: the (possibly decrypted) envelope for SOAP, the body text for REST. */
@@ -60,14 +149,32 @@ export interface AssertionSubject {
     readonly validateContract?: () => Promise<readonly {
         readonly message: string;
     }[]>;
+    /**
+     * The response headers in wire order (gRPC: metadata, then trailers), for `header` assertions and
+     * sequence transfers. Absent means none were recorded.
+     */
+    readonly headers?: readonly (readonly [string, string])[];
+    /**
+     * Set when the protocol's statuses have names. A status assertion then accepts a name and
+     * compares codes exactly; without it the HTTP rules apply (a number, or an `Nxx` class).
+     *
+     * @internal Exported for the engine's own hosts; not yet a plugin API (ADR-0017).
+     */
+    readonly statusNames?: StatusNames;
 }
 /** The outcome of evaluating one assertion against a subject. */
 export interface AssertionResult {
-    readonly type: Assertion['type'];
+    /** `script` for a test a post-response script recorded (#63); `baseline` for the runner's `--baseline` (#36). */
+    readonly type: StepAssertion['type'] | 'script' | 'baseline';
     readonly label: string;
     readonly outcome: 'passed' | 'failed' | 'errored';
     readonly expected?: string;
     readonly actual?: string;
     /** Why it errored: an expression that does not compile, a timeout, no contract to validate against. */
     readonly message?: string;
+    /** A callback assertion's matched capture, for a link to it (spec §5). */
+    readonly capture?: {
+        readonly hookId: string;
+        readonly captureId: string;
+    };
 }

package/dist/assert/model.js

@@ -5,4 +5,19 @@
  * for. Every member is evaluated — a failure does not stop the rest — so a report shows everything
  * that is wrong with a response, not just the first thing.
  */
-export {};
+/** Bounds on a callback assertion (spec §2.1) and the engine's poll interval (§2.3). */
+export const CALLBACK_LIMITS = Object.freeze({
+    defaultWithinMs: 30_000,
+    minWithinMs: 1_000,
+    maxWithinMs: 300_000,
+    /** How often a waiting callback asks for new captures. A constant; tests inject their own. */
+    pollIntervalMs: 1_000,
+    /** A catch URL's name, as the server bounds it (`HOOKS_LIMITS.maxNameLength`). */
+    maxCatchUrlLength: 100,
+    maxHeaderChecks: 20,
+    maxExpectChecks: 20,
+});
+/** The label of a callback assertion's result: its `name`, else the catch URL it waits on. */
+export function callbackLabel(assertion) {
+    return assertion.name ?? `callback ${assertion.catchUrl}`;
+}

package/dist/assert/schema.d.ts

@@ -1,8 +1,65 @@
 import { z } from 'zod';
+import type { CallbackAssertion } from './model.js';
+/** `type: callback` (spec §2.1): the same shape on a request file and on a sequence step. */
+export declare const callbackAssertionSchema: 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>;
+/**
+ * Only the fields a callback assertion defines, at every level. `looseObject` keeps unknown keys on
+ * the parsed value; dropping them here keeps them from being written back.
+ */
+export declare function toCallbackAssertion(raw: CallbackAssertion | z.output<typeof callbackAssertionSchema>): CallbackAssertion;
 /** The `assertions:` list of a request file. `looseObject` like every project schema; see `project/schema.ts`. */
 export declare const assertionsSchema: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"status">;
-    equals: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>]>;
+    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">;
@@ -31,4 +88,140 @@ export declare const assertionsSchema: z.ZodArray<z.ZodDiscriminatedUnion<[z.Zod
     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">>;
+/**
+ * The `assertions:` list of a sequence step: the request catalogue plus `header`.
+ */
+export declare const stepAssertionsSchema: 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<"header">;
+    header: z.ZodString;
+    equals: z.ZodOptional<z.ZodString>;
+    matches: z.ZodOptional<z.ZodString>;
+    exists: z.ZodOptional<z.ZodBoolean>;
+    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">>;