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

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

@@ -0,0 +1,19 @@
+/**
+ * In unary RPCs, Connect transports trailing metadata as response header
+ * fields, prefixed with "trailer-".
+ *
+ * This function demuxes headers and trailers into two separate Headers
+ * objects.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function trailerDemux(header: Headers): [header: Headers, trailer: Headers];
+/**
+ * In unary RPCs, Connect transports trailing metadata as response header
+ * fields, prefixed with "trailer-".
+ *
+ * This function muxes a header and a trailer into a single Headers object.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function trailerMux(header: Headers, trailer: Headers): Headers;

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

@@ -0,0 +1,49 @@
+// 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.
+/**
+ * In unary RPCs, Connect transports trailing metadata as response header
+ * fields, prefixed with "trailer-".
+ *
+ * This function demuxes headers and trailers into two separate Headers
+ * objects.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function trailerDemux(header) {
+    const h = new Headers(), t = new Headers();
+    header.forEach((value, key) => {
+        if (key.toLowerCase().startsWith("trailer-")) {
+            t.append(key.substring(8), value);
+        }
+        else {
+            h.append(key, value);
+        }
+    });
+    return [h, t];
+}
+/**
+ * In unary RPCs, Connect transports trailing metadata as response header
+ * fields, prefixed with "trailer-".
+ *
+ * This function muxes a header and a trailer into a single Headers object.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function trailerMux(header, trailer) {
+    const h = new Headers(header);
+    trailer.forEach((value, key) => {
+        h.append(`trailer-${key}`, value);
+    });
+    return h;
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-connect/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 Connect protocol.
+ */
+export declare function createTransport(opt: CommonTransportOptions): Transport;

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

