@wirebench/engine 2.2.0 → 3.1.0-rc.1

package/dist/send-options.d.ts

@@ -1,141 +0,0 @@
-/**
- * Turns a saved request plus the settings around it into the {@link SoapSendInput} the
- * transport actually receives.
- *
- * This is the single place the three layers of configuration meet, and the precedence between
- * them is fixed here rather than in the desktop app: the request's own property wins, then the
- * project's setting, then the user's preference (which is also the engine default). A property
- * left unset in the request is therefore never "off" — it is "inherit".
- */
-import type { Preferences } from './project/preferences.js';
-import type { Attachment, HeaderEntry, ProjectSettings, RequestProperties } from './project/model.js';
-import type { AttachmentResolver } from './soap/mime/types.js';
-import type { SendAuth, SoapSendInput } from './types.js';
-import type { ProxyOptions, TlsOptions } from './http/types.js';
-import type { FileResolver } from './rest/body.js';
-import type { KeyValueEntry, RestBody, RestMethod, RestRequestSettings } from './rest/model.js';
-import type { Cookie } from './rest/response.js';
-import type { RestSendInput } from './rest/send.js';
-import type { GrpcMethodKind, GrpcRequestSettings } from './grpc/model.js';
-import type { GrpcSendInput } from './grpc/send.js';
-/** The parts of a request {@link toSendInput} reads. */
-export interface SendRequestInput {
-    readonly properties: RequestProperties;
-    readonly soapVersion: '1.1' | '1.2';
-    readonly soapAction?: string;
-    readonly headers: readonly HeaderEntry[];
-    readonly envelopeXml: string;
-}
-/**
- * How the send is to read attachment and inline-file bytes. The engine never opens a file
- * on its own, so without this the request's attachments (and its inline-file property) are
- * left inert; the desktop main process supplies `createFileAttachmentResolver`.
- */
-export interface AttachmentResolvers {
-    readonly resolver: AttachmentResolver;
-    /** Reads one file for "Enable Inline Files". */
-    readonly resolveFile?: (path: string) => Promise<Uint8Array>;
-    /** The project's resource root, for relative inline-file references. */
-    readonly resourceRoot?: string;
-}
-/** Everything {@link toSendInput} needs beyond the request itself. */
-export interface ToSendInputArgs {
-    readonly request: SendRequestInput;
-    /** The already-resolved endpoint URL (environment overrides applied). */
-    readonly endpoint: string;
-    readonly preferences?: Preferences;
-    readonly projectSettings?: Pick<ProjectSettings, 'defaultTimeoutMs'>;
-    /** The request's attachments; only acted on together with {@link attachmentResolvers}. */
-    readonly attachments?: readonly Attachment[];
-    readonly attachmentResolvers?: AttachmentResolvers;
-}
-/**
- * Builds the send input for one request.
- *
- * Timeout precedence is request > project > preference. The TLS floor (`ssl.minVersion`) and
- * the HTTP/2 offer come from preferences alone. Headers are the request's own, plus a
- * `User-Agent` from preferences when the request does not set one, plus `Accept-Encoding` when
- * response compression is enabled and `Connection: close` when connection reuse is disabled.
- * Request-body gzip is requested via `compressBody`; the transport does the compressing so the
- * `Content-Length` it computes describes the bytes that are actually sent.
- *
- * The MTOM/attachment properties are mapped only when `attachmentResolvers` says how bytes
- * can be read; without a resolver there is nothing the transport could do with them, and a
- * half-configured send would silently drop parts.
- *
- * @param args the request, its resolved endpoint, and the preferences/project settings around it
- */
-export declare function toSendInput(args: ToSendInputArgs): SoapSendInput;
-/** The parts of a REST request {@link toRestSendInput} reads. */
-export interface RestSendRequestInput {
-    readonly method: RestMethod;
-    readonly url: string;
-    readonly pathParams: readonly KeyValueEntry[];
-    readonly query: readonly KeyValueEntry[];
-    readonly headers: readonly KeyValueEntry[];
-    readonly body: RestBody;
-    readonly settings: RestRequestSettings;
-}
-/** Everything {@link toRestSendInput} needs beyond the request itself. */
-export interface ToRestSendInputArgs {
-    readonly request: RestSendRequestInput;
-    /** The API's effective base URL, environment override applied and properties expanded. */
-    readonly baseUrl: string;
-    /** The API's own settings, which a request inherits where it sets nothing. */
-    readonly apiSettings?: RestRequestSettings;
-    readonly preferences?: Preferences;
-    readonly projectSettings?: Pick<ProjectSettings, 'defaultTimeoutMs'>;
-    /** Resolved credentials; the host turns `secretRef`s into values and tokens into `oauth2`. */
-    readonly auth?: SendAuth;
-    /** Cookies already matched against the URL, when the request asks for them. */
-    readonly cookies?: readonly Cookie[];
-    /** How a multipart file part or a binary body is read. */
-    readonly resolveFile?: FileResolver;
-    readonly tls?: TlsOptions;
-    readonly proxy?: ProxyOptions;
-    readonly signal?: AbortSignal;
-}
-/**
- * Builds the send input for one REST request.
- *
- * Precedence is request → API → project → preference, the same ladder a SOAP request's properties
- * climb, and for the same reason: a setting the request leaves unset means *inherit*, never *off*.
- * The headers the host adds on the request's behalf — `User-Agent`, `Accept-Encoding`, `Connection`,
- * a default `Accept` — are passed separately from the request's own, so `rest/send.ts` can let the
- * user's typed header win without having to guess which came from where.
- */
-export declare function toRestSendInput(args: ToRestSendInputArgs): RestSendInput;
-/** The parts of a gRPC request {@link toGrpcSendInput} reads. */
-export interface GrpcSendRequestInput {
-    readonly service: string;
-    readonly method: string;
-    readonly methodKind: GrpcMethodKind;
-    readonly metadata: readonly KeyValueEntry[];
-    readonly settings: GrpcRequestSettings;
-}
-/** Everything {@link toGrpcSendInput} needs beyond the request itself. */
-export interface ToGrpcSendInputArgs {
-    readonly request: GrpcSendRequestInput;
-    /** The API's effective target, environment override applied and properties expanded. */
-    readonly target: string;
-    readonly tls: boolean;
-    /** The API's own metadata rows, which a request row of the same key overrides. */
-    readonly apiMetadata?: readonly KeyValueEntry[];
-    /** The API's own settings, which a request inherits where it sets nothing. */
-    readonly apiSettings?: GrpcRequestSettings;
-    readonly preferences?: Preferences;
-    readonly projectSettings?: Pick<ProjectSettings, 'defaultTimeoutMs'>;
-    /** Resolved credentials; the host turns `secretRef`s into values and tokens into `oauth2`. */
-    readonly auth?: SendAuth;
-    readonly tlsOptions?: TlsOptions;
-    readonly signal?: AbortSignal;
-}
-/**
- * Builds the transport input for one gRPC call, everything but the encoded messages.
- *
- * The same request → API → project → preference ladder as a REST request, and the same TLS rule:
- * the floor comes from preferences, and the host merges trust anchors, the client identity and the
- * per-request trust decision on top. Metadata rows are the API's first and then the request's, so
- * a repeated key resolves to the request's value on the wire.
- */
-export declare function toGrpcSendInput(args: ToGrpcSendInputArgs): Omit<GrpcSendInput, 'messages'>;

package/dist/wsdl/fetch.d.ts

@@ -1,13 +0,0 @@
-import type { FetchDocument } from './resolver.js';
-/**
- * Creates the default {@link FetchDocument} implementation: `file:` URLs are
- * read from disk via `node:fs/promises`, and `http(s):` URLs are fetched via
- * the global `fetch` (following redirects, with a 20s timeout combined with
- * the caller's `AbortSignal`, and a `wirebench/0.1` User-Agent).
- *
- * Text is decoded as UTF-8 by default, honouring an `iso-8859-1` `encoding`
- * in the document's XML declaration when present (see {@link decodeXmlBytes}
- * for why `utf-16` isn't sniffed the same way). Other declared encodings
- * fall back to UTF-8.
- */
-export declare function createDefaultFetchDocument(): FetchDocument;