openrod 0.0.0 → 0.1.0

package/node_modules/@connectrpc/connect/dist/esm/cors.d.ts

@@ -0,0 +1,45 @@
+/**
+ * CORS prevents rogue scripts in a web browser from making arbitrary requests
+ * to other web servers.
+ *
+ * This object provides helpful constants to configure CORS middleware for
+ * cross-domain requests with the protocols supported by Connect.
+ *
+ * Make sure to add application-specific headers that your application
+ * uses as well.
+ */
+export declare const cors: {
+    /**
+     * Request methods that scripts running in the browser are permitted to use.
+     *
+     * To support cross-domain requests with the protocols supported by Connect,
+     * these headers fields must be included in the preflight response header
+     * Access-Control-Allow-Methods.
+     */
+    allowedMethods: ReadonlyArray<string>;
+    /**
+     * Header fields that scripts running in the browser are permitted to send.
+     *
+     * To support cross-domain requests with the protocols supported by Connect,
+     * these field names must be included in the preflight response header
+     * Access-Control-Allow-Headers.
+     *
+     * Make sure to include any application-specific headers your browser client
+     * may send.
+     */
+    allowedHeaders: ReadonlyArray<string>;
+    /**
+     * Header fields that scripts running the browser are permitted to see.
+     *
+     * To support cross-domain requests with the protocols supported by Connect,
+     * these field names must be included in header Access-Control-Expose-Headers
+     * of the actual response.
+     *
+     * Make sure to include any application-specific headers your browser client
+     * should see. If your application uses trailers, they will be sent as header
+     * fields with a `Trailer-` prefix for Connect unary RPCs - make sure to
+     * expose them as well if you want them to be visible in all supported
+     * protocols.
+     */
+    exposedHeaders: ReadonlyArray<string>;
+};

package/node_modules/@connectrpc/connect/dist/esm/cors.js

@@ -0,0 +1,79 @@
+// Copyright 2021-2026 The Connect Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import * as connect from "./protocol-connect/headers.js";
+import * as grpc from "./protocol-grpc/headers.js";
+import * as grpcWeb from "./protocol-grpc-web/headers.js";
+/**
+ * CORS prevents rogue scripts in a web browser from making arbitrary requests
+ * to other web servers.
+ *
+ * This object provides helpful constants to configure CORS middleware for
+ * cross-domain requests with the protocols supported by Connect.
+ *
+ * Make sure to add application-specific headers that your application
+ * uses as well.
+ */
+export const cors = {
+    /**
+     * Request methods that scripts running in the browser are permitted to use.
+     *
+     * To support cross-domain requests with the protocols supported by Connect,
+     * these headers fields must be included in the preflight response header
+     * Access-Control-Allow-Methods.
+     */
+    allowedMethods: ["POST", "GET"],
+    /**
+     * Header fields that scripts running in the browser are permitted to send.
+     *
+     * To support cross-domain requests with the protocols supported by Connect,
+     * these field names must be included in the preflight response header
+     * Access-Control-Allow-Headers.
+     *
+     * Make sure to include any application-specific headers your browser client
+     * may send.
+     */
+    allowedHeaders: [
+        connect.headerContentType,
+        connect.headerProtocolVersion,
+        connect.headerTimeout,
+        connect.headerStreamEncoding, // Unused in web browsers, but added for future-proofing
+        connect.headerStreamAcceptEncoding, // Unused in web browsers, but added for future-proofing
+        connect.headerUnaryEncoding, // Unused in web browsers, but added for future-proofing
+        connect.headerUnaryAcceptEncoding, // Unused in web browsers, but added for future-proofing
+        grpc.headerMessageType, // Unused in web browsers, but added for future-proofing
+        grpcWeb.headerXGrpcWeb,
+        grpcWeb.headerXUserAgent,
+        grpcWeb.headerTimeout,
+    ],
+    /**
+     * Header fields that scripts running the browser are permitted to see.
+     *
+     * To support cross-domain requests with the protocols supported by Connect,
+     * these field names must be included in header Access-Control-Expose-Headers
+     * of the actual response.
+     *
+     * Make sure to include any application-specific headers your browser client
+     * should see. If your application uses trailers, they will be sent as header
+     * fields with a `Trailer-` prefix for Connect unary RPCs - make sure to
+     * expose them as well if you want them to be visible in all supported
+     * protocols.
+     */
+    exposedHeaders: [
+        grpcWeb.headerGrpcStatus, // Crucial for gRPC-web
+        grpcWeb.headerGrpcMessage, // Crucial for gRPC-web
+        grpcWeb.headerStatusDetailsBin, // Error details in gRPC, gRPC-web
+        connect.headerUnaryEncoding, // Unused in web browsers, but added for future-proofing
+        connect.headerStreamEncoding, // Unused in web browsers, but added for future-proofing
+    ],
+};

