openrod 0.0.0 → 0.1.0

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

@@ -0,0 +1,150 @@
+"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.createFetchClient = createFetchClient;
+exports.createFetchHandler = createFetchHandler;
+exports.universalClientRequestToFetch = universalClientRequestToFetch;
+exports.universalClientResponseFromFetch = universalClientResponseFromFetch;
+exports.universalServerRequestFromFetch = universalServerRequestFromFetch;
+exports.universalServerResponseToFetch = universalServerResponseToFetch;
+/**
+ * Create a universal client function, a minimal abstraction of an HTTP client,
+ * using the given fetch() implementation.
+ */
+function createFetchClient(fetchFn) {
+    return async function fetchClient(request) {
+        const res = await fetchFn(universalClientRequestToFetch(request));
+        return universalClientResponseFromFetch(res);
+    };
+}
+/**
+ * Convert a universal handler function to a fetch handler.
+ */
+function createFetchHandler(uHandler, options) {
+    async function handleFetch(req) {
+        const uReq = universalServerRequestFromFetch(req, options !== null && options !== void 0 ? options : {});
+        const uRes = await uHandler(uReq);
+        return universalServerResponseToFetch(uRes);
+    }
+    return Object.assign(handleFetch, uHandler);
+}
+/**
+ * Convert a universal client request to a fetch request.
+ */
+function universalClientRequestToFetch(req) {
+    const body = req.body === undefined ? null : iterableToReadableStream(req.body);
+    return new Request(req.url, {
+        method: req.method,
+        headers: req.header,
+        signal: req.signal,
+        body,
+    });
+}
+/**
+ * Convert a fetch response to a universal client response.
+ */
+function universalClientResponseFromFetch(res) {
+    return {
+        status: res.status,
+        header: res.headers,
+        body: iterableFromReadableStream(res.body),
+        trailer: new Headers(),
+    };
+}
+/**
+ * Convert a fetch request to a universal server request.
+ */
+function universalServerRequestFromFetch(req, options) {
+    var _a;
+    return {
+        httpVersion: (_a = options.httpVersion) !== null && _a !== void 0 ? _a : "",
+        method: req.method,
+        url: req.url,
+        header: req.headers,
+        body: iterableFromReadableStream(req.body),
+        signal: req.signal,
+    };
+}
+/**
+ * Convert a universal server response to a fetch response.
+ */
+function universalServerResponseToFetch(res) {
+    let body = null;
+    if (res.body !== undefined) {
+        body = iterableToReadableStream(res.body);
+    }
+    return new Response(body, {
+        status: res.status,
+        headers: res.header,
+    });
+}
+function iterableToReadableStream(iterable) {
+    const it = iterable[Symbol.asyncIterator]();
+    return new ReadableStream({
+        async pull(controller) {
+            const r = await it.next();
+            if (r.done === true) {
+                controller.close();
+                return;
+            }
+            controller.enqueue(r.value);
+        },
+        async cancel(reason) {
+            if (it.throw) {
+                try {
+                    await it.throw(reason);
+                }
+                catch (_a) {
+                    // iterator.throw on a generator function rethrows unless the
+                    // body catches and swallows.
+                }
+            }
+        },
+    });
+}
+function iterableFromReadableStream(body) {
+    const reader = body === null || body === void 0 ? void 0 : body.getReader();
+    return {
+        [Symbol.asyncIterator]() {
+            return {
+                async next() {
+                    if (reader !== undefined) {
+                        const r = await reader.read();
+                        if (r.done) {
+                            return {
+                                done: true,
+                                value: undefined,
+                            };
+                        }
+                        return r;
+                    }
+                    return {
+                        done: true,
+                        value: undefined,
+                    };
+                },
+                async throw(e) {
+                    if (reader !== undefined) {
+                        await reader.cancel(e);
+                    }
+                    return {
+                        done: true,
+                        value: undefined,
+                    };
+                },
+            };
+        },
+    };
+}

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

@@ -0,0 +1,7 @@
+import type { UniversalHandler } from "./universal-handler.js";
+import type { UniversalClientFn } from "./universal.js";
+/**
+ * An in-memory UniversalClientFn that can be used to route requests to a ConnectRouter
+ * bypassing network calls. Useful for testing and calling in-process services.
+ */
+export declare function createUniversalHandlerClient(uHandlers: UniversalHandler[]): UniversalClientFn;

