openrod 0.0.0 → 0.1.0

package/node_modules/@connectrpc/connect/dist/cjs/protocol/run-call.js

@@ -0,0 +1,125 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runUnaryCall = runUnaryCall;
+exports.runStreamingCall = runStreamingCall;
+const interceptor_js_1 = require("../interceptor.js");
+const connect_error_js_1 = require("../connect-error.js");
+const signals_js_1 = require("./signals.js");
+const normalize_js_1 = require("./normalize.js");
+const code_js_1 = require("../code.js");
+/**
+ * Runs a unary method with the given interceptors. Note that this function
+ * is only used when implementing a Transport.
+ */
+function runUnaryCall(opt) {
+    const next = (0, interceptor_js_1.applyInterceptors)(opt.next, opt.interceptors);
+    const [signal, abort, done] = setupSignal(opt);
+    const req = Object.assign(Object.assign({}, opt.req), { message: (0, normalize_js_1.normalize)(opt.req.method.input, opt.req.message), signal });
+    return next(req).then((res) => {
+        done();
+        return res;
+    }, abort);
+}
+/**
+ * Runs a server-streaming method with the given interceptors. Note that this
+ * function is only used when implementing a Transport.
+ */
+function runStreamingCall(opt) {
+    const next = (0, interceptor_js_1.applyInterceptors)(opt.next, opt.interceptors);
+    const [signal, abort, done] = setupSignal(opt);
+    const req = Object.assign(Object.assign({}, opt.req), { message: (0, normalize_js_1.normalizeIterable)(opt.req.method.input, opt.req.message), signal });
+    let doneCalled = false;
+    // Call return on the request iterable to indicate
+    // that we will no longer consume it and it should
+    // cleanup any allocated resources.
+    signal.addEventListener("abort", function () {
+        var _a, _b;
+        const it = opt.req.message[Symbol.asyncIterator]();
+        // If the signal is aborted due to an error, we want to throw
+        // the error to the request iterator.
+        if (!doneCalled) {
+            (_a = it.throw) === null || _a === void 0 ? void 0 : _a.call(it, this.reason).catch(() => {
+                // throw returns a promise, which we don't care about.
+                //
+                // Uncaught promises are thrown at sometime/somewhere by the event loop,
+                // this is to ensure error is caught and ignored.
+            });
+        }
+        (_b = it.return) === null || _b === void 0 ? void 0 : _b.call(it).catch(() => {
+            // return returns a promise, which we don't care about.
+            //
+            // Uncaught promises are thrown at sometime/somewhere by the event loop,
+            // this is to ensure error is caught and ignored.
+        });
+    });
+    return next(req).then((res) => {
+        return Object.assign(Object.assign({}, res), { message: {
+                [Symbol.asyncIterator]() {
+                    const it = res.message[Symbol.asyncIterator]();
+                    return {
+                        next() {
+                            if (!doneCalled && signal.aborted) {
+                                return abort((0, signals_js_1.getAbortSignalReason)(signal));
+                            }
+                            return it.next().then((r) => {
+                                if (r.done == true) {
+                                    doneCalled = true;
+                                    done();
+                                }
+                                return r;
+                            }, abort);
+                        },
+                        // We deliberately omit throw/return.
+                    };
+                },
+            } });
+    }, abort);
+}
+/**
+ * Create an AbortSignal for Transport implementations. The signal is available
+ * in UnaryRequest and StreamingRequest, and is triggered when the call is
+ * aborted (via a timeout or explicit cancellation), errored (e.g. when reading
+ * an error from the server from the wire), or finished successfully.
+ *
+ * Transport implementations can pass the signal to HTTP clients to ensure that
+ * there are no unused connections leak.
+ *
+ * Returns a tuple:
+ * [0]: The signal, which is also aborted if the optional deadline is reached.
+ * [1]: Function to call if the Transport encountered an error.
+ * [2]: Function to call if the Transport finished without an error.
+ */
+function setupSignal(opt) {
+    const { signal, cleanup } = (0, signals_js_1.createDeadlineSignal)(opt.timeoutMs);
+    const controller = (0, signals_js_1.createLinkedAbortController)(opt.signal, signal);
+    return [
+        controller.signal,
+        function abort(reason) {
+            // We peek at the signal because fetch() will throw an error on abort
+            // that discards the signal reason.
+            const e = controller.signal.aborted
+                ? connect_error_js_1.ConnectError.from((0, signals_js_1.getAbortSignalReason)(controller.signal), code_js_1.Code.Canceled)
+                : connect_error_js_1.ConnectError.from(reason);
+            controller.abort(e);
+            cleanup();
+            return Promise.reject(e);
+        },
+        function done() {
+            cleanup();
+            controller.abort();
+        },
+    ];
+}