package/node_modules/@connectrpc/connect/dist/esm/http-headers.d.ts

@@ -0,0 +1,37 @@
+import type { BinaryReadOptions, DescMessage, Message, MessageShape } from "@bufbuild/protobuf";
+/**
+ * Encode a single binary header value according to the Connect
+ * and gRPC specifications.
+ *
+ * This function accepts raw binary data from a buffer, a string
+ * with UTF-8 text, or a protobuf message. It encodes the input
+ * with unpadded base64 and returns a string that can be used for
+ * a header whose name ends with `-bin`.
+ */
+export declare function encodeBinaryHeader(value: Message, desc: DescMessage): string;
+export declare function encodeBinaryHeader(value: Uint8Array | ArrayBufferLike | string): string;
+/**
+ * Decode a single binary header value according to the Connect
+ * and gRPC specifications.
+ *
+ * This function returns the raw binary data from a header whose
+ * name ends with `-bin`. If given a message type in the second
+ * argument, it deserializes a protobuf message. To decode a value
+ * that contains unicode text, pass the raw binary data returned
+ * from this function through TextDecoder.decode.
+ *
+ * Note that duplicate header names may have their values joined
+ * with a `,` as the delimiter, so you most likely will want to
+ * split by `,` first.
+ *
+ * If this function detects invalid base-64 encoding, or invalid
+ * binary message data, it throws a ConnectError with code
+ * DataLoss.
+ */
+export declare function decodeBinaryHeader(value: string): Uint8Array;
+export declare function decodeBinaryHeader<Desc extends DescMessage>(value: string, type: Desc, options?: Partial<BinaryReadOptions>): MessageShape<Desc>;
+/**
+ * Merge two or more Headers objects by appending all fields from
+ * all inputs to a new Headers object.
+ */
+export declare function appendHeaders(...headers: Headers[]): Headers;

package/node_modules/@connectrpc/connect/dist/esm/http-headers.js

@@ -0,0 +1,58 @@
+// Copyright 2021-2026 The Connect Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { fromBinary, toBinary } from "@bufbuild/protobuf";
+import { base64Encode, base64Decode } from "@bufbuild/protobuf/wire";
+import { ConnectError } from "./connect-error.js";
+import { Code } from "./code.js";
+export function encodeBinaryHeader(value, desc) {
+    let bytes;
+    if (desc !== undefined) {
+        bytes = toBinary(desc, value);
+    }
+    else if (typeof value == "string") {
+        bytes = new TextEncoder().encode(value);
+    }
+    else {
+        bytes =
+            value instanceof Uint8Array
+                ? value
+                : new Uint8Array(value);
+    }
+    return base64Encode(bytes, "std_raw");
+}
+export function decodeBinaryHeader(value, desc, options) {
+    try {
+        const bytes = base64Decode(value);
+        if (desc) {
+            return fromBinary(desc, bytes, options);
+        }
+        return bytes;
+    }
+    catch (e) {
+        throw ConnectError.from(e, Code.DataLoss);
+    }
+}
+/**
+ * Merge two or more Headers objects by appending all fields from
+ * all inputs to a new Headers object.
+ */
+export function appendHeaders(...headers) {
+    const h = new Headers();
+    for (const e of headers) {
+        e.forEach((value, key) => {
+            h.append(key, value);
+        });
+    }
+    return h;
+}

package/node_modules/@connectrpc/connect/dist/esm/implementation.d.ts

