@connectrpc/connect-node/dist/cjs/grpc-web-transport.d.ts

Connect is a family of libraries for building and consuming APIs on different languages and platforms, and [@connectrpc/connect](https://www.npmjs.com/package/@connectrpc/connect) brings type-safe APIs with Protobuf to TypeScript.

import type { Interceptor, Transport } from "@connectrpc/connect";
import type { Compression } from "@connectrpc/connect/protocol";
import type { BinaryReadOptions, BinaryWriteOptions, JsonReadOptions, JsonWriteOptions } from "@bufbuild/protobuf";
import { type NodeTransportOptions } from "./node-transport-options.js";
/**
 * Options used to configure the gRPC-web transport.
 *
 * See createGrpcWebTransport().
 */
export type GrpcWebTransportOptions = NodeTransportOptions & {
    /**
     * Base URI for all HTTP requests.
     *
     * Requests will be made to <baseUrl>/<package>.<service>/method
     *
     * Example: `baseUrl: "https://example.com/my-api"`
     *
     * This will make a `POST /my-api/my_package.MyService/Foo` to
     * `example.com` via HTTPS.
     */
    baseUrl: string;
    /**
     * By default, clients use the binary format for gRPC-web, because
     * not all gRPC-web implementations support JSON.
     */
    useBinaryFormat?: boolean;
    /**
     * Interceptors that should be applied to all calls running through
     * this transport. See the Interceptor type for details.
     */
    interceptors?: Interceptor[];
    /**
     * Options for the JSON format.
     * By default, unknown fields are ignored.
     */
    jsonOptions?: Partial<JsonReadOptions & JsonWriteOptions>;
    /**
     * Options for the binary wire format.
     */
    binaryOptions?: Partial<BinaryReadOptions & BinaryWriteOptions>;
    /**
     * Compression algorithms available to a client. Clients ask servers to
     * compress responses using any of the registered algorithms. The first
     * registered algorithm is the most preferred.
     *
     * It is safe to use this option liberally: servers will ignore any
     * compression algorithms they don't support. To compress requests, pair this
     * option with `sendCompression`.
     *
     * If this option is not provided, the compression algorithms "gzip" and "br"
     * (Brotli) are accepted. To opt out of response compression, pass an
     * empty array.
     */
    acceptCompression?: Compression[];
    /**
     * Configures the client to use the specified algorithm to compress request
     * messages.
     *
     * Because some servers don't support compression, clients default to sending
     * uncompressed requests.
     */
    sendCompression?: Compression;
    /**
     * Sets a minimum size threshold for compression: Messages that are smaller
     * than the configured minimum are sent uncompressed.
     *
     * The default value is 1 kibibyte, because the CPU cost of compressing very
     * small messages usually isn't worth the small reduction in network I/O.
     */
    compressMinBytes?: number;
    /**
     * Limits the performance impact of pathologically large messages sent by the
     * server. Limits apply to each individual message, not to the stream as a
     * whole.
     *
     * The default limit is the maximum supported value of ~4GiB.
     */
    readMaxBytes?: number;
    /**
     * Prevents sending messages too large for the server to handle.
     *
     * The default limit is the maximum supported value of ~4GiB.
     */
    writeMaxBytes?: number;
    /**
     * The timeout in milliseconds to apply to all requests.
     *
     * This can be overridden on a per-request basis by passing a timeoutMs.
     */
    defaultTimeoutMs?: number;
};
/**
 * Create a Transport for the gRPC-web protocol using the Node.js `http`,
 * `https`, or `http2` module.
 */
export declare function createGrpcWebTransport(options: GrpcWebTransportOptions): Transport;