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

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

@@ -0,0 +1,104 @@
+import type { BinaryReadOptions, BinaryWriteOptions, JsonReadOptions, JsonWriteOptions, Message, MessageType, MethodInfo } 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;
+    /**
+     * 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;
+    typeRegistry?: import("@bufbuild/protobuf").IMessageTypeRegistry & Partial<import("@bufbuild/protobuf").IExtensionRegistry>;
+    emitDefaultValues?: 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 Message<I>, O extends Message<O>>(method: MethodInfo<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 Message<I>, O extends Message<O>> {
+    /**
+     * Get the JSON or binary serialization for the request message type.
+     */
+    getI(useBinaryFormat: boolean): Serialization<I>;
+    /**
+     * Get the JSON or binary serialization for the response message type.
+     */
+    getO(useBinaryFormat: boolean): Serialization<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 Message<I>, O extends Message<O>>(method: MethodInfo<I, O>, useBinaryFormat: boolean, jsonOptions?: JsonSerializationOptions, binaryOptions?: BinarySerializationOptions): {
+    parse: (data: Uint8Array) => O;
+    serialize: (data: I) => Uint8Array;
+};
+/**
+ * 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<T extends Message<T>>(messageType: MessageType<T>, options: BinarySerializationOptions | undefined): Serialization<T>;
+/**
+ * Options for createJsonSerialization()
+ */
+type JsonSerializationOptions = Partial<JsonReadOptions & JsonWriteOptions> & {
+    textEncoder?: {
+        encode(input?: string): Uint8Array;
+    };
+    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<T extends Message<T>>(messageType: MessageType<T>, options: JsonSerializationOptions | undefined): Serialization<T>;
+export {};

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol/serialization.js

@@ -0,0 +1,140 @@
+// 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 { assertReadMaxBytes, assertWriteMaxBytes } from "./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.
+ */
+export 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.
+ */
+export function createMethodSerializationLookup(method, binaryOptions, jsonOptions, limitOptions) {
+    const inputBinary = limitSerialization(createBinarySerialization(method.I, binaryOptions), limitOptions);
+    const inputJson = limitSerialization(createJsonSerialization(method.I, jsonOptions), limitOptions);
+    const outputBinary = limitSerialization(createBinarySerialization(method.O, binaryOptions), limitOptions);
+    const outputJson = limitSerialization(createJsonSerialization(method.O, 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.
+ */
+export function createClientMethodSerializers(method, useBinaryFormat, jsonOptions, binaryOptions) {
+    const input = useBinaryFormat
+        ? createBinarySerialization(method.I, binaryOptions)
+        : createJsonSerialization(method.I, jsonOptions);
+    const output = useBinaryFormat
+        ? createBinarySerialization(method.O, binaryOptions)
+        : createJsonSerialization(method.O, 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.
+ */
+export function limitSerialization(serialization, limitOptions) {
+    return {
+        serialize(data) {
+            const bytes = serialization.serialize(data);
+            assertWriteMaxBytes(limitOptions.writeMaxBytes, bytes.byteLength);
+            return bytes;
+        },
+        parse(data) {
+            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.
+ */
+export function createBinarySerialization(messageType, options) {
+    return {
+        parse(data) {
+            try {
+                return messageType.fromBinary(data, options);
+            }
+            catch (e) {
+                const m = e instanceof Error ? e.message : String(e);
+                throw new ConnectError(`parse binary: ${m}`, Code.Internal);
+            }
+        },
+        serialize(data) {
+            try {
+                return data.toBinary(options);
+            }
+            catch (e) {
+                const m = e instanceof Error ? e.message : String(e);
+                throw new ConnectError(`serialize binary: ${m}`, Code.Internal);
+            }
+        },
+    };
+}
+/**
+ * Creates a Serialization object for serializing the given protobuf message
+ * with the protobuf canonical JSON encoding.
+ *
+ * By default, unknown fields are ignored.
+ */
+export function createJsonSerialization(messageType, 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 messageType.fromJsonString(json, o);
+            }
+            catch (e) {
+                throw ConnectError.from(e, Code.InvalidArgument);
+            }
+        },
+        serialize(data) {
+            try {
+                const json = data.toJsonString(o);
+                return textEncoder.encode(json);
+            }
+            catch (e) {
+                throw ConnectError.from(e, Code.Internal);
+            }
+        },
+    };
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/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/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol/signals.js

@@ -0,0 +1,95 @@
+// 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";
+/**
+ * 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 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.
+ */
+export function createDeadlineSignal(timeoutMs) {
+    const controller = new AbortController();
+    const listener = () => {
+        controller.abort(new ConnectError("the operation timed out", 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.
+ */
+export 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/gen/ts/node_modules/@connectrpc/connect/dist/esm/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/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol/transport-options.js

@@ -0,0 +1,14 @@
+// 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.
+export {};

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/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 {};

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol/universal-fetch.js

@@ -0,0 +1,142 @@
+// 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.
+/**
+ * Create a universal client function, a minimal abstraction of an HTTP client,
+ * using the given fetch() implementation.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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/gen/ts/node_modules/@connectrpc/connect/dist/esm/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;