package/node_modules/@connectrpc/connect/dist/cjs/protocol/universal-handler-client.js

@@ -0,0 +1,88 @@
+"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.createUniversalHandlerClient = createUniversalHandlerClient;
+const code_js_1 = require("../code.js");
+const connect_error_js_1 = require("../connect-error.js");
+const async_iterable_js_1 = require("./async-iterable.js");
+const signals_js_1 = require("./signals.js");
+/**
+ * An in-memory UniversalClientFn that can be used to route requests to a ConnectRouter
+ * bypassing network calls. Useful for testing and calling in-process services.
+ */
+function createUniversalHandlerClient(uHandlers) {
+    const handlerMap = new Map();
+    for (const handler of uHandlers) {
+        handlerMap.set(handler.requestPath, handler);
+    }
+    return async (uClientReq) => {
+        var _a, _b, _c;
+        const pathname = new URL(uClientReq.url).pathname;
+        const handler = handlerMap.get(pathname);
+        if (!handler) {
+            throw new connect_error_js_1.ConnectError(`RouterHttpClient: no handler registered for ${pathname}`, code_js_1.Code.Unimplemented);
+        }
+        const reqSignal = (_a = uClientReq.signal) !== null && _a !== void 0 ? _a : new AbortController().signal;
+        const uServerRes = await raceSignal(reqSignal, handler({
+            body: (_b = uClientReq.body) !== null && _b !== void 0 ? _b : (0, async_iterable_js_1.createAsyncIterable)([]),
+            httpVersion: "2.0",
+            method: uClientReq.method,
+            url: uClientReq.url,
+            header: uClientReq.header,
+            signal: reqSignal,
+        }));
+        const body = (_c = uServerRes.body) !== null && _c !== void 0 ? _c : (0, async_iterable_js_1.createAsyncIterable)([]);
+        return {
+            body: (0, async_iterable_js_1.pipe)(body, (iterable) => {
+                return {
+                    [Symbol.asyncIterator]() {
+                        const it = iterable[Symbol.asyncIterator]();
+                        const w = {
+                            next() {
+                                return raceSignal(reqSignal, it.next());
+                            },
+                        };
+                        if (it.throw !== undefined) {
+                            w.throw = (e) => it.throw(e);
+                        }
+                        if (it.return !== undefined) {
+                            w.return = (value) => it.return(value);
+                        }
+                        return w;
+                    },
+                };
+            }),
+            header: new Headers(uServerRes.header),
+            status: uServerRes.status,
+            trailer: new Headers(uServerRes.trailer),
+        };
+    };
+}
+/**
+ * Wrap a promise, and reject early if the given signal triggers before the
+ * promise is settled.
+ */
+function raceSignal(signal, promise) {
+    let cleanup;
+    const signalPromise = new Promise((_, reject) => {
+        const onAbort = () => reject((0, signals_js_1.getAbortSignalReason)(signal));
+        if (signal.aborted) {
+            return onAbort();
+        }
+        signal.addEventListener("abort", onAbort);
+        cleanup = () => signal.removeEventListener("abort", onAbort);
+    });
+    return Promise.race([signalPromise, promise]).finally(cleanup);
+}

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

