@wirebench/engine 2.2.0 → 3.1.0-rc.1

package/dist/{rest/auth.d.ts → http/auth/apply-auth.d.ts}

@@ -1,5 +1,5 @@
 /**
- * Working out which credentials a REST request uses, and turning them into what goes on the wire.
+ * Working out which credentials a request uses, and turning them into what goes on the wire.
  *
  * Two halves, both pure. {@link resolveAuthChain} walks the inheritance chain — request, then each
  * folder outwards, then the API — and answers with the first configuration that is not `inherit`.
@@ -9,9 +9,9 @@
  * Basic and NTLM are deliberately *not* applied here: they may need a challenge round trip, which
  * is the transport's job (`http/auth/*`), and this module never touches the network.
  */
-import type { AuthConfig } from '../project/model.js';
-import type { SendAuth } from '../types.js';
-import type { KeyValueEntry } from './model.js';
+import type { AuthConfig } from '../../project/model.js';
+import type { SendAuth } from './send-auth.js';
+import type { KeyValueEntry } from '../entries.js';
 /**
  * The credentials that actually apply, given a request's own configuration followed by its
  * folders from the inside out and finally its API's.

package/dist/{rest/auth.js → http/auth/apply-auth.js}

@@ -1,5 +1,5 @@
 /**
- * Working out which credentials a REST request uses, and turning them into what goes on the wire.
+ * Working out which credentials a request uses, and turning them into what goes on the wire.
  *
  * Two halves, both pure. {@link resolveAuthChain} walks the inheritance chain — request, then each
  * folder outwards, then the API — and answers with the first configuration that is not `inherit`.

package/dist/http/auth/apply.d.ts

@@ -10,7 +10,7 @@
  */
 import type { Dispatcher } from 'undici';
 import type { HttpExchange, HttpRequest } from '../types.js';
