@wirebench/engine 2.1.1

package/dist/grpc/reflection/descriptors.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Building a {@link ProtoSet} out of the encoded `FileDescriptorProto`s a server's reflection
+ * response carries, so a discovered schema and an imported one are the same thing downstream.
+ *
+ * An import parses `.proto` text; reflection receives the compiler's own output instead, one
+ * `FileDescriptorProto` per file. protobufjs reads that form through `Root.fromDescriptor`, which
+ * its `ext/descriptor` extension installs onto `Root` as a side effect — hence the bare import
+ * below, which also brings the type declaration for the method with it. The set it produces is
+ * indistinguishable to `describeServices`, the codec and `apiFromProtoSet` from a parsed one, so
+ * everything the import pipeline does after loading is reused unchanged.
+ */
+import 'protobufjs/ext/descriptor.js';
+import type { ProtoSet } from '../proto/load.js';
+/** A file's own name and the files it imports, read from its descriptor without a full decode. */
+export interface DescriptorHeader {
+    /** The file's name as the compiler recorded it, which is also what an `import` in another file spells. */
+    readonly name: string;
+    /** The names this file imports, in declaration order. */
+    readonly dependencies: readonly string[];
+}
+/**
+ * Reads a descriptor's `name` and `dependency` list.
+ *
+ * @throws ProtoError `grpc-reflection-descriptor` when the bytes are not a readable descriptor
+ */
+export declare function descriptorHeader(bytes: Uint8Array): DescriptorHeader;
+/**
+ * Wraps encoded `FileDescriptorProto`s in a `FileDescriptorSet`.
+ *
+ * `FileDescriptorSet` is one repeated message field, number 1, so the encoding is a length-delimited
+ * record per file and nothing has to be re-serialised: the server's bytes go through untouched, which
+ * is the same byte-exactness the `.proto` cache keeps.
+ */
+export declare function encodeFileDescriptorSet(files: readonly Uint8Array[]): Uint8Array;
+/** Reads the file names of a whole `FileDescriptorSet`, in the order it stores them. */
+export declare function descriptorSetHeaders(bytes: Uint8Array): DescriptorHeader[];
+/**
+ * Orders files so every file comes after the ones it imports. protobufjs resolves references as it
+ * adds each file, and a file naming a type from one added later would not find it.
+ */
+export declare function orderDescriptors(files: ReadonlyMap<string, Uint8Array>): string[];
+/** The collected descriptors as one `FileDescriptorSet`, dependencies first. */
+export declare function descriptorSetBytes(files: ReadonlyMap<string, Uint8Array>): Uint8Array;
+/** Options for {@link protoSetFromDescriptorSet}. */
+export interface ProtoSetFromDescriptorSetOptions {
+    /** The files to record as the set's roots. Defaults to every file in it. */
+    readonly roots?: readonly string[];
+}
+/**
+ * Resolves an encoded `FileDescriptorSet` into a loaded schema — the form the describe, sample and
+ * codec modules read, and the form a cached reflection definition is stored in.
+ *
+ * @throws ProtoError `grpc-reflection-empty` when the set has no files, `proto-unresolved` when a
+ * type reference in it resolves to nothing, which is what a set missing a dependency looks like
+ */
+export declare function protoSetFromDescriptorSet(bytes: Uint8Array, options?: ProtoSetFromDescriptorSetOptions): ProtoSet;
+/** Input to {@link protoSetFromDescriptors}. */
+export interface ProtoSetFromDescriptorsInput {
+    /** Every descriptor collected, keyed by the file name its own header carries. */
+    readonly files: ReadonlyMap<string, Uint8Array>;
+    /** The files the discovery started from — the ones declaring the services. Defaults to every file. */
+    readonly roots?: readonly string[];
+}
+/**
+ * Resolves a set of descriptors into a loaded schema.
+ *
+ * @throws as {@link protoSetFromDescriptorSet}
+ */
+export declare function protoSetFromDescriptors(input: ProtoSetFromDescriptorsInput): ProtoSet;

package/dist/grpc/reflection/descriptors.js