package/node_modules/@connectrpc/connect/dist/cjs/protocol/serialization.d.ts

@@ -0,0 +1,104 @@
+import type { MessageShape, BinaryReadOptions, BinaryWriteOptions, DescMessage, JsonReadOptions, JsonWriteOptions, DescMethodStreaming, DescMethodUnary } from "@bufbuild/protobuf";
+/**
+ * Serialization provides methods to serialize or parse data with a certain
+ * format.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export interface Serialization<T> {
+    /**
+     * Serialize T. Raises a ConnectError with Code.Internal if an error occurs.
+     */
+    serialize: (data: T) => Uint8Array<ArrayBuffer>;
+    /**
+     * Parse T. Raises a ConnectError with Code.InvalidArgument if an error occurs.
+     */
+    parse: (data: Uint8Array) => T;
+}
+/**
+ * Sets default JSON serialization options for connect-es.
+ *
+ * With standard protobuf JSON serialization, unknown JSON fields are
+ * rejected by default. In connect-es, unknown JSON fields are ignored
+ * by default.
+ */
+export declare function getJsonOptions(options: Partial<JsonReadOptions & JsonWriteOptions> | undefined): {
+    ignoreUnknownFields?: boolean | undefined;
+    registry?: import("@bufbuild/protobuf").Registry;
+    alwaysEmitImplicit?: boolean | undefined;
+    enumAsInteger?: boolean | undefined;
+    useProtoFieldName?: boolean | undefined;
+};
+/**
+ * Create an object that provides convenient access to request and response
+ * message serialization for a given method.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function createMethodSerializationLookup<I extends DescMessage, O extends DescMessage>(method: DescMethodUnary<I, O> | DescMethodStreaming<I, O>, binaryOptions: Partial<BinaryReadOptions & BinaryWriteOptions> | undefined, jsonOptions: Partial<JsonReadOptions & JsonWriteOptions> | undefined, limitOptions: {
+    writeMaxBytes: number;
+    readMaxBytes: number;
+}): MethodSerializationLookup<I, O>;
+/**
+ * MethodSerializationLookup provides convenient access to request and response
+ * message serialization for a given method.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export interface MethodSerializationLookup<I extends DescMessage, O extends DescMessage> {
+    /**
+     * Get the JSON or binary serialization for the request message type.
+     */
+    getI(useBinaryFormat: boolean): Serialization<MessageShape<I>>;
+    /**
+     * Get the JSON or binary serialization for the response message type.
+     */
+    getO(useBinaryFormat: boolean): Serialization<MessageShape<O>>;
+}
+/**
+ * Returns functions to normalize and serialize the input message
+ * of an RPC, and to parse the output message of an RPC.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function createClientMethodSerializers<I extends DescMessage, O extends DescMessage>(method: DescMethodUnary<I, O> | DescMethodStreaming<I, O>, useBinaryFormat: boolean, jsonOptions?: JsonSerializationOptions, binaryOptions?: BinarySerializationOptions): {
+    parse: (data: Uint8Array) => MessageShape<O>;
+    serialize: (data: MessageShape<I>) => Uint8Array<ArrayBuffer>;
+};
+/**
+ * Apply I/O limits to a Serialization object, returning a new object.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function limitSerialization<T>(serialization: Serialization<T>, limitOptions: {
+    writeMaxBytes: number;
+    readMaxBytes: number;
+}): Serialization<T>;
+/**
+ * Options for createBinarySerialization()
+ */
+type BinarySerializationOptions = Partial<BinaryReadOptions & BinaryWriteOptions>;
+/**
+ * Creates a Serialization object for serializing the given protobuf message
+ * with the protobuf binary format.
+ */
+export declare function createBinarySerialization<Desc extends DescMessage>(desc: Desc, options: BinarySerializationOptions | undefined): Serialization<MessageShape<Desc>>;
+/**
+ * Options for createJsonSerialization()
+ */
+type JsonSerializationOptions = Partial<JsonReadOptions & JsonWriteOptions> & {
+    textEncoder?: {
+        encode(input?: string): Uint8Array<ArrayBuffer>;
+    };
+    textDecoder?: {
+        decode(input?: Uint8Array): string;
+    };
+};
+/**
+ * Creates a Serialization object for serializing the given protobuf message
+ * with the protobuf canonical JSON encoding.
+ *
+ * By default, unknown fields are ignored.
+ */
+export declare function createJsonSerialization<Desc extends DescMessage>(desc: Desc, options: JsonSerializationOptions | undefined): Serialization<MessageShape<Desc>>;
+export {};

