@in-human-resources/backend-proto 0.1.5 → 0.1.6

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-grpc-web/request-header.js

@@ -0,0 +1,55 @@
+// Copyright 2021-2024 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 { headerAcceptEncoding, headerContentType, headerEncoding, headerTimeout, headerXGrpcWeb, headerUserAgent, headerXUserAgent, } from "./headers.js";
+import { contentTypeJson, contentTypeProto } from "./content-type.js";
+/**
+ * Creates headers for a gRPC-web request.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function requestHeader(useBinaryFormat, timeoutMs, userProvidedHeaders, setUserAgent) {
+    var _a, _b;
+    const result = new Headers(userProvidedHeaders !== null && userProvidedHeaders !== void 0 ? userProvidedHeaders : {});
+    // Note that we do not support the grpc-web-text format.
+    // https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-WEB.md#protocol-differences-vs-grpc-over-http2
+    result.set(headerContentType, useBinaryFormat ? contentTypeProto : contentTypeJson);
+    result.set(headerXGrpcWeb, "1");
+    // Note that we do not strictly comply with gRPC user agents.
+    // We use "connect-es/1.2.3" where gRPC would use "grpc-es/1.2.3".
+    // See https://github.com/grpc/grpc/blob/c462bb8d485fc1434ecfae438823ca8d14cf3154/doc/PROTOCOL-HTTP2.md#user-agents
+    const userAgent = (_b = (_a = result.get(headerUserAgent)) !== null && _a !== void 0 ? _a : result.get(headerXUserAgent)) !== null && _b !== void 0 ? _b : "connect-es/1.7.0";
+    result.set(headerXUserAgent, userAgent);
+    if (setUserAgent) {
+        result.set(headerUserAgent, userAgent);
+    }
+    if (timeoutMs !== undefined) {
+        result.set(headerTimeout, `${timeoutMs}m`);
+    }
+    return result;
+}
+/**
+ * Creates headers for a gRPC-web request with compression.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function requestHeaderWithCompression(useBinaryFormat, timeoutMs, userProvidedHeaders, acceptCompression, sendCompression, setUserAgent) {
+    const result = requestHeader(useBinaryFormat, timeoutMs, userProvidedHeaders, setUserAgent);
+    if (sendCompression != null) {
+        result.set(headerEncoding, sendCompression.name);
+    }
+    if (acceptCompression.length > 0) {
+        result.set(headerAcceptEncoding, acceptCompression.map((c) => c.name).join(","));
+    }
+    return result;
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-grpc-web/trailer.d.ts

@@ -0,0 +1,27 @@
+import type { Serialization } from "../protocol/serialization.js";
+/**
+ * trailerFlag indicates that the data in a EnvelopedMessage
+ * is a set of trailers of the gRPC-web protocol.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare const trailerFlag = 128;
+/**
+ * Parse a gRPC-web trailer, a set of header fields separated by CRLF.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function trailerParse(data: Uint8Array): Headers;
+/**
+ * Serialize a Headers object as a gRPC-web trailer.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function trailerSerialize(trailer: Headers): Uint8Array;
+/**
+ * Create a Serialization object that serializes a gRPC-web trailer, a Headers
+ * object that is serialized as a set of header fields, separated by CRLF.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function createTrailerSerialization(): Serialization<Headers>;

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-grpc-web/trailer.js

@@ -0,0 +1,65 @@
+// Copyright 2021-2024 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.
+/**
+ * trailerFlag indicates that the data in a EnvelopedMessage
+ * is a set of trailers of the gRPC-web protocol.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export const trailerFlag = 0b10000000;
+/**
+ * Parse a gRPC-web trailer, a set of header fields separated by CRLF.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function trailerParse(data) {
+    const headers = new Headers();
+    const lines = new TextDecoder().decode(data).split("\r\n");
+    for (const line of lines) {
+        if (line === "") {
+            continue;
+        }
+        const i = line.indexOf(":");
+        if (i > 0) {
+            const name = line.substring(0, i).trim();
+            const value = line.substring(i + 1).trim();
+            headers.append(name, value);
+        }
+    }
+    return headers;
+}
+/**
+ * Serialize a Headers object as a gRPC-web trailer.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function trailerSerialize(trailer) {
+    const lines = [];
+    trailer.forEach((value, key) => {
+        lines.push(`${key}: ${value}\r\n`);
+    });
+    return new TextEncoder().encode(lines.join(""));
+}
+/**
+ * Create a Serialization object that serializes a gRPC-web trailer, a Headers
+ * object that is serialized as a set of header fields, separated by CRLF.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function createTrailerSerialization() {
+    return {
+        serialize: trailerSerialize,
+        parse: trailerParse,
+    };
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-grpc-web/transport.d.ts

@@ -0,0 +1,6 @@
+import type { CommonTransportOptions } from "../protocol/transport-options.js";
+import type { Transport } from "../transport.js";
+/**
+ * Create a Transport for the gRPC-web protocol.
+ */
+export declare function createTransport(opt: CommonTransportOptions): Transport;

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-grpc-web/transport.js

