@wirebench/engine 2.1.1

package/dist/grpc/call.d.ts

@@ -0,0 +1,64 @@
+/**
+ * One gRPC call end to end: the request message text is encoded against the method's request type,
+ * sent, and every response message decoded against its response type. This is the function the
+ * desktop app calls; `send.ts` beneath it is bytes only, and `codec.ts` beside it is schema only.
+ */
+import type { GrpcMethodKind } from './model.js';
+import type { ProtoSet } from './proto/load.js';
+import type { GrpcExchange, GrpcSendInput } from './send.js';
+/** Everything {@link callGrpc} needs: the schema, the method, the message text, and the transport input. */
+export interface GrpcCallInput extends Omit<GrpcSendInput, 'messages' | 'onMessage' | 'onOpen'> {
+    readonly set: ProtoSet;
+    /** The request message(s) as JSON text: one object, or an array for a client stream. */
+    readonly messageText: string;
+    /**
+     * Called for each response message as it arrives, already decoded — the transport's
+     * {@link GrpcSendInput.onMessage} with the schema applied, so a caller showing a live stream
+     * never sees raw bytes. The same messages still come back in the result.
+     */
+    readonly onMessage?: (message: GrpcResponseMessage, index: number) => void;
+    /** Opts into an interactive call: the request side stays open and the handle drives it. */
+    readonly onOpen?: (handle: GrpcCallStreamHandle) => void;
+}
+/** The client's side of an interactive call, in message text rather than bytes. */
+export interface GrpcCallStreamHandle {
+    /**
+     * Encodes one more request message from its JSON text and writes it, returning the message as it
+     * went — the canonical JSON, which is what the caller shows as sent.
+     *
+     * @throws ProtoError when the text does not parse or encode against the request type; GrpcError
+     * `grpc-stream-closed` once the request side is closed
+     */
+    readonly send: (messageText: string) => unknown;
+    /** Half-closes the request side. Idempotent. */
+    readonly end: () => void;
+    readonly isOpen: () => boolean;
+}
+/** One response message, decoded when it could be. */
+export interface GrpcResponseMessage {
+    /** The message as canonical JSON, or `undefined` when it did not decode. */
+    readonly json?: unknown;
+    /** The message bytes as base64, kept so a message that did not decode is still visible. */
+    readonly base64: string;
+    readonly bytes: number;
+    readonly problem?: string;
+}
+/** The outcome of {@link callGrpc}. */
+export interface GrpcCallResult {
+    readonly exchange: GrpcExchange;
+    readonly methodKind: GrpcMethodKind;
+    readonly requestType: string;
+    readonly responseType: string;
+    /** The request messages as they were sent, in canonical JSON. */
+    readonly requestMessages: readonly unknown[];
+    readonly responseMessages: readonly GrpcResponseMessage[];
+}
+/**
+ * Encodes, sends and decodes one call.
+ *
+ * @throws ProtoError for a method or type the schema does not define, or a message that does not
+ * encode; whatever {@link sendGrpc} throws for a failure to get an answer
+ */
+export declare function callGrpc(input: GrpcCallInput): Promise<GrpcCallResult>;
+/** Decodes one response message, reporting rather than throwing when it does not decode. */
+export declare function decodeResponseMessage(set: ProtoSet, responseType: string, bytes: Uint8Array): GrpcResponseMessage;

package/dist/grpc/call.js