@@ -0,0 +1,159 @@
+import type { MessageInitShape, DescMessage, DescService, DescMethod, MessageShape, DescMethodBiDiStreaming, DescMethodClientStreaming, DescMethodServerStreaming, DescMethodUnary } from "@bufbuild/protobuf";
+import type { ContextValues } from "./context-values.js";
+/**
+ * ServiceImpl is the interface of the implementation of a service.
+ */
+export type ServiceImpl<Desc extends DescService> = {
+    [P in keyof Desc["method"]]: MethodImpl<Desc["method"][P]>;
+};
+/**
+ * MethodImpl is the signature of the implementation of an RPC.
+ */
+export type MethodImpl<M extends DescMethod> = M extends DescMethodUnary<infer I, infer O> ? UnaryImpl<I, O> : M extends DescMethodServerStreaming<infer I, infer O> ? ServerStreamingImpl<I, O> : M extends DescMethodClientStreaming<infer I, infer O> ? ClientStreamingImpl<I, O> : M extends DescMethodBiDiStreaming<infer I, infer O> ? BiDiStreamingImpl<I, O> : never;
+/**
+ * Context for an RPC on the server. Every RPC implementation can accept a
+ * HandlerContext as an argument to gain access to headers and service metadata.
+ */
+export interface HandlerContext {
+    /**
+     * Metadata for the method being called.
+     */
+    readonly method: DescMethod;
+    /**
+     * Metadata for the service being called.
+     */
+    readonly service: DescService;
+    /**
+     * An AbortSignal that triggers when the deadline is reached, or when an error
+     * occurs that aborts processing of the request, but also when the RPC is
+     * completed without error.
+     *
+     * The signal can be used to automatically cancel downstream calls.
+     */
+    readonly signal: AbortSignal;
+    /**
+     * If the current request has a timeout, this function returns the remaining
+     * time.
+     */
+    readonly timeoutMs: () => number | undefined;
+    /**
+     * HTTP method of incoming request, usually "POST", but "GET" in the case of
+     * Connect Get.
+     */
+    readonly requestMethod: string;
+    /**
+     * Incoming request headers.
+     */
+    readonly requestHeader: Headers;
+    /**
+     * Outgoing response headers.
+     *
+     * For methods that return a stream, response headers must be set before
+     * yielding the first response message.
+     */
+    readonly responseHeader: Headers;
+    /**
+     * Outgoing response trailers.
+     */
+    readonly responseTrailer: Headers;
+    /**
+     * Name of the RPC protocol in use; one of "connect", "grpc" or "grpc-web".
+     */
+    readonly protocolName: string;
+    /**
+     * Per RPC context values that can be used to pass data to handlers.
+     */
+    readonly values: ContextValues;
+    /**
+     * The URL received by the server.
+     */
+    readonly url: string;
+}
+/**
+ * Options for creating a HandlerContext.
+ */
+interface HandlerContextInit {
+    service: DescService;
+    method: DescMethod;
+    protocolName: string;
+    requestMethod: string;
+    url: string;
+    timeoutMs?: number;
+    shutdownSignal?: AbortSignal;
+    requestSignal?: AbortSignal;
+    requestHeader?: HeadersInit;
+    responseHeader?: HeadersInit;
+    responseTrailer?: HeadersInit;
+    contextValues?: ContextValues;
+}
+interface HandlerContextController extends HandlerContext {
+    abort(reason?: unknown): void;
+}
+/**
+ * Create a new HandlerContext.
+ *
+ * The context is usually automatically created by handlers, but if a service
+ * implementation is used in unit tests, this function can be used to create
+ * a context.
+ */
+export declare function createHandlerContext(init: HandlerContextInit): HandlerContextController;
+/**
+ * UnaryImpl is the signature of the implementation of a unary RPC.
+ */
+export type UnaryImpl<I extends DescMessage, O extends DescMessage> = (request: MessageShape<I>, context: HandlerContext) => Promise<MessageInitShape<O>> | MessageInitShape<O>;
+/**
+ * ClientStreamingImpl is the signature of the implementation of a
+ * client-streaming RPC.
+ */
+export type ClientStreamingImpl<I extends DescMessage, O extends DescMessage> = (requests: AsyncIterable<MessageShape<I>>, context: HandlerContext) => Promise<MessageInitShape<O>>;
+/**
+ * ServerStreamingImpl is the signature of the implementation of a
+ * server-streaming RPC.
+ */
+export type ServerStreamingImpl<I extends DescMessage, O extends DescMessage> = (request: MessageShape<I>, context: HandlerContext) => AsyncIterable<MessageInitShape<O>>;
+/**
+ * BiDiStreamingImpl is the signature of the implementation of a bi-di
+ * streaming RPC.
+ */
+export type BiDiStreamingImpl<I extends DescMessage, O extends DescMessage> = (requests: AsyncIterable<MessageShape<I>>, context: HandlerContext) => AsyncIterable<MessageInitShape<O>>;
+/**
+ * Wraps a user-provided implementation along with service and method
+ * metadata in a discriminated union type.
+ */
+export type MethodImplSpec<I extends DescMessage = DescMessage, O extends DescMessage = DescMessage> = {
+    kind: "unary";
+    impl: UnaryImpl<I, O>;
+    method: DescMethodUnary<I, O>;
+} | {
+    kind: "server_streaming";
+    impl: ServerStreamingImpl<I, O>;
+    method: DescMethodServerStreaming<I, O>;
+} | {
+    kind: "client_streaming";
+    impl: ClientStreamingImpl<I, O>;
+    method: DescMethodClientStreaming<I, O>;
+} | {
+    kind: "bidi_streaming";
+    impl: BiDiStreamingImpl<I, O>;
+    method: DescMethodBiDiStreaming<I, O>;
+};
+/**
+ * Wraps a user-provided service implementation and provides metadata.
+ */
+export type ServiceImplSpec = {
+    service: DescService;
+    methods: {
+        [key: string]: MethodImplSpec;
+    };
+};
+/**
+ * Create an MethodImplSpec - a user-provided implementation for a method,
+ * wrapped in a discriminated union type along with service and method metadata.
+ */
+export declare function createMethodImplSpec<M extends DescMethod>(method: M, impl: MethodImpl<M>): MethodImplSpec;
+/**
+ * Create an ServiceImplSpec - a user-provided service implementation wrapped
+ * with metadata.
+ */
+export declare function createServiceImplSpec<Desc extends DescService>(service: DescService, impl: Partial<ServiceImpl<Desc>>): ServiceImplSpec;
+export {};

