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

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

@@ -0,0 +1,87 @@
+// 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 { Code } from "../code.js";
+import { ConnectError } from "../connect-error.js";
+import { createAsyncIterable, pipe } from "./async-iterable.js";
+import { getAbortSignalReason } from "./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.
+ */
+export 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 ConnectError(`RouterHttpClient: no handler registered for ${pathname}`, 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 : 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 : createAsyncIterable([]);
+        return {
+            body: pipe(body, (iterable) => {
+                return {
+                    [Symbol.asyncIterator]() {
+                        const it = iterable[Symbol.asyncIterator]();
+                        const w = {
+                            next() {
+                                return raceSignal(reqSignal, it.next());
+                            },
+                        };
+                        if (it.throw !== undefined) {
+                            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- can't handle mutated object sensibly
+                            w.throw = (e) => it.throw(e);
+                        }
+                        if (it.return !== undefined) {
+                            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion,@typescript-eslint/no-explicit-any -- can't handle mutated object sensibly
+                            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(getAbortSignalReason(signal));
+        if (signal.aborted) {
+            return onAbort();
+        }
+        signal.addEventListener("abort", onAbort);
+        cleanup = () => signal.removeEventListener("abort", onAbort);
+    });
+    return Promise.race([signalPromise, promise]).finally(cleanup);
+}

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

@@ -0,0 +1,155 @@
+import type { BinaryReadOptions, BinaryWriteOptions, JsonReadOptions, JsonWriteOptions, MethodInfo, ServiceType } from "@bufbuild/protobuf";
+import type { 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 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: ServiceType;
+    /**
+     * Information about the method of the protobuf service.
+     */
+    method: MethodInfo;
+    /**
+     * 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/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol/universal-handler.js

@@ -0,0 +1,125 @@
+// 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 { MethodKind } from "@bufbuild/protobuf";
+import { uResponseMethodNotAllowed, uResponseUnsupportedMediaType, uResponseVersionNotSupported, } from "./universal.js";
+import { contentTypeMatcher } from "./content-type-matcher.js";
+import { validateReadWriteMaxBytes } from "./limit-io.js";
+import { ConnectError } from "../connect-error.js";
+import { Code } from "../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.
+ */
+export 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 }, 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 : [] });
+}
+/**
+ * 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 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.
+ */
+export 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.
+ */
+export function negotiateProtocol(protocolHandlers) {
+    if (protocolHandlers.length == 0) {
+        throw new ConnectError("at least one protocol is required", 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 ConnectError("cannot negotiate protocol for different RPCs", Code.Internal);
+    }
+    if (protocolHandlers.some((h) => h.requestPath !== requestPath)) {
+        throw new ConnectError("cannot negotiate protocol for different requestPaths", Code.Internal);
+    }
+    async function protocolNegotiatingHandler(request) {
+        var _a;
+        if (method.kind == MethodKind.BiDiStreaming &&
+            request.httpVersion.startsWith("1.")) {
+            return Object.assign(Object.assign({}, 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 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 uResponseUnsupportedMediaType;
+        }
+        const firstMatch = matchingContentTypes[0];
+        return firstMatch(request);
+    }
+    return Object.assign(protocolNegotiatingHandler, {
+        service,
+        method,
+        requestPath,
+        supportedContentType: 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/gen/ts/node_modules/@connectrpc/connect/dist/esm/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>;

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

@@ -0,0 +1,74 @@
+// 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.
+/**
+ * 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 function assertByteStreamRequest(req) {
+    if (typeof req.body == "object" &&
+        req.body !== null &&
+        Symbol.asyncIterator in req.body) {
+        return;
+    }
+    throw new Error("byte stream required, but received JSON");
+}
+/**
+ * HTTP 200 OK
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export const uResponseOk = {
+    status: 200,
+};
+/**
+ * HTTP 404 Not Found
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export const uResponseNotFound = {
+    status: 404,
+};
+/**
+ * HTTP 415 Unsupported Media Type
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export const uResponseUnsupportedMediaType = {
+    status: 415,
+};
+/**
+ * HTTP 405 Method Not Allowed
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export const uResponseMethodNotAllowed = {
+    status: 405,
+};
+/**
+ * HTTP 505 Version Not Supported
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export const uResponseVersionNotSupported = {
+    status: 505,
+};

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-connect/code-string.d.ts

@@ -0,0 +1,16 @@
+import { Code } from "../code.js";
+/**
+ * codeToString returns the string representation of a Code.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function codeToString(value: Code): string;
+/**
+ * codeFromString parses the string representation of a Code in snake_case.
+ * For example, the string "permission_denied" parses into Code.PermissionDenied.
+ *
+ * If the given string cannot be parsed, the function returns undefined.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function codeFromString(value: string): Code | undefined;

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-connect/code-string.js

@@ -0,0 +1,48 @@
+// 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 { Code } from "../code.js";
+/**
+ * codeToString returns the string representation of a Code.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function codeToString(value) {
+    const name = Code[value];
+    if (typeof name != "string") {
+        return value.toString();
+    }
+    return (name[0].toLowerCase() +
+        name.substring(1).replace(/[A-Z]/g, (c) => "_" + c.toLowerCase()));
+}
+let stringToCode;
+/**
+ * codeFromString parses the string representation of a Code in snake_case.
+ * For example, the string "permission_denied" parses into Code.PermissionDenied.
+ *
+ * If the given string cannot be parsed, the function returns undefined.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function codeFromString(value) {
+    if (!stringToCode) {
+        stringToCode = {};
+        for (const value of Object.values(Code)) {
+            if (typeof value == "string") {
+                continue;
+            }
+            stringToCode[codeToString(value)] = value;
+        }
+    }
+    return stringToCode[value];
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-connect/content-type.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Regular Expression that matches any valid Connect Content-Type header value.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare const contentTypeRegExp: RegExp;
+/**
+ * Regular Expression that matches a Connect unary Content-Type header value.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare const contentTypeUnaryRegExp: RegExp;
+/**
+ * Regular Expression that matches a Connect streaming Content-Type header value.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare const contentTypeStreamRegExp: RegExp;
+export declare const contentTypeUnaryProto = "application/proto";
+export declare const contentTypeUnaryJson = "application/json";
+export declare const contentTypeStreamProto = "application/connect+proto";
+export declare const contentTypeStreamJson = "application/connect+json";
+/**
+ * Parse a Connect Content-Type header.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function parseContentType(contentType: string | null): {
+    stream: boolean;
+    binary: boolean;
+} | undefined;
+/**
+ * Parse a Connect Get encoding query parameter.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function parseEncodingQuery(encoding: string | null): {
+    stream: boolean;
+    binary: boolean;
+} | undefined;