@@ -0,0 +1,72 @@
+/**
+ * One gRPC call end to end: the request message text is encoded against the method's request type,
+ * sent, and every response message decoded against its response type. This is the function the
+ * desktop app calls; `send.ts` beneath it is bytes only, and `codec.ts` beside it is schema only.
+ */
+import { decodeMessage, encodeMessage, parseMessageText } from './codec.js';
+import { clientStreams } from './model.js';
+import { describeMethod } from './proto/describe.js';
+import { sendGrpc } from './send.js';
+/**
+ * Encodes, sends and decodes one call.
+ *
+ * @throws ProtoError for a method or type the schema does not define, or a message that does not
+ * encode; whatever {@link sendGrpc} throws for a failure to get an answer
+ */
+export async function callGrpc(input) {
+    const method = describeMethod(input.set, input.service, input.method);
+    const parsed = parseMessageText(input.messageText, clientStreams(method.kind));
+    const messages = parsed.map((message) => encodeMessage(input.set, method.requestType, message));
+    const { set, messageText, onMessage, onOpen, ...send } = input;
+    void messageText;
+    // Every request message in canonical JSON: the ones the text held, then whatever an interactive
+    // call pushed afterwards, so the result records the whole conversation rather than its opening.
+    const requestMessages = messages.map((bytes) => decodeMessage(set, method.requestType, bytes));
+    const exchange = await sendGrpc({
+        ...send,
+        messages,
+        ...(onMessage !== undefined
+            ? {
+                onMessage: (bytes, index) => {
+                    onMessage(decodeResponseMessage(set, method.responseType, bytes), index);
+                },
+            }
+            : {}),
+        ...(onOpen !== undefined
+            ? {
+                onOpen: (handle) => {
+                    onOpen({
+                        send: (text) => {
+                            const [message] = parseMessageText(text, false);
+                            const bytes = encodeMessage(set, method.requestType, message);
+                            handle.write(bytes);
+                            const json = decodeMessage(set, method.requestType, bytes);
+                            requestMessages.push(json);
+                            return json;
+                        },
+                        end: handle.end,
+                        isOpen: handle.isOpen,
+                    });
+                },
+            }
+            : {}),
+    });
+    return {
+        exchange,
+        methodKind: method.kind,
+        requestType: method.requestType,
+        responseType: method.responseType,
+        requestMessages,
+        responseMessages: exchange.messages.map((bytes) => decodeResponseMessage(set, method.responseType, bytes)),
+    };
+}
+/** Decodes one response message, reporting rather than throwing when it does not decode. */
+export function decodeResponseMessage(set, responseType, bytes) {
+    const base64 = Buffer.from(bytes).toString('base64');
+    try {
+        return { json: decodeMessage(set, responseType, bytes), base64, bytes: bytes.byteLength };
+    }
+    catch (error) {
+        return { base64, bytes: bytes.byteLength, problem: error instanceof Error ? error.message : String(error) };
+    }
+}

package/dist/grpc/codec.d.ts

@@ -0,0 +1,29 @@
+/**
+ * JSON ⇄ protobuf bytes for one message type. The user edits a message as JSON in the canonical
+ * mapping the protobuf specification defines; the wire wants the binary encoding. This module is
+ * where the two meet, and it is deliberately strict on the way in — an unknown field, a value of the
+ * wrong shape or a malformed well-known type is an error naming the field, never a silently dropped
+ * key — and lenient on the way out, because whatever the server sent is what the user needs to see.
+ */
+import type { ProtoSet } from './proto/load.js';
+/**
+ * Encodes `json` as the binary form of the message type `typeName`.
+ *
+ * @throws ProtoError `grpc-message-invalid` naming the offending field, `proto-type-unknown`
+ */
+export declare function encodeMessage(set: ProtoSet, typeName: string, json: unknown): Uint8Array;
+/**
+ * Decodes `bytes` as the message type `typeName` into canonical JSON: 64-bit integers as strings,
+ * enums by name, bytes as base64, well-known types in their string or bare forms, and fields at
+ * their default value omitted.
+ *
+ * @throws ProtoError `grpc-message-malformed` when the bytes do not decode, `proto-type-unknown`
+ */
+export declare function decodeMessage(set: ProtoSet, typeName: string, bytes: Uint8Array): unknown;
+/**
+ * Parses the JSON text of a request body into the messages to send: one object, or — for a
+ * client-streaming method — an array of objects.
+ *
+ * @throws ProtoError `grpc-message-invalid` when the text is not JSON or has the wrong shape
+ */
+export declare function parseMessageText(text: string, streaming: boolean): unknown[];

package/dist/grpc/codec.js