-import type { AuthSummary, SendAuth } from '../../types.js';
+import type { AuthSummary, SendAuth } from './send-auth.js';
 /** Options for {@link sendWithAuth}: the same hooks `sendHttp` takes, for tests. */
 export interface SendWithAuthOptions {
     readonly dispatcher?: Dispatcher;

package/dist/{rest → http/auth}/oauth2.d.ts

@@ -10,8 +10,8 @@
  * No access token is ever written to a project file or returned to a renderer by this module; it
  * hands back a {@link TokenSet} and the host decides where it lives (ADR-0004).
  */
-import type { OAuth2Auth } from '../project/model.js';
-import type { HttpRequest } from '../http/types.js';
+import type { OAuth2Auth } from '../../project/model.js';
+import type { HttpRequest } from '../types.js';
 /** The credential values the host resolved for one OAuth2 configuration. */
 export interface OAuth2Secrets {
     /** The client secret, when the configuration references one. */

package/dist/{rest → http/auth}/oauth2.js

@@ -11,7 +11,7 @@
  * hands back a {@link TokenSet} and the host decides where it lives (ADR-0004).
  */
 import { createHash, randomBytes } from 'node:crypto';
-import { WirebenchError } from '../errors.js';
+import { WirebenchError } from '../../errors.js';
 /** Base64url without padding, the encoding every OAuth2 extension uses. */
 function base64url(bytes) {
     return Buffer.from(bytes).toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');

package/dist/http/auth/send-auth.d.ts

@@ -0,0 +1,57 @@
+/**
+ * The credentials of one send, and what authentication did with them.
+ *
+ * In `http/auth/` because every protocol's send takes a {@link SendAuth} and a protocol folder
+ * imports core and itself, never another protocol (protocol modules spec §7.2).
+ */
+/**
+ * Credentials for one send, already resolved to plaintext: the desktop app looks a
+ * `passwordRef` up in its secret store before calling the engine, so the engine never
+ * sees a secret reference (and never persists or logs the password).
+ */
+export type SendAuth = {
+    readonly type: 'basic';
+    readonly username: string;
+    readonly password: string;
+    /** Send the `Authorization` header on the first attempt instead of waiting for a 401. */
+    readonly preemptive: boolean;
+} | {
+    readonly type: 'ntlm';
+    readonly username: string;
+    readonly password: string;
+    readonly domain?: string;
+    readonly workstation?: string;
+}
+/** A token in an `Authorization` header. `scheme` defaults to `Bearer`. */
+ | {
+    readonly type: 'bearer';
+    readonly token: string;
+    readonly scheme?: string;
+}
+/** A key in one header or one query parameter. */
+ | {
+    readonly type: 'api-key';
+    readonly name: string;
+    readonly value: string;
+    readonly in: 'header' | 'query';
+}
+/**
+ * An OAuth2 access token the host already obtained. The engine never runs a grant during a send:
+ * the token is fetched (and cached, and refreshed) by the host, so a send is one exchange and
+ * the browser is never opened behind it. On the wire it is a Bearer token.
+ */
+ | {
+    readonly type: 'oauth2';
+    readonly accessToken: string;
+};
+/** What authentication actually did during one send, for the UI to explain the exchange. */
+export interface AuthSummary {
+    readonly scheme: SendAuth['type'];
+    /** True when the server answered the first attempt with a 401 challenge. */
+    readonly challenged: boolean;
+    /**
+     * How many HTTP attempts the send made: 1 preemptive/unchallenged, 2 after a Basic
+     * challenge, 3 for a full NTLM handshake (bare, Type 1, Type 3).
+     */
+    readonly attempts: 1 | 2 | 3;
+}

package/dist/http/auth/send-auth.js

@@ -0,0 +1,7 @@
+/**
+ * The credentials of one send, and what authentication did with them.
+ *
+ * In `http/auth/` because every protocol's send takes a {@link SendAuth} and a protocol folder
+ * imports core and itself, never another protocol (protocol modules spec §7.2).
+ */
+export {};

package/dist/http/client.js

@@ -1,5 +1,6 @@
 import { Agent, ProxyAgent, request as undiciRequest } from 'undici';
-import { decompressBody } from './decompress.js';
+import { pipeline } from 'node:stream';
+import { createDecompressStream, decompressBody } from './decompress.js';
 import { failedRequestFor, withFailedRequest } from './failed-request.js';
 import { invalidUrlError, toHttpError, tooManyRedirectsError } from './errors.js';
 import { buildRawRequest, buildRawResponse } from './raw-capture.js';
@@ -155,6 +156,59 @@ function scopeHeadersToOrigin(headers, fromUrl, toUrl) {
     }
     return scoped;
 }
+/**
+ * Applies a request's {@link OriginCredentials} to the next hop of a redirect: removed from a hop to
+ * any origin but the request's own, applied again on a hop back to it.
+ *
+ * A query key is stripped by name and value rather than by name alone, so a parameter the target
+ * uses for its own purposes survives; only the key's exact value is a secret. The URL is only
+ * re-serialised when something changes, so a `Location` otherwise reaches the wire as the server
+ * wrote it.
+ */
+function scopeCredentialsToOrigin(credentials, original, headers, toUrl) {
+    const names = new Set((credentials.headers ?? []).map((name) => name.toLowerCase()));
+    const sameOrigin = originOf(toUrl) === originOf(original.url);
+    const scoped = {};
+    for (const [name, value] of Object.entries(headers)) {
+        if (!names.has(name.toLowerCase()))
+            scoped[name] = value;
+    }
+    if (sameOrigin) {
+        for (const [name, value] of Object.entries(original.headers)) {
+            if (names.has(name.toLowerCase()))
+                scoped[name] = value;
+        }
+    }
+    const url = new URL(toUrl);
+    let changed = false;
+    for (const { name, value } of credentials.query ?? []) {
+        const present = url.searchParams.getAll(name).includes(value);
+        if (sameOrigin && !present) {
+            url.searchParams.append(name, value);
+            changed = true;
+        }
+        else if (!sameOrigin && present) {
+            url.searchParams.delete(name, value);
+            changed = true;
+        }
+    }
+    return { headers: scoped, url: changed ? url : toUrl };
+}
+/** `headers` with its `Cookie` header replaced by what `hook` sends to `url`, given the hand-set one. */
+function withJarCookies(headers, hook, url) {
+    let handSet;
+    const rest = {};
+    for (const [name, value] of Object.entries(headers)) {
+        if (name.toLowerCase() === 'cookie') {
+            handSet = value;
+        }
+        else {
+            rest[name] = value;
+        }
+    }
+    const cookie = hook.header(url.toString(), handSet);
+    return cookie === undefined ? rest : { ...rest, Cookie: cookie };
+}
 /** Joins undici's raw header shape (string | string[] per name) into our lower-cased map. */
 function joinHeaders(raw) {
     const headers = {};
@@ -228,6 +282,31 @@ async function drainBody(body) {
         void chunk; // discard; just drives the stream to completion
     }
 }
+/**
+ * Forwards an accepted stream's body to the sink until it ends, decoding it on the way when asked.
+ * Never throws: how the stream ended is the result. With the deadline cleared, the only abort left
+ * is the caller's own, so an abort reads as the client ending it and anything else as an error.
+ */
+async function pumpStream(body, contentEncoding, decompress, sink, signal) {
+    const decoder = decompress ? createDecompressStream(contentEncoding) : undefined;
+    const source = decoder === undefined ? body : pipeline(body, decoder, () => undefined);
+    try {
+        for await (const chunk of source) {
+            sink.onChunk(chunk);
+        }
+        return { by: 'server' };
+    }
+    catch (err) {
+        // Only the caller's signal can abort here: the deadline timer is cleared before streaming starts.
+        if (signal?.aborted === true)
+            return { by: 'client' };
+        return { by: 'error', error: err instanceof Error ? err.message : String(err) };
+    }
+    finally {
+        body.destroy();
+        decoder?.destroy();
+    }
+}
 /**
  * Sends one HTTP request and returns the full {@link HttpExchange}, including
  * reconstructed raw wire bytes and best-effort timings. Redirects (301/302/
@@ -275,13 +354,19 @@ export async function sendHttp(req, options) {
         let currentMethod = req.method;
         let currentBody = req.body;
         let currentHeaders = { ...req.headers };
+        // What the last attempt sent: with a cookie hook, its `Cookie` header is the jar's.
+        let sentHeaders = req.headers;
         let result;
         for (let attempt = 0; attempt <= maxRedirects; attempt++) {
             // Tells the tracker which origin the TLS events it is about to see belong to.
             tracker.setOrigin(currentUrl.origin);
-            const finalHeaders = buildFinalHeaders({ ...req, headers: currentHeaders, method: currentMethod }, currentUrl, currentBody);
+            // The jar is matched afresh for every hop's URL (cookie jar spec §1.4). `currentHeaders` holds
+            // only the hand-set `Cookie`, which a cross-origin hop has already dropped.
+            const attemptHeaders = req.cookies === undefined ? currentHeaders : withJarCookies(currentHeaders, req.cookies, currentUrl);
+            sentHeaders = attemptHeaders;
+            const finalHeaders = buildFinalHeaders({ ...req, headers: attemptHeaders, method: currentMethod }, currentUrl, currentBody);
             lastAttempt = failedRequestFor(currentUrl.toString(), currentMethod, finalHeaders, currentBody);
-            const rawRequest = buildRawRequest({ ...req, url: currentUrl.toString(), method: currentMethod, headers: currentHeaders }, finalHeaders, currentBody);
+            const rawRequest = buildRawRequest({ ...req, url: currentUrl.toString(), method: currentMethod, headers: attemptHeaders }, finalHeaders, currentBody);
             let response;
             try {
                 // Wraps the call itself (not its result) so the tracker can capture the exact
@@ -290,12 +375,14 @@ export async function sendHttp(req, options) {
                 // promise — see `TimingTracker.captureRequestFor`.
                 response = await tracker.captureRequestFor(() => undiciRequest(currentUrl, {
                     method: currentMethod,
-                    headers: currentHeaders,
+                    headers: attemptHeaders,
                     ...(currentBody !== undefined ? { body: currentBody } : {}),
                     dispatcher,
                     signal: combinedSignal ?? null,
                     headersTimeout: req.timeoutMs,
-                    bodyTimeout: req.timeoutMs,
+                    // An accepted stream may sit idle between events for as long as the server likes; a
+                    // buffered response stays bounded by the overall deadline, always the tighter limit.
+                    bodyTimeout: req.stream !== undefined ? 0 : req.timeoutMs,
                 }));
             }
             catch (err) {
@@ -308,6 +395,8 @@ export async function sendHttp(req, options) {
             }
             tracker.markHeaders();
             const { headers, rawHeaders } = joinHeaders(response.headers);
+            // Every hop's Set-Cookie is stored against that hop's URL, before a redirect is followed.
+            req.cookies?.received(currentUrl.toString(), rawHeaders);
             const isRedirect = req.followRedirects && REDIRECT_STATUSES.has(response.statusCode) && headers['location'] !== undefined;
             if (isRedirect) {
                 if (attempt === maxRedirects) {
@@ -335,10 +424,58 @@ export async function sendHttp(req, options) {
                 // Drop credential headers (Authorization/Proxy-Authorization/Cookie)
                 // when the redirect crosses to a different origin.
                 currentHeaders = scopeHeadersToOrigin(currentHeaders, currentUrl, nextUrl);
-                currentUrl = nextUrl;
+                if (req.originCredentials === undefined) {
+                    currentUrl = nextUrl;
+                }
+                else {
+                    // The caller's own credentials go to the request's origin only, on every hop.
+                    const scoped = scopeCredentialsToOrigin(req.originCredentials, { url: parsedUrl, headers: req.headers }, currentHeaders, nextUrl);
+                    currentHeaders = scoped.headers;
+                    currentUrl = scoped.url;
+                }
                 continue;
             }
-            const { data: rawBodyRaw, truncated } = await readBody(response.body, req.maxSizeBytes);
+            let sink;
+            try {
+                sink = req.stream?.accept(response.statusCode, headers);
+            }
+            catch (err) {
+                // The body is never read now, so release its connection rather than leave it checked out.
+                response.body.destroy();
+                throw err;
+            }
+            if (sink !== undefined) {
+                // From here the stream runs until the server, the caller, or the network ends it.
+                clearTimeout(timer);
+                const streamEnd = await pumpStream(response.body, headers['content-encoding'], req.decompress ?? true, sink, req.signal);
+                result = {
+                    status: response.statusCode,
+                    headers,
+                    rawHeaders,
+                    rawBody: new Uint8Array(),
+                    body: new Uint8Array(),
+                    truncated: false,
+                    rawRequest,
+                    finalUrl: currentUrl.toString(),
+                    finalMethod: currentMethod,
+                    streamEnd,
+                };
+                break;
+            }
+            let read;
+            try {
+                read = await readBody(response.body, req.maxSizeBytes);
+            }
+            catch (err) {
+                // A body the deadline or the caller cuts short fails as the request would have.
+                throw toHttpError(err, {
+                    userAborted: req.signal?.aborted === true,
+                    deadlineHit: deadlineController.signal.aborted,
+                    hadProxy: req.proxy !== undefined,
+                    host: currentUrl.host,
+                });
+            }
+            const { data: rawBodyRaw, truncated } = read;
             const decompress = req.decompress ?? true;
             let body = rawBodyRaw;
             let decodeError;
@@ -374,7 +511,11 @@ export async function sendHttp(req, options) {
         const rawResponse = buildRawResponse(result.status, statusText(result.status), result.rawHeaders, result.rawBody, httpVersion);
         const timings = tracker.finish();
         return {
-            request: { url: result.finalUrl, method: result.finalMethod, headers: req.headers },
+            request: {
+                url: result.finalUrl,
+                method: result.finalMethod,
+                headers: req.cookies === undefined ? req.headers : sentHeaders,
+            },
             status: result.status,
             statusText: statusText(result.status),
             headers: result.headers,
@@ -389,6 +530,7 @@ export async function sendHttp(req, options) {
             rawResponse,
             redirects,
             ...(tlsInfo !== undefined ? { tls: tlsInfo } : {}),
+            ...(result.streamEnd !== undefined ? { streamEnd: result.streamEnd } : {}),
         };
     }
     catch (err) {

package/dist/http/cookies.d.ts

@@ -0,0 +1,79 @@
+/**
+ * The cookies a response sets: what one is, and how every `Set-Cookie` header is read.
+ *
+ * In `http/` because a sequence's transfers read a response's cookies whatever protocol sent the
+ * request, and core imports no protocol folder (protocol modules spec §7.2). `rest/response.ts`
+ * re-exports both names. The jar's types live here for the same reason; the jar itself is
+ * `rest/cookie-jar.ts`.
+ */
+/** One cookie a response set, with the attributes it declared. */
+export interface Cookie {
+    readonly name: string;
+    readonly value: string;
+    readonly domain?: string;
+    readonly path?: string;
+    /** As declared, in ISO form when it could be parsed; absent for a session cookie. */
+    readonly expires?: string;
+    readonly maxAge?: number;
+    readonly secure?: boolean;
+    readonly httpOnly?: boolean;
+    readonly sameSite?: 'Strict' | 'Lax' | 'None';
+    /** Set when the header could not be parsed as a cookie; `name` then holds the whole line. */
+    readonly malformed?: boolean;
+}
+/**
+ * One cookie the jar holds (cookie jar spec §1.1). Its identity is `(name, domain, path)`; the
+ * response-side {@link Cookie} becomes one only when the jar stores it, because only then is the
+ * request URL known.
+ */
+export interface StoredCookie {
+    readonly name: string;
+    readonly value: string;
+    /** The Domain attribute (no leading dot), or the request host for a host-only cookie. */
+    readonly domain: string;
+    /** True when the response gave no Domain: the cookie goes back to that exact host only. */
+    readonly hostOnly: boolean;
+    /** The Path attribute, or the default path of the URL that set it (RFC 6265 §5.1.4). */
+    readonly path: string;
+    /** Absolute expiry in epoch ms, from Max-Age first and then Expires; absent for a session cookie. */
+    readonly expiresAt?: number;
+    readonly secure: boolean;
+    readonly httpOnly: boolean;
+    readonly sameSite?: 'Strict' | 'Lax' | 'None';
+    /** Epoch ms when first stored; kept when a later response replaces the value (§5.3 step 11). */
+    readonly createdAt: number;
+}
+/** What names one stored cookie. */
+export interface CookieKey {
+    readonly name: string;
+    readonly domain: string;
+    readonly path: string;
+}
+/** Why the jar did not store a cookie a response set. */
+export type CookieRejection = 'deleted' | 'domain-mismatch' | 'domain-not-allowed' | 'secure-over-http' | 'too-large' | 'malformed';
+/** The jar's verdict on one cookie a response set. */
+export type CookieVerdict = {
+    readonly stored: true;
+} | {
+    readonly stored: false;
+    readonly reason: CookieRejection;
+};
+/**
+ * What a host lends a send for its cookies (cookie jar spec §1.4): every REST send reports what each
+ * response set, redirect hops included, and a request whose `sendCookies` is on carries what the jar
+ * matches for each hop's URL. Here, in core, so `run/host.ts` can name it without importing `rest/`.
+ */
+export interface CookieJarHost {
+    /** The jar cookies a request to `url` would carry, in RFC 6265 §5.4 order. */
+    cookiesFor(url: string): readonly StoredCookie[];
+    /** Stores what a response to `url` set; one verdict per cookie, in order. */
+    remember(url: string, cookies: readonly Cookie[]): readonly CookieVerdict[];
+}
+/**
+ * Parses every `Set-Cookie` header of a response (RFC 6265 §5.2).
+ *
+ * `rawHeaders` rather than the merged map, because several cookies arrive as several headers and
+ * joining them with `, ` — which is what merging does — makes them unparseable. A line that is not
+ * a cookie at all is kept as `malformed` instead of dropped: it is evidence about the server.
+ */
+export declare function parseSetCookie(rawHeaders: readonly (readonly [string, string])[]): Cookie[];

package/dist/http/cookies.js

@@ -0,0 +1,81 @@
+/**
+ * The cookies a response sets: what one is, and how every `Set-Cookie` header is read.
+ *
+ * In `http/` because a sequence's transfers read a response's cookies whatever protocol sent the
+ * request, and core imports no protocol folder (protocol modules spec §7.2). `rest/response.ts`
+ * re-exports both names. The jar's types live here for the same reason; the jar itself is
+ * `rest/cookie-jar.ts`.
+ */
+/**
+ * Parses every `Set-Cookie` header of a response (RFC 6265 §5.2).
+ *
+ * `rawHeaders` rather than the merged map, because several cookies arrive as several headers and
+ * joining them with `, ` — which is what merging does — makes them unparseable. A line that is not
+ * a cookie at all is kept as `malformed` instead of dropped: it is evidence about the server.
+ */
+export function parseSetCookie(rawHeaders) {
+    const cookies = [];
+    for (const [name, value] of rawHeaders) {
+        if (name.toLowerCase() !== 'set-cookie') {
+            continue;
+        }
+        cookies.push(parseOne(value));
+    }
+    return cookies;
+}
+function parseOne(header) {
+    const parts = header.split(';');
+    const pair = parts[0] ?? '';
+    const equals = pair.indexOf('=');
+    if (equals <= 0) {
+        return { name: header.trim(), value: '', malformed: true };
+    }
+    const cookie = {
+        name: pair.slice(0, equals).trim(),
+        value: unquote(pair.slice(equals + 1).trim()),
+    };
+    for (const attribute of parts.slice(1)) {
+        const split = attribute.indexOf('=');
+        const key = (split === -1 ? attribute : attribute.slice(0, split)).trim().toLowerCase();
+        const attributeValue = split === -1 ? '' : attribute.slice(split + 1).trim();
+        switch (key) {
+            case 'domain':
+                // A leading dot is legal and means the same as its absence (RFC 6265 §5.2.3).
+                cookie.domain = attributeValue.replace(/^\./, '').toLowerCase();
+                break;
+            case 'path':
+                cookie.path = attributeValue;
+                break;
+            case 'expires': {
+                const date = new Date(attributeValue);
+                cookie.expires = Number.isNaN(date.getTime()) ? attributeValue : date.toISOString();
+                break;
+            }
+            case 'max-age': {
+                const seconds = Number.parseInt(attributeValue, 10);
+                if (!Number.isNaN(seconds)) {
+                    cookie.maxAge = seconds;
+                }
+                break;
+            }
+            case 'secure':
+                cookie.secure = true;
+                break;
+            case 'httponly':
+                cookie.httpOnly = true;
+                break;
+            case 'samesite': {
+                const normalized = attributeValue.toLowerCase();
+                cookie.sameSite = normalized === 'strict' ? 'Strict' : normalized === 'none' ? 'None' : 'Lax';
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    return cookie;
+}
+/** Strips one layer of double quotes from a cookie value, which some servers add. */
+function unquote(value) {
+    return value.length > 1 && value.startsWith('"') && value.endsWith('"') ? value.slice(1, -1) : value;
+}

package/dist/http/curl.d.ts

@@ -4,10 +4,9 @@
  *
  * {@link toCurl} describes a request in `curl`'s own terms — a method, a URL, headers and one of the
  * body shapes `curl` has a flag for — and knows nothing about SOAP or REST. Each protocol builds that
- * description from its own send input ({@link soapToCurl} here, `restToCurl` in `rest/curl.ts`), so the
+ * description from its own send input (`soapToCurl` in `soap/curl.ts`, `restToCurl` in `rest/curl.ts`), so the
  * quoting, the line continuations and the two shells have one implementation rather than two.
  */
-import type { SoapSendInput } from '../types.js';
 /** One header of an exported command, in the order the user wrote it. */
 export interface CurlHeader {
     readonly name: string;
@@ -65,8 +64,10 @@ export interface CurlCommand {
     /** `-L`, with `--max-redirs` when a limit is set. */
     readonly followRedirects?: boolean;
     readonly maxRedirects?: number;
+    /** `-N`/`--no-buffer`: don't hold output back waiting for a full buffer, for a streamed response. */
+    readonly noBuffer?: boolean;
 }
-/** Options for {@link toCurl} and {@link soapToCurl}. */
+/** Options for {@link toCurl} and for `soapToCurl` in `soap/curl.ts`. */
 export interface ToCurlOptions {
     /** Target shell for line continuations and quoting. Default 'posix'. */
     readonly shell?: 'posix' | 'powershell';
@@ -81,14 +82,3 @@ export declare function quoteForShell(value: string, shell: 'posix' | 'powershel
  * carries all of it unchanged — which is also what {@link fromCurl} reads back.
  */
 export declare function toCurl(command: CurlCommand, options?: ToCurlOptions): string;
-/** 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;