package/node_modules/@connectrpc/connect/dist/cjs/protocol/serialization.js

@@ -0,0 +1,149 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJsonOptions = getJsonOptions;
+exports.createMethodSerializationLookup = createMethodSerializationLookup;
+exports.createClientMethodSerializers = createClientMethodSerializers;
+exports.limitSerialization = limitSerialization;
+exports.createBinarySerialization = createBinarySerialization;
+exports.createJsonSerialization = createJsonSerialization;
+const protobuf_1 = require("@bufbuild/protobuf");
+const connect_error_js_1 = require("../connect-error.js");
+const code_js_1 = require("../code.js");
+const limit_io_js_1 = require("./limit-io.js");
+/**
+ * Sets default JSON serialization options for connect-es.
+ *
+ * With standard protobuf JSON serialization, unknown JSON fields are
+ * rejected by default. In connect-es, unknown JSON fields are ignored
+ * by default.
+ */
+function getJsonOptions(options) {
+    var _a;
+    const o = Object.assign({}, options);
+    (_a = o.ignoreUnknownFields) !== null && _a !== void 0 ? _a : (o.ignoreUnknownFields = true);
+    return o;
+}
+/**
+ * Create an object that provides convenient access to request and response
+ * message serialization for a given method.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function createMethodSerializationLookup(method, binaryOptions, jsonOptions, limitOptions) {
+    const inputBinary = limitSerialization(createBinarySerialization(method.input, binaryOptions), limitOptions);
+    const inputJson = limitSerialization(createJsonSerialization(method.input, jsonOptions), limitOptions);
+    const outputBinary = limitSerialization(createBinarySerialization(method.output, binaryOptions), limitOptions);
+    const outputJson = limitSerialization(createJsonSerialization(method.output, jsonOptions), limitOptions);
+    return {
+        getI(useBinaryFormat) {
+            return useBinaryFormat ? inputBinary : inputJson;
+        },
+        getO(useBinaryFormat) {
+            return useBinaryFormat ? outputBinary : outputJson;
+        },
+    };
+}
+/**
+ * Returns functions to normalize and serialize the input message
+ * of an RPC, and to parse the output message of an RPC.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function createClientMethodSerializers(method, useBinaryFormat, jsonOptions, binaryOptions) {
+    const input = useBinaryFormat
+        ? createBinarySerialization(method.input, binaryOptions)
+        : createJsonSerialization(method.input, jsonOptions);
+    const output = useBinaryFormat
+        ? createBinarySerialization(method.output, binaryOptions)
+        : createJsonSerialization(method.output, jsonOptions);
+    return { parse: output.parse, serialize: input.serialize };
+}
+/**
+ * Apply I/O limits to a Serialization object, returning a new object.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function limitSerialization(serialization, limitOptions) {
+    return {
+        serialize(data) {
+            const bytes = serialization.serialize(data);
+            (0, limit_io_js_1.assertWriteMaxBytes)(limitOptions.writeMaxBytes, bytes.byteLength);
+            return bytes;
+        },
+        parse(data) {
+            (0, limit_io_js_1.assertReadMaxBytes)(limitOptions.readMaxBytes, data.byteLength, true);
+            return serialization.parse(data);
+        },
+    };
+}
+/**
+ * Creates a Serialization object for serializing the given protobuf message
+ * with the protobuf binary format.
+ */
+function createBinarySerialization(desc, options) {
+    return {
+        parse(data) {
+            try {
+                return (0, protobuf_1.fromBinary)(desc, data, options);
+            }
+            catch (e) {
+                const m = e instanceof Error ? e.message : String(e);
+                throw new connect_error_js_1.ConnectError(`parse binary: ${m}`, code_js_1.Code.Internal);
+            }
+        },
+        serialize(data) {
+            try {
+                return (0, protobuf_1.toBinary)(desc, data, options);
+            }
+            catch (e) {
+                const m = e instanceof Error ? e.message : String(e);
+                throw new connect_error_js_1.ConnectError(`serialize binary: ${m}`, code_js_1.Code.Internal);
+            }
+        },
+    };
+}
+/**
+ * Creates a Serialization object for serializing the given protobuf message
+ * with the protobuf canonical JSON encoding.
+ *
+ * By default, unknown fields are ignored.
+ */
+function createJsonSerialization(desc, options) {
+    var _a, _b;
+    const textEncoder = (_a = options === null || options === void 0 ? void 0 : options.textEncoder) !== null && _a !== void 0 ? _a : new TextEncoder();
+    const textDecoder = (_b = options === null || options === void 0 ? void 0 : options.textDecoder) !== null && _b !== void 0 ? _b : new TextDecoder();
+    const o = getJsonOptions(options);
+    return {
+        parse(data) {
+            try {
+                const json = textDecoder.decode(data);
+                return (0, protobuf_1.fromJsonString)(desc, json, o);
+            }
+            catch (e) {
+                throw connect_error_js_1.ConnectError.from(e, code_js_1.Code.InvalidArgument);
+            }
+        },
+        serialize(data) {
+            try {
+                const json = (0, protobuf_1.toJsonString)(desc, data, o);
+                return textEncoder.encode(json);
+            }
+            catch (e) {
+                throw connect_error_js_1.ConnectError.from(e, code_js_1.Code.Internal);
+            }
+        },
+    };
+}