@@ -0,0 +1,416 @@
+/**
+ * JSON ⇄ protobuf bytes for one message type. The user edits a message as JSON in the canonical
+ * mapping the protobuf specification defines; the wire wants the binary encoding. This module is
+ * where the two meet, and it is deliberately strict on the way in — an unknown field, a value of the
+ * wrong shape or a malformed well-known type is an error naming the field, never a silently dropped
+ * key — and lenient on the way out, because whatever the server sent is what the user needs to see.
+ */
+import protobuf from 'protobufjs';
+import { ProtoError } from '../errors.js';
+import { lookupMessageType, qualifiedName } from './proto/describe.js';
+import { durationFromJson, durationToJson, fieldMaskFromJson, fieldMaskToJson, isWrapperType, timestampFromJson, timestampToJson, } from './proto/well-known.js';
+const TO_OBJECT_OPTIONS = {
+    longs: String,
+    enums: String,
+    bytes: String,
+    defaults: false,
+    arrays: false,
+    objects: false,
+    oneofs: false,
+};
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function invalid(path, reason) {
+    return new ProtoError('grpc-message-invalid', `${path}: ${reason}`, { details: { path, reason } });
+}
+/** `snake_case` → `lowerCamelCase`, the JSON name the specification derives from a field name. */
+function jsonName(name) {
+    return name.replace(/_([a-z0-9])/g, (_, char) => char.toUpperCase());
+}
+/** Finds a field by its declared name or its JSON name, both of which the JSON mapping accepts. */
+function fieldNamed(type, key) {
+    const direct = type.fields[key];
+    if (direct !== undefined) {
+        return direct;
+    }
+    return type.fieldsArray.find((field) => jsonName(field.name) === key);
+}
+/** Message-level conversions for well-known types, JSON form → parser form. `undefined` means "ordinary message". */
+function wellKnownFromJson(type, value, path, set) {
+    const name = qualifiedName(type);
+    const field = (id) => type.fieldsById[id]?.name ?? String(id);
+    switch (name) {
+        case 'google.protobuf.Timestamp': {
+            if (isRecord(value))
+                return value;
+            const { seconds, nanos } = timestampFromJson(value);
+            return { [field(1)]: seconds, [field(2)]: nanos };
+        }
+        case 'google.protobuf.Duration': {
+            if (isRecord(value))
+                return value;
+            const { seconds, nanos } = durationFromJson(value);
+            return { [field(1)]: seconds, [field(2)]: nanos };
+        }
+        case 'google.protobuf.FieldMask':
+            return isRecord(value) ? value : { [field(1)]: fieldMaskFromJson(value).paths };
+        case 'google.protobuf.Struct':
+            if (!isRecord(value))
+                throw invalid(path, 'a Struct must be a JSON object');
+            return {
+                [field(1)]: Object.fromEntries(Object.entries(value).map(([k, v]) => [k, valueFromJson(type.root, v)])),
+            };
+        case 'google.protobuf.Value':
+            return valueFromJson(type.root, value);
+        case 'google.protobuf.ListValue':
+            if (!Array.isArray(value))
+                throw invalid(path, 'a ListValue must be a JSON array');
+            return { [field(1)]: value.map((item) => valueFromJson(type.root, item)) };
+        case 'google.protobuf.Empty':
+            return {};
+        case 'google.protobuf.Any':
+            return anyFromJson(type, value, path, set);
+        default:
+            if (isWrapperType(name)) {
+                return isRecord(value) && 'value' in value ? value : { [field(1)]: value };
+            }
+            return undefined;
+    }
+}
+function valueFromJson(root, value) {
+    const type = root.lookupType('google.protobuf.Value');
+    const field = (id) => type.fieldsById[id]?.name ?? String(id);
+    if (value === null || value === undefined)
+        return { [field(1)]: 0 };
+    if (typeof value === 'number')
+        return { [field(2)]: value };
+    if (typeof value === 'string')
+        return { [field(3)]: value };
+    if (typeof value === 'boolean')
+        return { [field(4)]: value };
+    if (Array.isArray(value)) {
+        const list = root.lookupType('google.protobuf.ListValue');
+        return { [field(6)]: { [list.fieldsById[1]?.name ?? 'values']: value.map((item) => valueFromJson(root, item)) } };
+    }
+    const struct = root.lookupType('google.protobuf.Struct');
+    return {
+        [field(5)]: {
+            [struct.fieldsById[1]?.name ?? 'fields']: Object.fromEntries(Object.entries(value).map(([k, v]) => [k, valueFromJson(root, v)])),
+        },
+    };
+}
+function anyFromJson(type, value, path, set) {
+    if (!isRecord(value))
+        throw invalid(path, 'an Any must be a JSON object with an "@type"');
+    const { '@type': typeUrl, ...rest } = value;
+    if (typeof typeUrl !== 'string' || typeUrl === '') {
+        if ('type_url' in value || 'typeUrl' in value)
+            return value;
+        throw invalid(path, 'an Any needs an "@type" such as "type.googleapis.com/pkg.Message"');
+    }
+    const innerName = typeUrl.slice(typeUrl.lastIndexOf('/') + 1);
+    const inner = lookupMessageType(set, innerName);
+    const innerJson = wellKnownFromJson(inner, rest['value'], `${path}.value`, set) !== undefined && 'value' in rest
+        ? rest['value']
+        : rest;
+    const bytes = encodeMessage(set, innerName, innerJson);
+    return { [type.fieldsById[1]?.name ?? 'type_url']: typeUrl, [type.fieldsById[2]?.name ?? 'value']: bytes };
+}
+const INT64_TYPES = new Set(['int64', 'uint64', 'sint64', 'fixed64', 'sfixed64']);
+const INT32_TYPES = new Set(['int32', 'uint32', 'sint32', 'fixed32', 'sfixed32']);
+const FLOAT_TYPES = new Set(['float', 'double']);
+/**
+ * Checks a scalar or enum value against its declared type, the way the JSON mapping reads it: a
+ * 64-bit integer may be a string, a float may be `"NaN"` or `"Infinity"`, an enum may be a name or
+ * a number, bytes are base64. The parser's own `verify` wants its internal forms (a `Long`, an enum
+ * number), so the checking lives here and `fromObject` does the converting.
+ */
+function checkScalar(field, value, path) {
+    const type = field.type;
+    const resolved = field.resolvedType;
+    if (resolved instanceof protobuf.Enum) {
+        if (typeof value === 'string') {
+            if (!(value in resolved.values)) {
+                throw invalid(path, `"${value}" is not a value of ${qualifiedName(resolved)}`);
+            }
+            return value;
+        }
+        if (typeof value === 'number' && Number.isInteger(value)) {
+            return value;
+        }
+        throw invalid(path, `expected a ${qualifiedName(resolved)} name`);
+    }
+    if (type === 'string') {
+        if (typeof value !== 'string')
+            throw invalid(path, 'string expected');
+        return value;
+    }
+    if (type === 'bool') {
+        if (typeof value !== 'boolean')
+            throw invalid(path, 'boolean expected');
+        return value;
+    }
+    if (type === 'bytes') {
+        if (typeof value !== 'string')
+            throw invalid(path, 'base64 string expected');
+        return value;
+    }
+    if (INT64_TYPES.has(type)) {
+        if (typeof value === 'number' && Number.isInteger(value))
+            return value;
+        if (typeof value === 'string' && /^-?\d+$/.test(value))
+            return value;
+        throw invalid(path, 'integer expected (a 64-bit value may be written as a string)');
+    }
+    if (INT32_TYPES.has(type)) {
+        if (typeof value === 'number' && Number.isInteger(value))
+            return value;
+        if (typeof value === 'string' && /^-?\d+$/.test(value))
+            return Number(value);
+        throw invalid(path, 'integer expected');
+    }
+    if (FLOAT_TYPES.has(type)) {
+        if (typeof value === 'number')
+            return value;
+        if (value === 'NaN' || value === 'Infinity' || value === '-Infinity')
+            return Number(value);
+        if (typeof value === 'string' && value.trim() !== '' && !Number.isNaN(Number(value)))
+            return Number(value);
+        throw invalid(path, 'number expected');
+    }
+    return value;
+}
+/** Converts one JSON value into the parser's object form for `type`, checking every field name. */
+function toParserObject(set, type, value, path) {
+    const special = wellKnownFromJson(type, value, path, set);
+    if (special !== undefined) {
+        return special;
+    }
+    if (!isRecord(value)) {
+        throw invalid(path, `expected a JSON object for ${qualifiedName(type)}`);
+    }
+    const out = {};
+    for (const [key, raw] of Object.entries(value)) {
+        const field = fieldNamed(type, key);
+        if (field === undefined) {
+            throw invalid(`${path}.${key}`, `${qualifiedName(type)} has no field "${key}"`);
+        }
+        if (raw === null || raw === undefined) {
+            continue;
+        }
+        field.resolve();
+        const fieldPath = `${path}.${field.name}`;
+        if (field instanceof protobuf.MapField) {
+            if (!isRecord(raw))
+                throw invalid(fieldPath, 'a map field must be a JSON object');
+            const valueType = field.resolvedType;
+            out[field.name] = Object.fromEntries(Object.entries(raw).map(([k, v]) => [
+                k,
+                valueType instanceof protobuf.Type
+                    ? toParserObject(set, valueType, v, `${fieldPath}.${k}`)
+                    : checkScalar(field, v, `${fieldPath}.${k}`),
+            ]));
+            continue;
+        }
+        const convert = (item, itemPath) => field.resolvedType instanceof protobuf.Type
+            ? toParserObject(set, field.resolvedType, item, itemPath)
+            : checkScalar(field, item, itemPath);
+        if (field.repeated) {
+            if (!Array.isArray(raw))
+                throw invalid(fieldPath, 'a repeated field must be a JSON array');
+            out[field.name] = raw.map((item, index) => convert(item, `${fieldPath}[${String(index)}]`));
+            continue;
+        }
+        out[field.name] = convert(raw, fieldPath);
+    }
+    return out;
+}
+/**
+ * Encodes `json` as the binary form of the message type `typeName`.
+ *
+ * @throws ProtoError `grpc-message-invalid` naming the offending field, `proto-type-unknown`
+ */
+export function encodeMessage(set, typeName, json) {
+    const type = lookupMessageType(set, typeName);
+    const object = toParserObject(set, type, json, qualifiedName(type));
+    return type.encode(type.fromObject(object)).finish();
+}
+/** Message-level conversions for well-known types, parser form → JSON form. */
+function wellKnownToJson(type, value, set) {
+    const name = qualifiedName(type);
+    const field = (id) => type.fieldsById[id]?.name ?? String(id);
+    const at = (id) => value[field(id)];
+    switch (name) {
+        case 'google.protobuf.Timestamp':
+            return timestampToJson({ seconds: at(1), nanos: at(2) });
+        case 'google.protobuf.Duration':
+            return durationToJson({ seconds: at(1), nanos: at(2) });
+        case 'google.protobuf.FieldMask':
+            return fieldMaskToJson({ paths: at(1) });
+        case 'google.protobuf.Struct': {
+            const fields = at(1);
+            return isRecord(fields)
+                ? Object.fromEntries(Object.entries(fields).map(([k, v]) => [k, valueToJson(type.root, v)]))
+                : {};
+        }
+        case 'google.protobuf.Value':
+            return valueToJson(type.root, value);
+        case 'google.protobuf.ListValue': {
+            const items = at(1);
+            return Array.isArray(items) ? items.map((item) => valueToJson(type.root, item)) : [];
+        }
+        case 'google.protobuf.Empty':
+            return {};
+        case 'google.protobuf.Any':
+            return anyToJson(value, at(1), at(2), set);
+        default:
+            if (isWrapperType(name)) {
+                return at(1) ?? wrapperDefault(name);
+            }
+            return undefined;
+    }
+}
+function wrapperDefault(name) {
+    switch (name) {
+        case 'google.protobuf.BoolValue':
+            return false;
+        case 'google.protobuf.StringValue':
+        case 'google.protobuf.BytesValue':
+            return '';
+        case 'google.protobuf.Int64Value':
+        case 'google.protobuf.UInt64Value':
+            return '0';
+        default:
+            return 0;
+    }
+}
+function valueToJson(root, value) {
+    if (!isRecord(value))
+        return null;
+    const type = root.lookupType('google.protobuf.Value');
+    const field = (id) => type.fieldsById[id]?.name ?? String(id);
+    if (field(2) in value)
+        return value[field(2)];
+    if (field(3) in value)
+        return value[field(3)];
+    if (field(4) in value)
+        return value[field(4)];
+    if (field(5) in value) {
+        const struct = value[field(5)];
+        const fields = isRecord(struct)
+            ? struct[root.lookupType('google.protobuf.Struct').fieldsById[1]?.name ?? 'fields']
+            : undefined;
+        return isRecord(fields)
+            ? Object.fromEntries(Object.entries(fields).map(([k, v]) => [k, valueToJson(root, v)]))
+            : {};
+    }
+    if (field(6) in value) {
+        const list = value[field(6)];
+        const items = isRecord(list)
+            ? list[root.lookupType('google.protobuf.ListValue').fieldsById[1]?.name ?? 'values']
+            : undefined;
+        return Array.isArray(items) ? items.map((item) => valueToJson(root, item)) : [];
+    }
+    return null;
+}
+function anyToJson(value, typeUrl, bytes, set) {
+    if (typeof typeUrl !== 'string' || typeUrl === '') {
+        return value;
+    }
+    const innerName = typeUrl.slice(typeUrl.lastIndexOf('/') + 1);
+    let inner;
+    try {
+        inner = lookupMessageType(set, innerName);
+    }
+    catch {
+        return {
+            '@type': typeUrl,
+            value: typeof bytes === 'string' ? bytes : Buffer.from(bytes).toString('base64'),
+        };
+    }
+    const raw = typeof bytes === 'string' ? Buffer.from(bytes, 'base64') : bytes;
+    const decoded = decodeMessage(set, qualifiedName(inner), raw);
+    return isRecord(decoded) && wellKnownToJson(inner, {}, set) === undefined
+        ? { '@type': typeUrl, ...decoded }
+        : { '@type': typeUrl, value: decoded };
+}
+/** Converts the parser's object form of `type` into canonical JSON. Lenient: nothing here throws. */
+function toJson(set, type, value) {
+    if (!isRecord(value)) {
+        return value;
+    }
+    const special = wellKnownToJson(type, value, set);
+    if (special !== undefined) {
+        return special;
+    }
+    const out = {};
+    for (const [key, raw] of Object.entries(value)) {
+        const field = type.fields[key];
+        if (field === undefined) {
+            out[key] = raw;
+            continue;
+        }
+        field.resolve();
+        const nested = field.resolvedType instanceof protobuf.Type ? field.resolvedType : undefined;
+        if (field instanceof protobuf.MapField) {
+            out[key] = isRecord(raw)
+                ? Object.fromEntries(Object.entries(raw).map(([k, v]) => [k, nested === undefined ? v : toJson(set, nested, v)]))
+                : raw;
+            continue;
+        }
+        if (field.repeated) {
+            out[key] = Array.isArray(raw)
+                ? raw.map((item) => (nested === undefined ? item : toJson(set, nested, item)))
+                : raw;
+            continue;
+        }
+        out[key] = nested === undefined ? raw : toJson(set, nested, raw);
+    }
+    return out;
+}
+/**
+ * Decodes `bytes` as the message type `typeName` into canonical JSON: 64-bit integers as strings,
+ * enums by name, bytes as base64, well-known types in their string or bare forms, and fields at
+ * their default value omitted.
+ *
+ * @throws ProtoError `grpc-message-malformed` when the bytes do not decode, `proto-type-unknown`
+ */
+export function decodeMessage(set, typeName, bytes) {
+    const type = lookupMessageType(set, typeName);
+    let message;
+    try {
+        message = type.decode(bytes);
+    }
+    catch (error) {
+        throw new ProtoError('grpc-message-malformed', `The response could not be decoded as ${qualifiedName(type)}: ${error instanceof Error ? error.message : String(error)}`, { cause: error, details: { type: qualifiedName(type), bytes: bytes.byteLength } });
+    }
+    return toJson(set, type, type.toObject(message, TO_OBJECT_OPTIONS));
+}
+/**
+ * Parses the JSON text of a request body into the messages to send: one object, or — for a
+ * client-streaming method — an array of objects.
+ *
+ * @throws ProtoError `grpc-message-invalid` when the text is not JSON or has the wrong shape
+ */
+export function parseMessageText(text, streaming) {
+    let parsed;
+    try {
+        parsed = text.trim() === '' ? {} : JSON.parse(text);
+    }
+    catch (error) {
+        throw new ProtoError('grpc-message-invalid', `The message is not valid JSON: ${error instanceof Error ? error.message : String(error)}`, {
+            cause: error,
+        });
+    }
+    if (streaming) {
+        if (Array.isArray(parsed)) {
+            return parsed;
+        }
+        return [parsed];
+    }
+    if (Array.isArray(parsed)) {
+        throw new ProtoError('grpc-message-invalid', 'This method takes one message, but the body is a JSON array');
+    }
+    return [parsed];
+}