@@ -0,0 +1,140 @@
+/**
+ * Building a {@link ProtoSet} out of the encoded `FileDescriptorProto`s a server's reflection
+ * response carries, so a discovered schema and an imported one are the same thing downstream.
+ *
+ * An import parses `.proto` text; reflection receives the compiler's own output instead, one
+ * `FileDescriptorProto` per file. protobufjs reads that form through `Root.fromDescriptor`, which
+ * its `ext/descriptor` extension installs onto `Root` as a side effect — hence the bare import
+ * below, which also brings the type declaration for the method with it. The set it produces is
+ * indistinguishable to `describeServices`, the codec and `apiFromProtoSet` from a parsed one, so
+ * everything the import pipeline does after loading is reused unchanged.
+ */
+import protobuf from 'protobufjs';
+import 'protobufjs/ext/descriptor.js';
+import { ProtoError } from '../../errors.js';
+import { decodeMessage } from '../codec.js';
+import { DESCRIPTOR_HEADER_TYPE, DESCRIPTOR_SET_HEADER_TYPE, descriptorHeaderProtoSet } from './proto.js';
+/**
+ * Reads a descriptor's `name` and `dependency` list.
+ *
+ * @throws ProtoError `grpc-reflection-descriptor` when the bytes are not a readable descriptor
+ */
+export function descriptorHeader(bytes) {
+    let decoded;
+    try {
+        decoded = decodeMessage(descriptorHeaderProtoSet(), DESCRIPTOR_HEADER_TYPE, bytes);
+    }
+    catch (error) {
+        throw new ProtoError('grpc-reflection-descriptor', 'The server sent a file descriptor this client could not read', {
+            cause: error,
+            details: { bytes: bytes.byteLength },
+        });
+    }
+    const record = (decoded ?? {});
+    const name = typeof record.name === 'string' ? record.name : '';
+    const dependencies = Array.isArray(record.dependency)
+        ? record.dependency.filter((entry) => typeof entry === 'string')
+        : [];
+    return { name, dependencies };
+}
+/**
+ * Wraps encoded `FileDescriptorProto`s in a `FileDescriptorSet`.
+ *
+ * `FileDescriptorSet` is one repeated message field, number 1, so the encoding is a length-delimited
+ * record per file and nothing has to be re-serialised: the server's bytes go through untouched, which
+ * is the same byte-exactness the `.proto` cache keeps.
+ */
+export function encodeFileDescriptorSet(files) {
+    const writer = new protobuf.Writer();
+    for (const file of files) {
+        writer.uint32(0x0a).bytes(file);
+    }
+    return writer.finish();
+}
+/** Reads the file names of a whole `FileDescriptorSet`, in the order it stores them. */
+export function descriptorSetHeaders(bytes) {
+    let decoded;
+    try {
+        decoded = decodeMessage(descriptorHeaderProtoSet(), DESCRIPTOR_SET_HEADER_TYPE, bytes);
+    }
+    catch (error) {
+        throw new ProtoError('grpc-reflection-descriptor', 'The descriptor set could not be read', {
+            cause: error,
+            details: { bytes: bytes.byteLength },
+        });
+    }
+    const files = decoded.file;
+    return (Array.isArray(files) ? files : []).map((file) => {
+        const record = (file ?? {});
+        return {
+            name: typeof record.name === 'string' ? record.name : '',
+            dependencies: Array.isArray(record.dependency)
+                ? record.dependency.filter((entry) => typeof entry === 'string')
+                : [],
+        };
+    });
+}
+/**
+ * Orders files so every file comes after the ones it imports. protobufjs resolves references as it
+ * adds each file, and a file naming a type from one added later would not find it.
+ */
+export function orderDescriptors(files) {
+    const ordered = [];
+    const seen = new Set();
+    const add = (name) => {
+        if (seen.has(name)) {
+            return;
+        }
+        seen.add(name);
+        const bytes = files.get(name);
+        if (bytes === undefined) {
+            return;
+        }
+        for (const dependency of descriptorHeader(bytes).dependencies) {
+            add(dependency);
+        }
+        ordered.push(name);
+    };
+    for (const name of files.keys()) {
+        add(name);
+    }
+    return ordered;
+}
+/** The collected descriptors as one `FileDescriptorSet`, dependencies first. */
+export function descriptorSetBytes(files) {
+    return encodeFileDescriptorSet(orderDescriptors(files).map((name) => files.get(name)));
+}
+/**
+ * Resolves an encoded `FileDescriptorSet` into a loaded schema — the form the describe, sample and
+ * codec modules read, and the form a cached reflection definition is stored in.
+ *
+ * @throws ProtoError `grpc-reflection-empty` when the set has no files, `proto-unresolved` when a
+ * type reference in it resolves to nothing, which is what a set missing a dependency looks like
+ */
+export function protoSetFromDescriptorSet(bytes, options = {}) {
+    const files = descriptorSetHeaders(bytes).map((header) => header.name);
+    if (files.length === 0) {
+        throw new ProtoError('grpc-reflection-empty', 'The descriptor set describes no files');
+    }
+    let root;
+    try {
+        root = protobuf.Root.fromDescriptor(bytes, { keepCase: true });
+        root.resolveAll();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new ProtoError('proto-unresolved', message, { cause: error });
+    }
+    return { root, files, roots: [...(options.roots ?? files)] };
+}
+/**
+ * Resolves a set of descriptors into a loaded schema.
+ *
+ * @throws as {@link protoSetFromDescriptorSet}
+ */
+export function protoSetFromDescriptors(input) {
+    if (input.files.size === 0) {
+        throw new ProtoError('grpc-reflection-empty', 'The server described no files');
+    }
+    return protoSetFromDescriptorSet(descriptorSetBytes(input.files), input.roots !== undefined ? { roots: input.roots } : {});
+}