package/node_modules/@connectrpc/connect/dist/cjs/protocol/signals.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Create an AbortController that is automatically aborted if one of the given
+ * signals is aborted.
+ *
+ * For convenience, the linked AbortSignals can be undefined.
+ *
+ * If the controller or any of the signals is aborted, all event listeners are
+ * removed.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function createLinkedAbortController(...signals: (AbortSignal | undefined)[]): AbortController;
+/**
+ * Create a deadline signal. The returned object contains an AbortSignal, but
+ * also a cleanup function to stop the timer, which must be called once the
+ * calling code is no longer interested in the signal.
+ *
+ * Ideally, we would simply use AbortSignal.timeout(), but it is not widely
+ * available yet.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function createDeadlineSignal(timeoutMs: number | undefined): {
+    signal: AbortSignal;
+    cleanup: () => void;
+};
+/**
+ * Returns the reason why an AbortSignal was aborted. Returns undefined if the
+ * signal has not been aborted.
+ *
+ * The property AbortSignal.reason is not widely available. This function
+ * returns an AbortError if the signal is aborted, but reason is undefined.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function getAbortSignalReason(signal: AbortSignal): unknown;

package/node_modules/@connectrpc/connect/dist/cjs/protocol/signals.js

@@ -0,0 +1,100 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLinkedAbortController = createLinkedAbortController;
+exports.createDeadlineSignal = createDeadlineSignal;
+exports.getAbortSignalReason = getAbortSignalReason;
+const connect_error_js_1 = require("../connect-error.js");
+const code_js_1 = require("../code.js");
+/**
+ * Create an AbortController that is automatically aborted if one of the given
+ * signals is aborted.
+ *
+ * For convenience, the linked AbortSignals can be undefined.
+ *
+ * If the controller or any of the signals is aborted, all event listeners are
+ * removed.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function createLinkedAbortController(...signals) {
+    const controller = new AbortController();
+    const sa = signals.filter((s) => s !== undefined).concat(controller.signal);
+    for (const signal of sa) {
+        if (signal.aborted) {
+            onAbort.apply(signal);
+            break;
+        }
+        signal.addEventListener("abort", onAbort);
+    }
+    function onAbort() {
+        if (!controller.signal.aborted) {
+            controller.abort(getAbortSignalReason(this));
+        }
+        for (const signal of sa) {
+            signal.removeEventListener("abort", onAbort);
+        }
+    }
+    return controller;
+}
+/**
+ * Create a deadline signal. The returned object contains an AbortSignal, but
+ * also a cleanup function to stop the timer, which must be called once the
+ * calling code is no longer interested in the signal.
+ *
+ * Ideally, we would simply use AbortSignal.timeout(), but it is not widely
+ * available yet.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function createDeadlineSignal(timeoutMs) {
+    const controller = new AbortController();
+    const listener = () => {
+        controller.abort(new connect_error_js_1.ConnectError("the operation timed out", code_js_1.Code.DeadlineExceeded));
+    };
+    let timeoutId;
+    if (timeoutMs !== undefined) {
+        if (timeoutMs <= 0)
+            listener();
+        else
+            timeoutId = setTimeout(listener, timeoutMs);
+    }
+    return {
+        signal: controller.signal,
+        cleanup: () => clearTimeout(timeoutId),
+    };
+}
+/**
+ * Returns the reason why an AbortSignal was aborted. Returns undefined if the
+ * signal has not been aborted.
+ *
+ * The property AbortSignal.reason is not widely available. This function
+ * returns an AbortError if the signal is aborted, but reason is undefined.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function getAbortSignalReason(signal) {
+    if (!signal.aborted) {
+        return undefined;
+    }
+    if (signal.reason !== undefined) {
+        return signal.reason;
+    }
+    // AbortSignal.reason is available in Node.js v16, v18, and later,
+    // and in all browsers since early 2022.
+    const e = new Error("This operation was aborted");
+    e.name = "AbortError";
+    return e;
+}

package/node_modules/@connectrpc/connect/dist/cjs/protocol/transport-options.d.ts

@@ -0,0 +1,98 @@
+import type { BinaryReadOptions, BinaryWriteOptions, JsonReadOptions, JsonWriteOptions } from "@bufbuild/protobuf";
+import type { UniversalClientFn } from "./universal.js";
+import type { Interceptor } from "../interceptor.js";
+import type { Compression } from "./compression.js";
+/**
+ * @private Internal code, does not follow semantic versioning.
+ */
+export interface CommonTransportOptions {
+    /**
+     * The HTTP client to use.
+     */
+    httpClient: UniversalClientFn;
+    /**
+     * 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 | null;
+    /**
+     * 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;
+    /**
+     * Controls whether or not Connect GET requests should be used when
+     * available, on side-effect free methods. Defaults to false.
+     */
+    useHttpGet?: boolean;
+    /**
+     * The timeout in milliseconds to apply to all requests.
+     *
+     * This can be overridden on a per-request basis by passing a timeoutMs.
+     */
+    defaultTimeoutMs?: number;
+}