package/dist/grpc/command.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The command-line equivalent of a call, for the Code panel: what a person would type at a shell
+ * to make the same call with a command-line gRPC client that takes JSON and `.proto` files. The
+ * same value the send path uses is what is rendered, so what the panel shows is what would be sent;
+ * credentials are replaced with a stand-in unless the caller says otherwise.
+ */
+import type { GrpcSendInput } from './send.js';
+/** Options for {@link grpcToCommand}. */
+export interface GrpcToCommandOptions {
+    /** Replace secret values with a stand-in. On by default. */
+    readonly redactSecrets?: boolean;
+    /** The `.proto` files to name with `-proto`; the import root is passed as `-import-path`. */
+    readonly protoFiles?: readonly string[];
+    readonly importPath?: string;
+    readonly shell?: 'posix' | 'powershell';
+}
+/** The stand-in a redacted secret is rendered as. */
+export declare const GRPC_COMMAND_REDACTED = "<redacted>";
+/**
+ * Renders one call as a shell command. `messageText` is the request JSON, one object or an array,
+ * passed as the data argument; a client stream is what an array means to such a tool as well.
+ */
+export declare function grpcToCommand(input: Pick<GrpcSendInput, 'target' | 'tls' | 'service' | 'method' | 'metadata' | 'auth' | 'defaultMetadata' | 'timeoutMs'>, messageText: string, options?: GrpcToCommandOptions): string;