package/dist/grpc/reflection/proto.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The server reflection service, as a `.proto` the engine carries with it.
+ *
+ * A server that speaks reflection describes itself over a service the client must already know, so
+ * this one definition cannot come from the user. It is a string constant rather than a shipped
+ * `.proto` file because the engine builds with `tsc -b` alone and has no step that would copy an
+ * asset into `dist/`; it is loaded through the same {@link loadProtoSet} every imported file goes
+ * through, so the codec meets it exactly as it meets a user's own schema.
+ *
+ * Two packages exist for the same service. `grpc.reflection.v1alpha` is what servers shipped for
+ * years; `grpc.reflection.v1` is the stable name, and the message shapes are identical — which is
+ * why one template with the package substituted covers both rather than two copies that could drift.
+ */
+import type { ProtoSet } from '../proto/load.js';
+export type { GrpcReflectionVersion } from '../model.js';
+/** The two versions a server may answer on, newest first — the order `auto` tries them in. */
+export declare const REFLECTION_VERSIONS: readonly ['v1', 'v1alpha'];
+/** The `package` a version's service lives in. */
+export declare function reflectionPackage(version: 'v1' | 'v1alpha'): string;
+/** The fully qualified service name for a version. */
+export declare function reflectionServiceName(version: 'v1' | 'v1alpha'): string;
+/** The single method, a bidirectional stream whose exchange is request/response per message. */
+export declare const REFLECTION_METHOD = "ServerReflectionInfo";
+/** The reflection definition's source text for one version. */
+export declare function reflectionProtoSource(version: 'v1' | 'v1alpha'): string;
+/** The loaded reflection schema for one version, parsed once per process. */
+export declare function reflectionProtoSet(version: 'v1' | 'v1alpha'): ProtoSet;
+/** The message type {@link descriptorHeaderProtoSet} declares for one file. */
+export declare const DESCRIPTOR_HEADER_TYPE = "wirebench.reflection.FileDescriptorHeader";
+/** The message type {@link descriptorHeaderProtoSet} declares for a whole set. */
+export declare const DESCRIPTOR_SET_HEADER_TYPE = "wirebench.reflection.FileDescriptorSetHeader";
+/** The partial `FileDescriptorProto` schema, parsed once per process. */
+export declare function descriptorHeaderProtoSet(): ProtoSet;

package/dist/grpc/reflection/proto.js