package/node_modules/@connectrpc/connect/dist/cjs/protocol/transport-options.js

@@ -0,0 +1,15 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });

package/node_modules/@connectrpc/connect/dist/cjs/protocol/universal-fetch.d.ts

@@ -0,0 +1,35 @@
+import type { UniversalClientFn, UniversalClientRequest, UniversalClientResponse, UniversalHandlerFn, UniversalServerRequest, UniversalServerResponse } from "./universal.js";
+/**
+ * Create a universal client function, a minimal abstraction of an HTTP client,
+ * using the given fetch() implementation.
+ */
+export declare function createFetchClient(fetchFn: typeof fetch): UniversalClientFn;
+/**
+ * FetchHandlerFn is a minimal abstraction of an HTTP handler with the fetch API
+ * Request and Response types.
+ */
+type FetchHandlerFn = (req: Request) => Promise<Response>;
+interface FetchHandlerOptions {
+    httpVersion?: string;
+}
+/**
+ * Convert a universal handler function to a fetch handler.
+ */
+export declare function createFetchHandler(uHandler: UniversalHandlerFn, options?: FetchHandlerOptions): FetchHandlerFn;
+/**
+ * Convert a universal client request to a fetch request.
+ */
+export declare function universalClientRequestToFetch(req: UniversalClientRequest): Request;
+/**
+ * Convert a fetch response to a universal client response.
+ */
+export declare function universalClientResponseFromFetch(res: Response): UniversalClientResponse;
+/**
+ * Convert a fetch request to a universal server request.
+ */
+export declare function universalServerRequestFromFetch(req: Request, options: FetchHandlerOptions): UniversalServerRequest;
+/**
+ * Convert a universal server response to a fetch response.
+ */
+export declare function universalServerResponseToFetch(res: UniversalServerResponse): Response;
+export {};