package/node_modules/@connectrpc/connect/dist/esm/implementation.js

@@ -0,0 +1,73 @@
+// Copyright 2021-2026 The Connect Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { ConnectError } from "./connect-error.js";
+import { Code } from "./code.js";
+import { createDeadlineSignal, createLinkedAbortController, } from "./protocol/signals.js";
+import { createContextValues } from "./context-values.js";
+/**
+ * Create a new HandlerContext.
+ *
+ * The context is usually automatically created by handlers, but if a service
+ * implementation is used in unit tests, this function can be used to create
+ * a context.
+ */
+export function createHandlerContext(init) {
+    var _a;
+    let timeoutMs;
+    if (init.timeoutMs !== undefined) {
+        const date = new Date(Date.now() + init.timeoutMs);
+        timeoutMs = () => date.getTime() - Date.now();
+    }
+    else {
+        timeoutMs = () => undefined;
+    }
+    const deadline = createDeadlineSignal(init.timeoutMs);
+    const abortController = createLinkedAbortController(deadline.signal, init.requestSignal, init.shutdownSignal);
+    return Object.assign(Object.assign({}, init), { signal: abortController.signal, timeoutMs, requestHeader: new Headers(init.requestHeader), responseHeader: new Headers(init.responseHeader), responseTrailer: new Headers(init.responseTrailer), abort(reason) {
+            deadline.cleanup();
+            abortController.abort(reason);
+        }, values: (_a = init.contextValues) !== null && _a !== void 0 ? _a : createContextValues() });
+}
+/**
+ * Create an MethodImplSpec - a user-provided implementation for a method,
+ * wrapped in a discriminated union type along with service and method metadata.
+ */
+export function createMethodImplSpec(method, impl) {
+    return {
+        kind: method.methodKind,
+        method,
+        impl,
+    };
+}
+/**
+ * Create an ServiceImplSpec - a user-provided service implementation wrapped
+ * with metadata.
+ */
+export function createServiceImplSpec(service, impl) {
+    const s = { service, methods: {} };
+    for (const method of service.methods) {
+        let fn = impl[method.localName];
+        if (typeof fn == "function") {
+            fn = fn.bind(impl);
+        }
+        else {
+            const message = `${service.typeName}.${method.name} is not implemented`;
+            fn = function unimplemented() {
+                throw new ConnectError(message, Code.Unimplemented);
+            };
+        }
+        s.methods[method.localName] = createMethodImplSpec(method, fn);
+    }
+    return s;
+}