@@ -0,0 +1,144 @@
+/**
+ * The server reflection service, as a `.proto` the engine carries with it.
+ *
+ * A server that speaks reflection describes itself over a service the client must already know, so
+ * this one definition cannot come from the user. It is a string constant rather than a shipped
+ * `.proto` file because the engine builds with `tsc -b` alone and has no step that would copy an
+ * asset into `dist/`; it is loaded through the same {@link loadProtoSet} every imported file goes
+ * through, so the codec meets it exactly as it meets a user's own schema.
+ *
+ * Two packages exist for the same service. `grpc.reflection.v1alpha` is what servers shipped for
+ * years; `grpc.reflection.v1` is the stable name, and the message shapes are identical — which is
+ * why one template with the package substituted covers both rather than two copies that could drift.
+ */
+import { loadProtoSet } from '../proto/load.js';
+/** The two versions a server may answer on, newest first — the order `auto` tries them in. */
+export const REFLECTION_VERSIONS = ['v1', 'v1alpha'];
+/** The `package` a version's service lives in. */
+export function reflectionPackage(version) {
+    return `grpc.reflection.${version}`;
+}
+/** The fully qualified service name for a version. */
+export function reflectionServiceName(version) {
+    return `${reflectionPackage(version)}.ServerReflection`;
+}
+/** The single method, a bidirectional stream whose exchange is request/response per message. */
+export const REFLECTION_METHOD = 'ServerReflectionInfo';
+/** The import path the reflection definition is loaded under. */
+const REFLECTION_FILE = 'grpc/reflection/reflection.proto';
+/**
+ * `reflection.proto` with `__PACKAGE__` where the package name goes. Transcribed from the gRPC
+ * specification's own definition; the field numbers are part of the wire contract, so the gaps
+ * (`ServerReflectionRequest` has no field 2, `ServerReflectionResponse` no field 3) are deliberate.
+ */
+const REFLECTION_TEMPLATE = `syntax = "proto3";
+
+package __PACKAGE__;
+
+service ServerReflection {
+  rpc ServerReflectionInfo(stream ServerReflectionRequest) returns (stream ServerReflectionResponse);
+}
+
+message ServerReflectionRequest {
+  string host = 1;
+  oneof message_request {
+    string file_by_filename = 3;
+    string file_containing_symbol = 4;
+    ExtensionRequest file_containing_extension = 5;
+    string all_extension_numbers_of_type = 6;
+    string list_services = 7;
+  }
+}
+
+message ExtensionRequest {
+  string containing_type = 1;
+  int32 extension_number = 2;
+}
+
+message ServerReflectionResponse {
+  string valid_host = 1;
+  ServerReflectionRequest original_request = 2;
+  oneof message_response {
+    FileDescriptorResponse file_descriptor_response = 4;
+    ExtensionNumberResponse all_extension_numbers_response = 5;
+    ListServiceResponse list_services_response = 6;
+    ErrorResponse error_response = 7;
+  }
+}
+
+message FileDescriptorResponse {
+  repeated bytes file_descriptor_proto = 1;
+}
+
+message ExtensionNumberResponse {
+  string base_type_name = 1;
+  repeated int32 extension_number = 2;
+}
+
+message ListServiceResponse {
+  repeated ServiceResponse service = 1;
+}
+
+message ServiceResponse {
+  string name = 1;
+}
+
+message ErrorResponse {
+  int32 error_code = 1;
+  string error_message = 2;
+}
+`;
+/** The reflection definition's source text for one version. */
+export function reflectionProtoSource(version) {
+    return REFLECTION_TEMPLATE.replaceAll('__PACKAGE__', reflectionPackage(version));
+}
+const cached = new Map();
+/** The loaded reflection schema for one version, parsed once per process. */
+export function reflectionProtoSet(version) {
+    const existing = cached.get(version);
+    if (existing !== undefined) {
+        return existing;
+    }
+    const set = loadProtoSet(new Map([[REFLECTION_FILE, reflectionProtoSource(version)]]), { roots: [REFLECTION_FILE] });
+    cached.set(version, set);
+    return set;
+}
+/**
+ * The import path a descriptor file the engine loaded from a reflection response is called by, and
+ * the partial `FileDescriptorProto` the client reads its name and dependencies from.
+ *
+ * A reflection response carries each file as encoded `FileDescriptorProto` bytes, and the client has
+ * to know a file's own name (to key it, and to satisfy a later `file_by_filename`) and what it
+ * imports (to notice a dependency the server did not volunteer) *before* it can build a schema out
+ * of the set. Protobuf's unknown-field rule makes that cheap: decoding a full `FileDescriptorProto`
+ * against a message declaring only fields 1 and 3 yields exactly those two and skips everything
+ * else, so the engine needs no copy of `descriptor.proto` to read a file's header.
+ */
+const HEADER_FILE = 'grpc/reflection/descriptor-header.proto';
+/** The message type {@link descriptorHeaderProtoSet} declares for one file. */
+export const DESCRIPTOR_HEADER_TYPE = 'wirebench.reflection.FileDescriptorHeader';
+/** The message type {@link descriptorHeaderProtoSet} declares for a whole set. */
+export const DESCRIPTOR_SET_HEADER_TYPE = 'wirebench.reflection.FileDescriptorSetHeader';
+const HEADER_SOURCE = `syntax = "proto3";
+
+package wirebench.reflection;
+
+// The first fields of google.protobuf.FileDescriptorProto. Every other field decodes as unknown and
+// is skipped, which is all this client needs to key a file and follow its imports.
+message FileDescriptorHeader {
+  string name = 1;
+  repeated string dependency = 3;
+}
+
+// google.protobuf.FileDescriptorSet, read one header deep: enough to list a cached set's files in
+// the order they were written without decoding every declaration in them.
+message FileDescriptorSetHeader {
+  repeated FileDescriptorHeader file = 1;
+}
+`;
+let headerSet;
+/** The partial `FileDescriptorProto` schema, parsed once per process. */
+export function descriptorHeaderProtoSet() {
+    headerSet ??= loadProtoSet(new Map([[HEADER_FILE, HEADER_SOURCE]]), { roots: [HEADER_FILE] });
+    return headerSet;
+}