@@ -0,0 +1,211 @@
+// 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 { MethodIdempotency } from "@bufbuild/protobuf";
+import { requestHeaderWithCompression } from "./request-header.js";
+import { headerUnaryContentLength, headerUnaryEncoding } from "./headers.js";
+import { validateResponseWithCompression } from "./validate-response.js";
+import { trailerDemux } from "./trailer-mux.js";
+import { errorFromJsonBytes } from "./error-json.js";
+import { createEndStreamSerialization, endStreamFlag } from "./end-stream.js";
+import { transformConnectPostToGetRequest } from "./get-request.js";
+import { Code } from "../code.js";
+import { ConnectError } from "../connect-error.js";
+import { appendHeaders } from "../http-headers.js";
+import { createAsyncIterable, pipeTo, sinkAllBytes, pipe, transformSerializeEnvelope, transformCompressEnvelope, transformJoinEnvelopes, 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";
+/**
+ * Create a Transport for the Connect 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(method.kind, opt.useBinaryFormat, timeoutMs, header, opt.acceptCompression, opt.sendCompression, true),
+                    contextValues: contextValues !== null && contextValues !== void 0 ? contextValues : createContextValues(),
+                    message,
+                },
+                next: async (req) => {
+                    var _a;
+                    let requestBody = serialization
+                        .getI(opt.useBinaryFormat)
+                        .serialize(req.message);
+                    if (opt.sendCompression &&
+                        requestBody.byteLength > opt.compressMinBytes) {
+                        requestBody = await opt.sendCompression.compress(requestBody);
+                        req.header.set(headerUnaryEncoding, opt.sendCompression.name);
+                    }
+                    else {
+                        req.header.delete(headerUnaryEncoding);
+                    }
+                    const useGet = opt.useHttpGet === true &&
+                        method.idempotency === MethodIdempotency.NoSideEffects;
+                    let body;
+                    if (useGet) {
+                        req = transformConnectPostToGetRequest(req, requestBody, opt.useBinaryFormat);
+                    }
+                    else {
+                        body = createAsyncIterable([requestBody]);
+                    }
+                    const universalResponse = await opt.httpClient({
+                        url: req.url,
+                        method: (_a = req.init.method) !== null && _a !== void 0 ? _a : "POST",
+                        header: req.header,
+                        signal: req.signal,
+                        body,
+                    });
+                    const { compression, isUnaryError, unaryError } = validateResponseWithCompression(method.kind, opt.acceptCompression, opt.useBinaryFormat, universalResponse.status, universalResponse.header);
+                    const [header, trailer] = trailerDemux(universalResponse.header);
+                    let responseBody = await pipeTo(universalResponse.body, sinkAllBytes(opt.readMaxBytes, universalResponse.header.get(headerUnaryContentLength)), { propagateDownStreamError: false });
+                    if (compression) {
+                        responseBody = await compression.decompress(responseBody, opt.readMaxBytes);
+                    }
+                    if (isUnaryError) {
+                        throw errorFromJsonBytes(responseBody, appendHeaders(header, trailer), unaryError);
+                    }
+                    return {
+                        stream: false,
+                        service,
+                        method,
+                        header,
+                        message: serialization
+                            .getO(opt.useBinaryFormat)
+                            .parse(responseBody),
+                        trailer,
+                    };
+                },
+            });
+        },
+        async stream(service, method, signal, timeoutMs, header, input, contextValues) {
+            const serialization = createMethodSerializationLookup(method, opt.binaryOptions, opt.jsonOptions, opt);
+            const endStreamSerialization = createEndStreamSerialization(opt.jsonOptions);
+            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(method.kind, 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 } = validateResponseWithCompression(method.kind, opt.acceptCompression, opt.useBinaryFormat, uRes.status, uRes.header);
+                    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), endStreamFlag, endStreamSerialization), function (iterable) {
+                            return __asyncGenerator(this, arguments, function* () {
+                                var _a, e_1, _b, _c;
+                                let endStreamReceived = false;
+                                try {
+                                    for (var _d = true, iterable_1 = __asyncValues(iterable), iterable_1_1; iterable_1_1 = yield __await(iterable_1.next()), _a = iterable_1_1.done, !_a; _d = true) {
+                                        _c = iterable_1_1.value;
+                                        _d = false;
+                                        const chunk = _c;
+                                        if (chunk.end) {
+                                            if (endStreamReceived) {
+                                                throw new ConnectError("protocol error: received extra EndStreamResponse", Code.InvalidArgument);
+                                            }
+                                            endStreamReceived = true;
+                                            if (chunk.value.error) {
+                                                const error = chunk.value.error;
+                                                uRes.header.forEach((value, key) => {
+                                                    error.metadata.append(key, value);
+                                                });
+                                                throw error;
+                                            }
+                                            chunk.value.metadata.forEach((value, key) => res.trailer.set(key, value));
+                                            continue;
+                                        }
+                                        if (endStreamReceived) {
+                                            throw new ConnectError("protocol error: received extra message after EndStreamResponse", Code.InvalidArgument);
+                                        }
+                                        yield yield __await(chunk.value);
+                                    }
+                                }
+                                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                                finally {
+                                    try {
+                                        if (!_d && !_a && (_b = iterable_1.return)) yield __await(_b.call(iterable_1));
+                                    }
+                                    finally { if (e_1) throw e_1.error; }
+                                }
+                                if (!endStreamReceived) {
+                                    throw new ConnectError("protocol error: missing EndStreamResponse", Code.InvalidArgument);
+                                }
+                            });
+                        }, { propagateDownStreamError: true }) });
+                    return res;
+                },
+            });
+        },
+    };
+}

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

@@ -0,0 +1,30 @@
+import { MethodKind } from "@bufbuild/protobuf";
+import { ConnectError } from "../connect-error.js";
+import type { Compression } from "../protocol/compression.js";
+/**
+ * Validates response status and header for the Connect protocol.
+ * Throws a ConnectError if the header indicates an error, or if
+ * the content type is unexpected, with the following exception:
+ * For unary RPCs with an HTTP error status, this returns an error
+ * derived from the HTTP status instead of throwing it, giving an
+ * implementation a chance to parse a Connect error from the wire.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function validateResponse(methodKind: MethodKind, useBinaryFormat: boolean, status: number, headers: Headers): {
+    isUnaryError: false;
+    unaryError?: undefined;
+} | {
+    isUnaryError: true;
+    unaryError: ConnectError;
+};
+/**
+ * Validates response status and header for the Connect protocol.
+ * This function is identical to validateResponse(), but also verifies
+ * that a given encoding header is acceptable.
+ *
+ * @private
+ */
+export declare function validateResponseWithCompression(methodKind: MethodKind, acceptCompression: Compression[], useBinaryFormat: boolean, status: number, headers: Headers): ReturnType<typeof validateResponse> & {
+    compression: Compression | undefined;
+};

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

@@ -0,0 +1,68 @@
+// 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 { Code } from "../code.js";
+import { codeFromHttpStatus } from "./http-status.js";
+import { ConnectError } from "../connect-error.js";
+import { parseContentType } from "./content-type.js";
+import { headerContentType, headerStreamEncoding, headerUnaryEncoding, } from "./headers.js";
+/**
+ * Validates response status and header for the Connect protocol.
+ * Throws a ConnectError if the header indicates an error, or if
+ * the content type is unexpected, with the following exception:
+ * For unary RPCs with an HTTP error status, this returns an error
+ * derived from the HTTP status instead of throwing it, giving an
+ * implementation a chance to parse a Connect error from the wire.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function validateResponse(methodKind, useBinaryFormat, status, headers) {
+    const mimeType = headers.get(headerContentType);
+    const parsedType = parseContentType(mimeType);
+    if (status !== 200) {
+        const errorFromStatus = new ConnectError(`HTTP ${status}`, codeFromHttpStatus(status), headers);
+        // If parsedType is defined and it is not binary, then this is a unary JSON response
+        if (methodKind == MethodKind.Unary && parsedType && !parsedType.binary) {
+            return { isUnaryError: true, unaryError: errorFromStatus };
+        }
+        throw errorFromStatus;
+    }
+    const allowedContentType = {
+        binary: useBinaryFormat,
+        stream: methodKind !== MethodKind.Unary,
+    };
+    if ((parsedType === null || parsedType === void 0 ? void 0 : parsedType.binary) !== allowedContentType.binary ||
+        parsedType.stream !== allowedContentType.stream) {
+        throw new ConnectError(`unsupported content type ${mimeType}`, parsedType === undefined ? Code.Unknown : Code.Internal, headers);
+    }
+    return { isUnaryError: false };
+}
+/**
+ * Validates response status and header for the Connect protocol.
+ * This function is identical to validateResponse(), but also verifies
+ * that a given encoding header is acceptable.
+ *
+ * @private
+ */
+export function validateResponseWithCompression(methodKind, acceptCompression, useBinaryFormat, status, headers) {
+    let compression;
+    const encoding = headers.get(methodKind == MethodKind.Unary ? headerUnaryEncoding : headerStreamEncoding);
+    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 Object.assign({ compression }, validateResponse(methodKind, useBinaryFormat, status, headers));
+}

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

@@ -0,0 +1,20 @@
+/**
+ * The only know value for the header Connect-Protocol-Version.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare const protocolVersion = "1";
+/**
+ * Requires the Connect-Protocol-Version header to be present with the expected
+ * value. Raises a ConnectError with Code.InvalidArgument otherwise.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function requireProtocolVersionHeader(requestHeader: Headers): void;
+/**
+ * Requires the connect query parameter to be present with the expected value.
+ * Raises a ConnectError with Code.InvalidArgument otherwise.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function requireProtocolVersionParam(queryParams: URLSearchParams): void;

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

@@ -0,0 +1,53 @@
+// 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 { headerProtocolVersion } from "./headers.js";
+import { paramConnectVersion } from "./query-params.js";
+import { ConnectError } from "../connect-error.js";
+import { Code } from "../code.js";
+/**
+ * The only know value for the header Connect-Protocol-Version.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export const protocolVersion = "1";
+/**
+ * Requires the Connect-Protocol-Version header to be present with the expected
+ * value. Raises a ConnectError with Code.InvalidArgument otherwise.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function requireProtocolVersionHeader(requestHeader) {
+    const v = requestHeader.get(headerProtocolVersion);
+    if (v === null) {
+        throw new ConnectError(`missing required header: set ${headerProtocolVersion} to "${protocolVersion}"`, Code.InvalidArgument);
+    }
+    else if (v !== protocolVersion) {
+        throw new ConnectError(`${headerProtocolVersion} must be "${protocolVersion}": got "${v}"`, Code.InvalidArgument);
+    }
+}
+/**
+ * Requires the connect query parameter to be present with the expected value.
+ * Raises a ConnectError with Code.InvalidArgument otherwise.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function requireProtocolVersionParam(queryParams) {
+    const v = queryParams.get(paramConnectVersion);
+    if (v === null) {
+        throw new ConnectError(`missing required parameter: set ${paramConnectVersion} to "v${protocolVersion}"`, Code.InvalidArgument);
+    }
+    else if (v !== `v${protocolVersion}`) {
+        throw new ConnectError(`${paramConnectVersion} must be "v${protocolVersion}": got "${v}"`, Code.InvalidArgument);
+    }
+}

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

@@ -0,0 +1,16 @@
+/**
+ * Regular Expression that matches any valid gRPC Content-Type header value.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare const contentTypeRegExp: RegExp;
+export declare const contentTypeProto = "application/grpc+proto";
+export declare const contentTypeJson = "application/grpc+json";
+/**
+ * Parse a gRPC Content-Type header.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function parseContentType(contentType: string | null): {
+    binary: boolean;
+} | undefined;

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

@@ -0,0 +1,34 @@
+// 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.
+/**
+ * Regular Expression that matches any valid gRPC Content-Type header value.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export const contentTypeRegExp = /^application\/grpc(?:\+(?:(json)(?:; ?charset=utf-?8)?|proto))?$/i;
+export const contentTypeProto = "application/grpc+proto";
+export const contentTypeJson = "application/grpc+json";
+/**
+ * Parse a gRPC Content-Type header.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function parseContentType(contentType) {
+    const match = contentType === null || contentType === void 0 ? void 0 : contentType.match(contentTypeRegExp);
+    if (!match) {
+        return undefined;
+    }
+    const binary = !match[1];
+    return { binary };
+}

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

@@ -0,0 +1,89 @@
+import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
+import { Any, Message, proto3 } from "@bufbuild/protobuf";
+/**
+ * The `Status` type defines a logical error model that is suitable for different
+ * programming environments, including REST APIs and RPC APIs. It is used by
+ * [gRPC](https://github.com/grpc). The error model is designed to be:
+ *
+ * - Simple to use and understand for most users
+ * - Flexible enough to meet unexpected needs
+ *
+ * # Overview
+ *
+ * The `Status` message contains three pieces of data: error code, error message,
+ * and error details. The error code should be an enum value of
+ * [google.rpc.Code][google.rpc.Code], but it may accept additional error codes if needed.  The
+ * error message should be a developer-facing English message that helps
+ * developers *understand* and *resolve* the error. If a localized user-facing
+ * error message is needed, put the localized message in the error details or
+ * localize it in the client. The optional error details may contain arbitrary
+ * information about the error. There is a predefined set of error detail types
+ * in the package `google.rpc` which can be used for common error conditions.
+ *
+ * # Language mapping
+ *
+ * The `Status` message is the logical representation of the error model, but it
+ * is not necessarily the actual wire format. When the `Status` message is
+ * exposed in different client libraries and different wire protocols, it can be
+ * mapped differently. For example, it will likely be mapped to some exceptions
+ * in Java, but more likely mapped to some error codes in C.
+ *
+ * # Other uses
+ *
+ * The error model and the `Status` message can be used in a variety of
+ * environments, either with or without APIs, to provide a
+ * consistent developer experience across different environments.
+ *
+ * Example uses of this error model include:
+ *
+ * - Partial errors. If a service needs to return partial errors to the client,
+ *     it may embed the `Status` in the normal response to indicate the partial
+ *     errors.
+ *
+ * - Workflow errors. A typical workflow has multiple steps. Each step may
+ *     have a `Status` message for error reporting purpose.
+ *
+ * - Batch operations. If a client uses batch request and batch response, the
+ *     `Status` message should be used directly inside batch response, one for
+ *     each error sub-response.
+ *
+ * - Asynchronous operations. If an API call embeds asynchronous operation
+ *     results in its response, the status of those operations should be
+ *     represented directly using the `Status` message.
+ *
+ * - Logging. If some API errors are stored in logs, the message `Status` could
+ *     be used directly after any stripping needed for security/privacy reasons.
+ *
+ * @generated from message google.rpc.Status
+ */
+export declare class Status extends Message<Status> {
+    /**
+     * The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code].
+     *
+     * @generated from field: int32 code = 1;
+     */
+    code: number;
+    /**
+     * A developer-facing error message, which should be in English. Any
+     * user-facing error message should be localized and sent in the
+     * [google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client.
+     *
+     * @generated from field: string message = 2;
+     */
+    message: string;
+    /**
+     * A list of messages that carry the error details.  There will be a
+     * common set of message types for APIs to use.
+     *
+     * @generated from field: repeated google.protobuf.Any details = 3;
+     */
+    details: Any[];
+    constructor(data?: PartialMessage<Status>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "google.rpc.Status";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Status;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Status;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Status;
+    static equals(a: Status | PlainMessage<Status> | undefined, b: Status | PlainMessage<Status> | undefined): boolean;
+}