package/node_modules/@connectrpc/connect/dist/esm/index.d.ts

@@ -0,0 +1,22 @@
+export { ConnectError } from "./connect-error.js";
+export { Code } from "./code.js";
+export { encodeBinaryHeader, decodeBinaryHeader, appendHeaders, } from "./http-headers.js";
+export { createCallbackClient } from "./callback-client.js";
+export type { CallbackClient } from "./callback-client.js";
+export { createClient } from "./promise-client.js";
+export type { Client } from "./promise-client.js";
+export type { CallOptions } from "./call-options.js";
+export type { Transport } from "./transport.js";
+export type { Interceptor, UnaryRequest, UnaryResponse, StreamRequest, StreamResponse, } from "./interceptor.js";
+export type { ServiceImpl, MethodImpl, HandlerContext, } from "./implementation.js";
+export { createConnectRouter } from "./router.js";
+export type { ConnectRouter, ConnectRouterOptions } from "./router.js";
+export { createHandlerContext } from "./implementation.js";
+export { cors } from "./cors.js";
+export { createContextKey, createContextValues } from "./context-values.js";
+export type { ContextKey, ContextValues } from "./context-values.js";
+export { makeAnyClient } from "./any-client.js";
+export type { AnyClient } from "./any-client.js";
+export { createServiceImplSpec, createMethodImplSpec, } from "./implementation.js";
+export type { ServiceImplSpec, MethodImplSpec } from "./implementation.js";
+export { createRouterTransport } from "./router-transport.js";

package/node_modules/@connectrpc/connect/dist/esm/index.js

@@ -0,0 +1,27 @@
+// Copyright 2021-2026 The Connect Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+export { ConnectError } from "./connect-error.js";
+export { Code } from "./code.js";
+export { encodeBinaryHeader, decodeBinaryHeader, appendHeaders, } from "./http-headers.js";
+export { createCallbackClient } from "./callback-client.js";
+export { createClient } from "./promise-client.js";
+export { createConnectRouter } from "./router.js";
+export { createHandlerContext } from "./implementation.js";
+export { cors } from "./cors.js";
+export { createContextKey, createContextValues } from "./context-values.js";
+// Symbols above should be relevant to end users.
+// Symbols below should only be relevant for other libraries.
+export { makeAnyClient } from "./any-client.js";
+export { createServiceImplSpec, createMethodImplSpec, } from "./implementation.js";
+export { createRouterTransport } from "./router-transport.js";

package/node_modules/@connectrpc/connect/dist/esm/interceptor.d.ts