@@ -0,0 +1,235 @@
+// Copyright 2021-2024 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.
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+import { validateTrailer } from "../protocol-grpc/validate-trailer.js";
+import { requestHeaderWithCompression } from "./request-header.js";
+import { validateResponseWithCompression } from "./validate-response.js";
+import { createTrailerSerialization, trailerFlag } from "./trailer.js";
+import { Code } from "../code.js";
+import { ConnectError } from "../connect-error.js";
+import { pipe, createAsyncIterable, transformSerializeEnvelope, transformCompressEnvelope, transformJoinEnvelopes, pipeTo, transformSplitEnvelope, transformDecompressEnvelope, transformParseEnvelope, } from "../protocol/async-iterable.js";
+import { createMethodUrl } from "../protocol/create-method-url.js";
+import { runUnaryCall, runStreamingCall } from "../protocol/run-call.js";
+import { createMethodSerializationLookup } from "../protocol/serialization.js";
+import { createContextValues } from "../context-values.js";
+import { headerGrpcStatus } from "./headers.js";
+/**
+ * Create a Transport for the gRPC-web protocol.
+ */
+export function createTransport(opt) {
+    return {
+        async unary(service, method, signal, timeoutMs, header, message, contextValues) {
+            const serialization = createMethodSerializationLookup(method, opt.binaryOptions, opt.jsonOptions, opt);
+            timeoutMs =
+                timeoutMs === undefined
+                    ? opt.defaultTimeoutMs
+                    : timeoutMs <= 0
+                        ? undefined
+                        : timeoutMs;
+            return await runUnaryCall({
+                interceptors: opt.interceptors,
+                signal,
+                timeoutMs,
+                req: {
+                    stream: false,
+                    service,
+                    method,
+                    url: createMethodUrl(opt.baseUrl, service, method),
+                    init: {},
+                    header: requestHeaderWithCompression(opt.useBinaryFormat, timeoutMs, header, opt.acceptCompression, opt.sendCompression, true),
+                    contextValues: contextValues !== null && contextValues !== void 0 ? contextValues : createContextValues(),
+                    message,
+                },
+                next: async (req) => {
+                    const uRes = await opt.httpClient({
+                        url: req.url,
+                        method: "POST",
+                        header: req.header,
+                        signal: req.signal,
+                        body: pipe(createAsyncIterable([req.message]), transformSerializeEnvelope(serialization.getI(opt.useBinaryFormat)), transformCompressEnvelope(opt.sendCompression, opt.compressMinBytes), transformJoinEnvelopes(), {
+                            propagateDownStreamError: true,
+                        }),
+                    });
+                    const { compression, headerError } = validateResponseWithCompression(opt.acceptCompression, uRes.status, uRes.header);
+                    const { trailer, message } = await pipeTo(uRes.body, transformSplitEnvelope(opt.readMaxBytes), transformDecompressEnvelope(compression !== null && compression !== void 0 ? compression : null, opt.readMaxBytes), transformParseEnvelope(serialization.getO(opt.useBinaryFormat), trailerFlag, createTrailerSerialization()), async (iterable) => {
+                        var _a, e_1, _b, _c;
+                        let message;
+                        let trailer;
+                        try {
+                            for (var _d = true, iterable_1 = __asyncValues(iterable), iterable_1_1; iterable_1_1 = await iterable_1.next(), _a = iterable_1_1.done, !_a; _d = true) {
+                                _c = iterable_1_1.value;
+                                _d = false;
+                                const env = _c;
+                                if (env.end) {
+                                    if (trailer !== undefined) {
+                                        throw new ConnectError("protocol error: received extra trailer", Code.Unimplemented);
+                                    }
+                                    trailer = env.value;
+                                }
+                                else {
+                                    if (message !== undefined) {
+                                        throw new ConnectError("protocol error: received extra output message for unary method", Code.Unimplemented);
+                                    }
+                                    message = env.value;
+                                }
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (!_d && !_a && (_b = iterable_1.return)) await _b.call(iterable_1);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                        return { trailer, message };
+                    }, {
+                        propagateDownStreamError: false,
+                    });
+                    if (trailer === undefined) {
+                        if (headerError != undefined) {
+                            throw headerError;
+                        }
+                        throw new ConnectError("protocol error: missing trailer", uRes.header.has(headerGrpcStatus)
+                            ? Code.Unimplemented
+                            : Code.Unknown);
+                    }
+                    validateTrailer(trailer, uRes.header);
+                    if (message === undefined) {
+                        throw new ConnectError("protocol error: missing output message for unary method", trailer.has(headerGrpcStatus) ? Code.Unimplemented : Code.Unknown);
+                    }
+                    return {
+                        stream: false,
+                        service,
+                        method,
+                        header: uRes.header,
+                        message,
+                        trailer,
+                    };
+                },
+            });
+        },
+        async stream(service, method, signal, timeoutMs, header, input, contextValues) {
+            const serialization = createMethodSerializationLookup(method, opt.binaryOptions, opt.jsonOptions, opt);
+            timeoutMs =
+                timeoutMs === undefined
+                    ? opt.defaultTimeoutMs
+                    : timeoutMs <= 0
+                        ? undefined
+                        : timeoutMs;
+            return runStreamingCall({
+                interceptors: opt.interceptors,
+                signal,
+                timeoutMs,
+                req: {
+                    stream: true,
+                    service,
+                    method,
+                    url: createMethodUrl(opt.baseUrl, service, method),
+                    init: {
+                        method: "POST",
+                        redirect: "error",
+                        mode: "cors",
+                    },
+                    header: requestHeaderWithCompression(opt.useBinaryFormat, timeoutMs, header, opt.acceptCompression, opt.sendCompression, true),
+                    contextValues: contextValues !== null && contextValues !== void 0 ? contextValues : createContextValues(),
+                    message: input,
+                },
+                next: async (req) => {
+                    const uRes = await opt.httpClient({
+                        url: req.url,
+                        method: "POST",
+                        header: req.header,
+                        signal: req.signal,
+                        body: pipe(req.message, transformSerializeEnvelope(serialization.getI(opt.useBinaryFormat)), transformCompressEnvelope(opt.sendCompression, opt.compressMinBytes), transformJoinEnvelopes(), { propagateDownStreamError: true }),
+                    });
+                    const { compression, foundStatus, headerError } = validateResponseWithCompression(opt.acceptCompression, uRes.status, uRes.header);
+                    if (headerError) {
+                        throw headerError;
+                    }
+                    const res = Object.assign(Object.assign({}, req), { header: uRes.header, trailer: new Headers(), message: pipe(uRes.body, transformSplitEnvelope(opt.readMaxBytes), transformDecompressEnvelope(compression !== null && compression !== void 0 ? compression : null, opt.readMaxBytes), transformParseEnvelope(serialization.getO(opt.useBinaryFormat), trailerFlag, createTrailerSerialization()), function (iterable) {
+                            return __asyncGenerator(this, arguments, function* () {
+                                var _a, e_2, _b, _c;
+                                if (foundStatus) {
+                                    // A grpc-status: 0 response header was present. This is a "trailers-only"
+                                    // response (a response without a body and no trailers).
+                                    //
+                                    // The spec seems to disallow a trailers-only response for status 0 - we are
+                                    // lenient and only verify that the body is empty.
+                                    //
+                                    // > [...] Trailers-Only is permitted for calls that produce an immediate error.
+                                    // See https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md
+                                    const r = yield __await(iterable[Symbol.asyncIterator]().next());
+                                    if (r.done !== true) {
+                                        throw new ConnectError("protocol error: extra data for trailers-only", Code.InvalidArgument);
+                                    }
+                                    return yield __await(void 0);
+                                }
+                                let trailerReceived = false;
+                                try {
+                                    for (var _d = true, iterable_2 = __asyncValues(iterable), iterable_2_1; iterable_2_1 = yield __await(iterable_2.next()), _a = iterable_2_1.done, !_a; _d = true) {
+                                        _c = iterable_2_1.value;
+                                        _d = false;
+                                        const chunk = _c;
+                                        if (chunk.end) {
+                                            if (trailerReceived) {
+                                                throw new ConnectError("protocol error: received extra trailer", Code.InvalidArgument);
+                                            }
+                                            trailerReceived = true;
+                                            validateTrailer(chunk.value, uRes.header);
+                                            chunk.value.forEach((value, key) => res.trailer.set(key, value));
+                                            continue;
+                                        }
+                                        if (trailerReceived) {
+                                            throw new ConnectError("protocol error: received extra message after trailer", Code.InvalidArgument);
+                                        }
+                                        yield yield __await(chunk.value);
+                                    }
+                                }
+                                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                                finally {
+                                    try {
+                                        if (!_d && !_a && (_b = iterable_2.return)) yield __await(_b.call(iterable_2));
+                                    }
+                                    finally { if (e_2) throw e_2.error; }
+                                }
+                                if (!trailerReceived) {
+                                    throw new ConnectError("protocol error: missing trailer", Code.Internal);
+                                }
+                            });
+                        }, { propagateDownStreamError: true }) });
+                    return res;
+                },
+            });
+        },
+    };
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-grpc-web/validate-response.d.ts

@@ -0,0 +1,34 @@
+import { ConnectError } from "../connect-error.js";
+import type { Compression } from "../protocol/compression.js";
+/**
+ * Validates response status and header for the gRPC-web protocol.
+ *
+ * Throws a ConnectError if the header contains an error status,
+ * or if the HTTP status indicates an error.
+ *
+ * Returns an object that indicates whether a gRPC status was found
+ * in the response header. In this case, clients can not expect a
+ * trailer.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function validateResponse(status: number, headers: Headers): {
+    foundStatus: boolean;
+    headerError?: ConnectError;
+};
+/**
+ * Validates response status and header for the gRPC-web protocol.
+ * This function is identical to validateResponse(), but also verifies
+ * that a given encoding header is acceptable.
+ *
+ * Returns an object with the response compression, and a boolean
+ * indicating whether a gRPC status was found in the response header
+ * (in this case, clients can not expect a trailer).
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function validateResponseWithCompression(acceptCompression: Compression[], status: number, headers: Headers): {
+    foundStatus: boolean;
+    compression: Compression | undefined;
+    headerError?: ConnectError;
+};

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-grpc-web/validate-response.js

@@ -0,0 +1,69 @@
+// Copyright 2021-2024 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 { headerEncoding, headerGrpcMessage, headerGrpcStatus, } from "./headers.js";
+import { codeFromHttpStatus } from "../protocol-grpc/http-status.js";
+import { findTrailerError } from "../protocol-grpc/trailer-status.js";
+/**
+ * Validates response status and header for the gRPC-web protocol.
+ *
+ * Throws a ConnectError if the header contains an error status,
+ * or if the HTTP status indicates an error.
+ *
+ * Returns an object that indicates whether a gRPC status was found
+ * in the response header. In this case, clients can not expect a
+ * trailer.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function validateResponse(status, headers) {
+    var _a;
+    // For compatibility with the `grpc-web` package, we treat all HTTP status
+    // codes in the 200 range as valid, not just HTTP 200.
+    if (status >= 200 && status < 300) {
+        return {
+            foundStatus: headers.has(headerGrpcStatus),
+            headerError: findTrailerError(headers),
+        };
+    }
+    throw new ConnectError(decodeURIComponent((_a = headers.get(headerGrpcMessage)) !== null && _a !== void 0 ? _a : `HTTP ${status}`), codeFromHttpStatus(status), headers);
+}
+/**
+ * Validates response status and header for the gRPC-web protocol.
+ * This function is identical to validateResponse(), but also verifies
+ * that a given encoding header is acceptable.
+ *
+ * Returns an object with the response compression, and a boolean
+ * indicating whether a gRPC status was found in the response header
+ * (in this case, clients can not expect a trailer).
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function validateResponseWithCompression(acceptCompression, status, headers) {
+    const { foundStatus, headerError } = validateResponse(status, headers);
+    let compression;
+    const encoding = headers.get(headerEncoding);
+    if (encoding !== null && encoding.toLowerCase() !== "identity") {
+        compression = acceptCompression.find((c) => c.name === encoding);
+        if (!compression) {
+            throw new ConnectError(`unsupported response encoding "${encoding}"`, Code.Internal, headers);
+        }
+    }
+    return {
+        foundStatus,
+        compression,
+        headerError,
+    };
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/router-transport.d.ts

@@ -0,0 +1,13 @@
+import type { CommonTransportOptions } from "./protocol/transport-options.js";
+import type { ConnectRouter, ConnectRouterOptions } from "./router.js";
+/**
+ * Creates a Transport that routes requests to the configured router. Useful for testing
+ * and calling services running in the same process.
+ *
+ * This can be used to test both client logic by using this to stub/mock the backend,
+ * and to test server logic by using this to run without needing to spin up a server.
+ */
+export declare function createRouterTransport(routes: (router: ConnectRouter) => void, options?: {
+    transport?: Partial<CommonTransportOptions>;
+    router?: ConnectRouterOptions;
+}): import("./transport.js").Transport;

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/router-transport.js

@@ -0,0 +1,29 @@
+// Copyright 2021-2024 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 { createTransport } from "./protocol-connect/transport.js";
+import { createUniversalHandlerClient } from "./protocol/universal-handler-client.js";
+import { createConnectRouter } from "./router.js";
+/**
+ * Creates a Transport that routes requests to the configured router. Useful for testing
+ * and calling services running in the same process.
+ *
+ * This can be used to test both client logic by using this to stub/mock the backend,
+ * and to test server logic by using this to run without needing to spin up a server.
+ */
+export function createRouterTransport(routes, options) {
+    var _a, _b;
+    const router = createConnectRouter(Object.assign(Object.assign({}, ((_a = options === null || options === void 0 ? void 0 : options.router) !== null && _a !== void 0 ? _a : {})), { connect: true }));
+    routes(router);
+    return createTransport(Object.assign({ httpClient: createUniversalHandlerClient(router.handlers), baseUrl: "https://in-memory", useBinaryFormat: true, interceptors: [], acceptCompression: [], sendCompression: null, compressMinBytes: Number.MAX_SAFE_INTEGER, readMaxBytes: Number.MAX_SAFE_INTEGER, writeMaxBytes: Number.MAX_SAFE_INTEGER }, ((_b = options === null || options === void 0 ? void 0 : options.transport) !== null && _b !== void 0 ? _b : {})));
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/router.d.ts

@@ -0,0 +1,88 @@
+import type { MethodInfo, ServiceType } from "@bufbuild/protobuf";
+import type { MethodImpl, ServiceImpl } from "./implementation.js";
+import type { UniversalHandler, UniversalHandlerOptions } from "./protocol/universal-handler.js";
+import type { MethodType } from "./method-type.js";
+/**
+ * ConnectRouter is your single registration point for RPCs.
+ *
+ * Create a file `connect.ts` with a default export such as this:
+ *
+ * ```ts
+ * import {ConnectRouter} from "@connectrpc/connect";
+ *
+ * export default (router: ConnectRouter) => {
+ *   router.service(ElizaService, {});
+ * }
+ * ```
+ *
+ * The pass this function to adapters and plugins, for example
+ * from @connectrpc/connect-node, or from @connectrpc/connect-fastify.
+ */
+export interface ConnectRouter {
+    readonly handlers: UniversalHandler[];
+    /**
+     * Register a service implementation, and object with methods for the
+     * individual RPCs.
+     *
+     * You don't have to implement all RPCs of a service. If you omit a method,
+     * the router adds a method that responds with an error code `unimplemented`.
+     */
+    service<T extends ServiceType>(service: T, implementation: Partial<ServiceImpl<T>>, options?: Partial<UniversalHandlerOptions>): this;
+    /**
+     * Register a single RPC implementation.
+     */
+    rpc<M extends MethodInfo>(service: ServiceType, method: M, impl: MethodImpl<M>, options?: Partial<UniversalHandlerOptions>): this;
+    /**
+     * Register a single RPC implementation for a method type.
+     *
+     * @private This is an experimental API. Please do not rely on it yet.
+     */
+    rpc<M extends MethodType>(method: M, impl: MethodImpl<M>, options?: Partial<UniversalHandlerOptions>): this;
+}
+/**
+ * Options for a ConnectRouter. By default, all three protocols gRPC, gRPC-web,
+ * and Connect are enabled.
+ */
+export interface ConnectRouterOptions extends Partial<UniversalHandlerOptions> {
+    /**
+     * Enable the gRPC protocol and make your API available to all gRPC clients
+     * for various platforms and languages. See https://grpc.io/
+     *
+     * The protocol is enabled by default. Set this option to `false` to disable
+     * it, but mind that at least one protocol must be enabled.
+     *
+     * Note that gRPC is typically served with TLS over HTTP/2 and requires access
+     * to HTTP trailers.
+     */
+    grpc?: boolean;
+    /**
+     * Enable the gRPC-web protocol and make your API available to all gRPC-web
+     * clients. gRPC-web is commonly used in web browsers, but there are client
+     * implementations for other platforms as well, for example in Dart, Kotlin,
+     * and Swift. See https://github.com/grpc/grpc-web
+     *
+     * The protocol is enabled by default. Set this option to `false` to disable
+     * it, but mind that at least one protocol must be enabled.
+     *
+     * gRPC-web works over HTTP 1.1 or HTTP/2 and does not require access to HTTP
+     * trailers. Note that bidi streaming requires HTTP/2, and web browsers may
+     * not support all streaming types.
+     */
+    grpcWeb?: boolean;
+    /**
+     * Enable the Connect protocol and make your API available to all Connect
+     * clients, but also for a simple call with curl. See https://connectrpc.com/
+     *
+     * The protocol is enabled by default. Set this option to `false` to disable
+     * it, but mind that at least one protocol must be enabled.
+     *
+     * Connect works over HTTP 1.1 or HTTP/2 and does not require access to HTTP
+     * trailers. Note that bidi streaming requires HTTP/2, and web browsers may
+     * not support all streaming types.
+     */
+    connect?: boolean;
+}
+/**
+ * Create a new ConnectRouter.
+ */
+export declare function createConnectRouter(routerOptions?: ConnectRouterOptions): ConnectRouter;