@@ -0,0 +1,167 @@
+import type { BinaryReadOptions, BinaryWriteOptions, DescMethod, DescService, JsonReadOptions, JsonWriteOptions } from "@bufbuild/protobuf";
+import type { HandlerContext, MethodImplSpec, ServiceImplSpec } from "../implementation.js";
+import type { UniversalHandlerFn } from "./universal.js";
+import type { ContentTypeMatcher } from "./content-type-matcher.js";
+import type { Compression } from "./compression.js";
+import type { ProtocolHandlerFactory } from "./protocol-handler-factory.js";
+import type { Interceptor } from "../interceptor.js";
+/**
+ * Common options for handlers.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export interface UniversalHandlerOptions {
+    /**
+     * Compression algorithms available to a server for decompressing request
+     * messages, and for compressing response messages.
+     */
+    acceptCompression: 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
+     * client. 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 client to handle.
+     *
+     * The default limit is the maximum supported value of ~4GiB.
+     */
+    writeMaxBytes: number;
+    /**
+     * 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>;
+    /**
+     * The maximum value for timeouts that clients may specify.
+     * If a clients requests a timeout that is greater than maxTimeoutMs,
+     * the server responds with the error code InvalidArgument.
+     */
+    maxTimeoutMs: number;
+    /**
+     * To shut down servers gracefully, this option takes an AbortSignal.
+     * If this signal is aborted, all signals in handler contexts will be aborted
+     * as well. This gives implementations a chance to wrap up work before the
+     * server process is killed.
+     * Abort this signal with a ConnectError to send a message and code to
+     * clients.
+     */
+    shutdownSignal?: AbortSignal;
+    /**
+     * Require requests using the Connect protocol to include the header
+     * Connect-Protocol-Version. This ensures that HTTP proxies and other
+     * code inspecting traffic can easily identify Connect RPC requests,
+     * even if they use a common Content-Type like application/json.
+     *
+     * If a Connect request does not include the Connect-Protocol-Version
+     * header, an error with code invalid_argument (HTTP 400) is returned.
+     * This option has no effect if the client uses the gRPC or the gRPC-web
+     * protocol.
+     */
+    requireConnectProtocolHeader: boolean;
+    /**
+     * Interceptors that should be applied to all calls running through
+     * this router. See the Interceptor type for details.
+     */
+    interceptors: Interceptor[];
+    /**
+     * An optional gate that runs after request headers are available, but before
+     * any request message is received, decompressed, or parsed.
+     *
+     * This is the right place to reject unauthenticated requests cheaply. Throw
+     * a ConnectError to end any RPC without reading the body.
+     *
+     * The gate receives the HandlerContext for the call. It may set context
+     * values for interceptors and the implementation to consume, and set
+     * response headers or trailers.
+     */
+    requestGate?: (context: HandlerContext) => void | Promise<void>;
+}
+/**
+ * An HTTP handler for one specific RPC - a procedure typically defined in
+ * protobuf.
+ */
+export interface UniversalHandler extends UniversalHandlerFn {
+    /**
+     * The name of the protocols this handler implements.
+     */
+    protocolNames: string[];
+    /**
+     * Information about the related protobuf service.
+     */
+    service: DescService;
+    /**
+     * Information about the method of the protobuf service.
+     */
+    method: DescMethod;
+    /**
+     * The request path of the procedure, without any prefixes.
+     * For example, "/something/foo.FooService/Bar" for the method
+     * "Bar" of the service "foo.FooService".
+     */
+    requestPath: string;
+    /**
+     * The HTTP request methods this procedure allows. For example, "POST".
+     */
+    allowedMethods: string[];
+    /**
+     * A matcher for Content-Type header values that this procedure supports.
+     */
+    supportedContentType: ContentTypeMatcher;
+}
+/**
+ * Asserts that the options are within sane limits, and returns default values
+ * where no value is provided.
+ *
+ * Note that this function does not set default values for `acceptCompression`.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function validateUniversalHandlerOptions(opt: Partial<UniversalHandlerOptions> | undefined): UniversalHandlerOptions;
+/**
+ * For the given service implementation, return a universal handler for each
+ * RPC. The handler serves the given protocols.
+ *
+ * At least one protocol is required.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function createUniversalServiceHandlers(spec: ServiceImplSpec, protocols: ProtocolHandlerFactory[]): UniversalHandler[];
+/**
+ * Return a universal handler for the given RPC implementation.
+ * The handler serves the given protocols.
+ *
+ * At least one protocol is required.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function createUniversalMethodHandler(spec: MethodImplSpec, protocols: ProtocolHandlerFactory[]): UniversalHandler;
+/**
+ * Create a universal handler that negotiates the protocol.
+ *
+ * This functions takes one or more handlers - all for the same RPC, but for
+ * different protocols - and returns a single handler that looks at the
+ * Content-Type header and the HTTP verb of the incoming request to select
+ * the appropriate protocol-specific handler.
+ *
+ * Raises an error if no protocol handlers were provided, or if they do not
+ * handle exactly the same RPC.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function negotiateProtocol(protocolHandlers: UniversalHandler[]): UniversalHandler;

package/node_modules/@connectrpc/connect/dist/cjs/protocol/universal-handler.js

@@ -0,0 +1,130 @@
+"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.validateUniversalHandlerOptions = validateUniversalHandlerOptions;
+exports.createUniversalServiceHandlers = createUniversalServiceHandlers;
+exports.createUniversalMethodHandler = createUniversalMethodHandler;
+exports.negotiateProtocol = negotiateProtocol;
+const universal_js_1 = require("./universal.js");
+const content_type_matcher_js_1 = require("./content-type-matcher.js");
+const limit_io_js_1 = require("./limit-io.js");
+const connect_error_js_1 = require("../connect-error.js");
+const code_js_1 = require("../code.js");
+/**
+ * Asserts that the options are within sane limits, and returns default values
+ * where no value is provided.
+ *
+ * Note that this function does not set default values for `acceptCompression`.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function validateUniversalHandlerOptions(opt) {
+    var _a, _b, _c;
+    opt !== null && opt !== void 0 ? opt : (opt = {});
+    const acceptCompression = opt.acceptCompression
+        ? [...opt.acceptCompression]
+        : [];
+    const requireConnectProtocolHeader = (_a = opt.requireConnectProtocolHeader) !== null && _a !== void 0 ? _a : false;
+    const maxTimeoutMs = (_b = opt.maxTimeoutMs) !== null && _b !== void 0 ? _b : Number.MAX_SAFE_INTEGER;
+    return Object.assign(Object.assign({ acceptCompression }, (0, limit_io_js_1.validateReadWriteMaxBytes)(opt.readMaxBytes, opt.writeMaxBytes, opt.compressMinBytes)), { jsonOptions: opt.jsonOptions, binaryOptions: opt.binaryOptions, maxTimeoutMs, shutdownSignal: opt.shutdownSignal, requireConnectProtocolHeader, interceptors: (_c = opt.interceptors) !== null && _c !== void 0 ? _c : [], requestGate: opt.requestGate });
+}
+/**
+ * For the given service implementation, return a universal handler for each
+ * RPC. The handler serves the given protocols.
+ *
+ * At least one protocol is required.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function createUniversalServiceHandlers(spec, protocols) {
+    return Object.entries(spec.methods).map(([, implSpec]) => createUniversalMethodHandler(implSpec, protocols));
+}
+/**
+ * Return a universal handler for the given RPC implementation.
+ * The handler serves the given protocols.
+ *
+ * At least one protocol is required.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function createUniversalMethodHandler(spec, protocols) {
+    return negotiateProtocol(protocols.map((f) => f(spec)));
+}
+/**
+ * Create a universal handler that negotiates the protocol.
+ *
+ * This functions takes one or more handlers - all for the same RPC, but for
+ * different protocols - and returns a single handler that looks at the
+ * Content-Type header and the HTTP verb of the incoming request to select
+ * the appropriate protocol-specific handler.
+ *
+ * Raises an error if no protocol handlers were provided, or if they do not
+ * handle exactly the same RPC.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function negotiateProtocol(protocolHandlers) {
+    if (protocolHandlers.length == 0) {
+        throw new connect_error_js_1.ConnectError("at least one protocol is required", code_js_1.Code.Internal);
+    }
+    const service = protocolHandlers[0].service;
+    const method = protocolHandlers[0].method;
+    const requestPath = protocolHandlers[0].requestPath;
+    if (protocolHandlers.some((h) => h.service !== service || h.method !== method)) {
+        throw new connect_error_js_1.ConnectError("cannot negotiate protocol for different RPCs", code_js_1.Code.Internal);
+    }
+    if (protocolHandlers.some((h) => h.requestPath !== requestPath)) {
+        throw new connect_error_js_1.ConnectError("cannot negotiate protocol for different requestPaths", code_js_1.Code.Internal);
+    }
+    async function protocolNegotiatingHandler(request) {
+        var _a;
+        if (method.methodKind == "bidi_streaming" &&
+            request.httpVersion.startsWith("1.")) {
+            return Object.assign(Object.assign({}, universal_js_1.uResponseVersionNotSupported), { 
+                // Clients coded to expect full-duplex connections may hang if they've
+                // mistakenly negotiated HTTP/1.1. To unblock them, we must close the
+                // underlying TCP connection.
+                header: new Headers({ Connection: "close" }) });
+        }
+        const contentType = (_a = request.header.get("Content-Type")) !== null && _a !== void 0 ? _a : "";
+        const matchingMethod = protocolHandlers.filter((h) => h.allowedMethods.includes(request.method));
+        if (matchingMethod.length == 0) {
+            return universal_js_1.uResponseMethodNotAllowed;
+        }
+        // If Content-Type is unset but only one handler matches, use it.
+        if (matchingMethod.length == 1 && contentType === "") {
+            const onlyMatch = matchingMethod[0];
+            return onlyMatch(request);
+        }
+        const matchingContentTypes = matchingMethod.filter((h) => h.supportedContentType(contentType));
+        if (matchingContentTypes.length == 0) {
+            return universal_js_1.uResponseUnsupportedMediaType;
+        }
+        const firstMatch = matchingContentTypes[0];
+        return firstMatch(request);
+    }
+    return Object.assign(protocolNegotiatingHandler, {
+        service,
+        method,
+        requestPath,
+        supportedContentType: (0, content_type_matcher_js_1.contentTypeMatcher)(...protocolHandlers.map((h) => h.supportedContentType)),
+        protocolNames: protocolHandlers
+            .flatMap((h) => h.protocolNames)
+            .filter((value, index, array) => array.indexOf(value) === index),
+        allowedMethods: protocolHandlers
+            .flatMap((h) => h.allowedMethods)
+            .filter((value, index, array) => array.indexOf(value) === index),
+    });
+}

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

@@ -0,0 +1,102 @@
+import type { JsonValue } from "@bufbuild/protobuf";
+import type { ContextValues } from "../context-values.js";
+/**
+ * A minimal abstraction of an HTTP client.
+ */
+export type UniversalClientFn = (request: UniversalClientRequest) => Promise<UniversalClientResponse>;
+/**
+ * A minimal abstraction of an HTTP request on the client side.
+ */
+export interface UniversalClientRequest {
+    url: string;
+    method: string;
+    header: Headers;
+    body?: AsyncIterable<Uint8Array>;
+    signal?: AbortSignal;
+}
+/**
+ * A minimal abstraction of an HTTP request on the client side.
+ */
+export interface UniversalClientResponse {
+    status: number;
+    header: Headers;
+    body: AsyncIterable<Uint8Array>;
+    trailer: Headers;
+}
+/**
+ * A minimal abstraction of an HTTP handler.
+ */
+export type UniversalHandlerFn = (request: UniversalServerRequest) => Promise<UniversalServerResponse>;
+/**
+ * A minimal abstraction of an HTTP request on the server side.
+ */
+export interface UniversalServerRequest {
+    httpVersion: string;
+    url: string;
+    method: string;
+    header: Headers;
+    /**
+     * Many server frameworks parse request bodies with the mime type
+     * application/json automatically. We accept a JSON value as an
+     * alternative to a byte stream here so that this situation can be
+     * handled efficiently.
+     */
+    body: AsyncIterable<Uint8Array> | JsonValue;
+    signal: AbortSignal;
+    contextValues?: ContextValues;
+}
+/**
+ * A minimal abstraction of an HTTP response on the server side.
+ */
+export interface UniversalServerResponse {
+    status: number;
+    header?: Headers;
+    body?: AsyncIterable<Uint8Array>;
+    trailer?: Headers;
+}
+/**
+ * Assert that the given UniversalServerRequest has a byte stream body, not
+ * a JSON value.
+ *
+ * We accept a JSON object or a byte stream in server requests.
+ * In practice, only Connect unary handlers will receive a parse
+ * JSON object. Other call-sites can use this assertion to narrow
+ * the union type. A failure in such a call-sites indicates that
+ * the contract between a server framework and the connect-node \
+ * handler is broken.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function assertByteStreamRequest(req: UniversalServerRequest): asserts req is Omit<UniversalServerRequest, "body"> & {
+    body: AsyncIterable<Uint8Array>;
+};
+/**
+ * HTTP 200 OK
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare const uResponseOk: Readonly<UniversalServerResponse>;
+/**
+ * HTTP 404 Not Found
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare const uResponseNotFound: Readonly<UniversalServerResponse>;
+/**
+ * HTTP 415 Unsupported Media Type
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare const uResponseUnsupportedMediaType: Readonly<UniversalServerResponse>;
+/**
+ * HTTP 405 Method Not Allowed
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare const uResponseMethodNotAllowed: Readonly<UniversalServerResponse>;
+/**
+ * HTTP 505 Version Not Supported
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare const uResponseVersionNotSupported: Readonly<UniversalServerResponse>;