package/dist/grpc/send.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Sending one gRPC call over HTTP/2 with Node's `http2` module.
+ *
+ * gRPC is HTTP/2 with a fixed shape: a `POST` to `/<service>/<method>`, `content-type:
+ * application/grpc`, `te: trailers`, each message length-prefixed in the body, and the outcome in
+ * `grpc-status`/`grpc-message` trailers (or in the headers, for a "trailers-only" response). The
+ * REST transport's HTTP client hides trailers and buffers bodies, which is exactly what a server
+ * stream must not have, so this module speaks HTTP/2 directly. It knows nothing about protobuf:
+ * messages arrive and leave as bytes, and `call.ts` is where the codec meets the wire.
+ *
+ * A non-`OK` status is a result, not an error — the user asked what the server would say, and it
+ * said `NOT_FOUND`. Only a failure to get an answer at all (connection, TLS, an abort, a malformed
+ * stream) throws.
+ */
+import type { SslInfo } from '../http/tls.js';
+import type { Timings, TlsOptions } from '../http/types.js';
+import type { KeyValueEntry } from '../rest/model.js';
+import type { SendAuth } from '../types.js';
+import type { GrpcTarget } from './target.js';
+export { parseGrpcTarget } from './target.js';
+export type { GrpcTarget } from './target.js';
+/** Everything {@link sendGrpc} needs, with every property already expanded and every secret resolved. */
+export interface GrpcSendInput {
+    readonly target: string;
+    readonly tls: boolean;
+    readonly service: string;
+    readonly method: string;
+    /** The request messages, already encoded; one for a unary or server-streaming call. */
+    readonly messages: readonly Uint8Array[];
+    /** Metadata rows: the API's defaults first, then the request's own, a later row winning a repeated key. */
+    readonly metadata: readonly KeyValueEntry[];
+    /** Metadata the host adds on the call's behalf (`user-agent`), which a typed row overrides. */
+    readonly defaultMetadata?: Readonly<Record<string, string>>;
+    /** Credentials, already resolved to values. Basic, Bearer, OAuth2 and header API keys become `authorization` or a header. */
+    readonly auth?: SendAuth;
+    /** The deadline, sent as `grpc-timeout` and enforced locally. */
+    readonly timeoutMs: number;
+    /** Stop reading once this many response message bytes have arrived. */
+    readonly maxSizeBytes?: number;
+    readonly localAddress?: string;
+    readonly tlsOptions?: TlsOptions;
+    readonly signal?: AbortSignal;
+    /** Clock for timings; tests inject one. */
+    readonly now?: () => number;
+    /**
+     * Called once with the initial metadata, the moment the server's headers arrive rather than when
+     * the call ends. A server stream can run for minutes before its first message, and the headers
+     * are the first sign it was accepted at all.
+     */
+    readonly onHeaders?: (headers: Readonly<Record<string, string>>, httpStatus: number) => void;
+    /**
+     * Called for each response message as it is parsed, already decompressed, in arrival order. The
+     * same messages are still collected into {@link GrpcExchange.messages}, so a caller that only
+     * wants the end result ignores this and sees no difference.
+     */
+    readonly onMessage?: (message: Uint8Array, index: number) => void;
+    /**
+     * Opts into *interactive* mode: the request side stays open after {@link GrpcSendInput.messages}
+     * are written, and the handle pushes further messages or half-closes. Without it — every batch
+     * caller — `sendGrpc` writes every message and half-closes immediately, as it always has.
+     *
+     * The call still ends the way it always did: when the server ends the stream, the deadline
+     * passes, or the signal aborts. Half-closing is not required to finish, since a server may
+     * answer and end while the client still holds its side open.
+     */
+    readonly onOpen?: (handle: GrpcStreamHandle) => void;
+}
+/** The client's side of a call left open by {@link GrpcSendInput.onOpen}. */
+export interface GrpcStreamHandle {
+    /**
+     * Frames and writes one more request message.
+     *
+     * @throws GrpcError `grpc-stream-closed` once the request side is half-closed or the call is over
+     */
+    readonly write: (message: Uint8Array) => void;
+    /** Half-closes the request side. Idempotent, and a no-op once the call has ended. */
+    readonly end: () => void;
+    /** False once {@link end} has been called or the call has ended. */
+    readonly isOpen: () => boolean;
+}
+/** Where a call's status came from, which the response pane says when it is not the trailers. */
+export type GrpcStatusSource = 'trailers' | 'headers' | 'http' | 'local';
+/** The full record of one gRPC call. */
+export interface GrpcExchange {
+    readonly request: {
+        readonly authority: string;
+        readonly path: string;
+        /** The headers as sent, pseudo-headers included, lower-cased. */
+        readonly headers: Readonly<Record<string, string>>;
+        readonly messages: readonly Uint8Array[];
+    };
+    /** The HTTP status, 200 for every answer a gRPC server gives itself. */
+    readonly httpStatus: number;
+    /** Response headers (initial metadata), lower-cased, pseudo-headers removed. */
+    readonly headers: Readonly<Record<string, string>>;
+    readonly trailers: Readonly<Record<string, string>>;
+    readonly status: number;
+    readonly statusName: string;
+    readonly statusMessage?: string;
+    readonly statusSource: GrpcStatusSource;
+    /** Response messages in arrival order, decompressed. */
+    readonly messages: readonly Uint8Array[];
+    /** The `grpc-encoding` the server used, when it compressed. */
+    readonly encoding?: string;
+    /** True when reading stopped at `maxSizeBytes` before the stream ended. */
+    readonly truncated: boolean;
+    readonly timings: Timings;
+    readonly tls?: SslInfo;
+    /** Request pseudo-headers and headers as text, then the framed messages, as they went on the wire. */
+    readonly rawRequest: Uint8Array;
+    /** Response headers as text, the framed messages, then the trailers as text. */
+    readonly rawResponse: Uint8Array;
+    readonly durationMs: number;
+}
+/** Builds the request headers: protocol first, then host defaults, credentials, and the user's rows last. */
+export declare function buildGrpcHeaders(input: GrpcSendInput, target: GrpcTarget): Record<string, string>;
+/**
+ * Sends one gRPC call and collects every response message and the final status.
+ *
+ * Client-streaming and bidirectional methods are sent in "batch" form: every request message is
+ * written, the request side is closed, and the responses are read until the server ends the stream.
+ * {@link GrpcSendInput.onOpen} turns that into an interactive call instead, where the caller keeps
+ * pushing messages until it half-closes.
+ *
+ * {@link GrpcSendInput.onHeaders} and {@link GrpcSendInput.onMessage} report the initial metadata
+ * and each response message as they arrive, for a caller that shows a stream while it runs.
+ *
+ * @throws HttpError for a connection, DNS, TLS or abort failure, with the HTTP transport's codes;
+ * GrpcError `grpc-target-invalid`, `grpc-auth-unsupported`, `grpc-stream-malformed`,
+ * `grpc-encoding-unsupported`, `grpc-message-too-large`, `grpc-stream-closed`
+ */
+export declare function sendGrpc(input: GrpcSendInput): Promise<GrpcExchange>;