@@ -0,0 +1,170 @@
+import type { DescMessage, DescService, MessageShape, DescMethodStreaming, DescMethodUnary } from "@bufbuild/protobuf";
+import type { ContextValues } from "./context-values.js";
+/**
+ * An interceptor can add logic to clients or servers, similar to the decorators
+ * or middleware you may have seen in other libraries. Interceptors may
+ * mutate the request and response, catch errors and retry/recover, emit
+ * logs, or do nearly everything else.
+ *
+ * For a simple example, the following interceptor logs all requests:
+ *
+ * ```ts
+ * const logger: Interceptor = (next) => async (req) => {
+ *   console.log(`sending message to ${req.url}`);
+ *   return await next(req);
+ * };
+ * ```
+ *
+ * You can think of interceptors like a layered onion. A request initiated
+ * by a client goes through the outermost layer first. In the center, the
+ * actual HTTP request is run by the transport. The response then comes back
+ * through all layers and is returned to the client.
+ *
+ * Similarly, a request received by a server goes through the outermost layer
+ * first. In the center, the actual HTTP request is received by the handler. The
+ * response then comes back through all layers and is returned to the client.
+ *
+ * To implement that layering, Interceptors are functions that wrap a call
+ * invocation. In an array of interceptors, the interceptor at the end of
+ * the array is applied first.
+ */
+export type Interceptor = (next: AnyFn) => AnyFn;
+/**
+ * AnyFn represents the client-side invocation of an RPC. Interceptors can wrap
+ * this invocation, add request headers, and wrap parts of the request or
+ * response to inspect and log.
+ */
+type AnyFn = (req: UnaryRequest | StreamRequest) => Promise<UnaryResponse | StreamResponse>;
+/**
+ * UnaryRequest is used in interceptors to represent a request with a
+ * single input message.
+ */
+export interface UnaryRequest<I extends DescMessage = DescMessage, O extends DescMessage = DescMessage> extends RequestCommon {
+    /**
+     * The `stream` property discriminates between UnaryRequest and
+     * StreamingRequest.
+     */
+    readonly stream: false;
+    /**
+     * The input message that will be transmitted.
+     */
+    readonly message: MessageShape<I>;
+    /**
+     * Metadata related to the service method that is being called.
+     */
+    readonly method: DescMethodUnary<I, O>;
+}
+/**
+ * UnaryResponse is used in interceptors to represent a response with
+ * a single output message.
+ */
+export interface UnaryResponse<I extends DescMessage = DescMessage, O extends DescMessage = DescMessage> extends ResponseCommon {
+    /**
+     * The `stream` property discriminates between UnaryResponse and
+     * StreamingConn.
+     */
+    readonly stream: false;
+    /**
+     * The received output message.
+     */
+    readonly message: MessageShape<O>;
+    /**
+     * Metadata related to the service method that is being called.
+     */
+    readonly method: DescMethodUnary<I, O>;
+}
+/**
+ * StreamRequest is used in interceptors to represent a request that has
+ * zero or more input messages, and zero or more output messages.
+ */
+export interface StreamRequest<I extends DescMessage = DescMessage, O extends DescMessage = DescMessage> extends RequestCommon {
+    /**
+     * The `stream` property discriminates between UnaryRequest and
+     * StreamingRequest.
+     */
+    readonly stream: true;
+    /**
+     * The input messages that will be transmitted.
+     */
+    readonly message: AsyncIterable<MessageShape<I>>;
+    /**
+     * Metadata related to the service method that is being called.
+     */
+    readonly method: DescMethodStreaming<I, O>;
+}
+/**
+ * StreamResponse is used in interceptors to represent an ongoing call that has
+ * zero or more input messages, and zero or more output messages.
+ */
+export interface StreamResponse<I extends DescMessage = DescMessage, O extends DescMessage = DescMessage> extends ResponseCommon {
+    /**
+     * The `stream` property discriminates between UnaryResponse and
+     * StreamingConn.
+     */
+    readonly stream: true;
+    /**
+     * The output messages.
+     */
+    readonly message: AsyncIterable<MessageShape<O>>;
+    /**
+     * Metadata related to the service method that is being called.
+     */
+    readonly method: DescMethodStreaming<I, O>;
+}
+/**
+ * @private
+ */
+export interface RequestCommon {
+    /**
+     * Metadata related to the service that is being called.
+     */
+    readonly service: DescService;
+    /**
+     * HTTP method of the request. Server-side interceptors may use this value
+     * to identify Connect GET requests.
+     */
+    readonly requestMethod: string;
+    /**
+     * The URL the request is going to hit for the clients or the
+     * URL received by the server.
+     */
+    readonly url: string;
+    /**
+     * The AbortSignal for the current call.
+     */
+    readonly signal: AbortSignal;
+    /**
+     * Headers that will be sent along with the request.
+     */
+    readonly header: Headers;
+    /**
+     * The context values for the current call.
+     */
+    readonly contextValues: ContextValues;
+}
+/**
+ * @private
+ */
+export interface ResponseCommon {
+    /**
+     * Metadata related to the service that is being called.
+     */
+    readonly service: DescService;
+    /**
+     * Headers received from the response.
+     */
+    readonly header: Headers;
+    /**
+     * Trailers received from the response.
+     * Note that trailers are only populated when the entirety of the response
+     * has been read.
+     */
+    readonly trailer: Headers;
+}
+/**
+ * applyInterceptors takes the given UnaryFn or ServerStreamingFn, and wraps
+ * it with each of the given interceptors, returning a new UnaryFn or
+ * ServerStreamingFn.
+ */
+export declare function applyInterceptors<T>(next: T, interceptors: Interceptor[] | undefined): T;
+export {};