@canton-network/core-ledger-proto 0.10.0 → 0.11.0

package/dist/cjs/_proto/google/protobuf/timestamp.cjs

@@ -0,0 +1,196 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var timestamp_exports = {};
+__export(timestamp_exports, {
+  Timestamp: () => Timestamp
+});
+module.exports = __toCommonJS(timestamp_exports);
+var import_runtime = require("@protobuf-ts/runtime");
+var import_runtime2 = require("@protobuf-ts/runtime");
+var import_runtime3 = require("@protobuf-ts/runtime");
+var import_runtime4 = require("@protobuf-ts/runtime");
+var import_runtime5 = require("@protobuf-ts/runtime");
+var import_runtime6 = require("@protobuf-ts/runtime");
+class Timestamp$Type extends import_runtime6.MessageType {
+  constructor() {
+    super("google.protobuf.Timestamp", [
+      {
+        no: 1,
+        name: "seconds",
+        kind: "scalar",
+        T: 3,
+        L: 0
+      },
+      {
+        no: 2,
+        name: "nanos",
+        kind: "scalar",
+        T: 5
+        /*ScalarType.INT32*/
+      }
+    ]);
+  }
+  /**
+   * Creates a new `Timestamp` for the current time.
+   */
+  now() {
+    const msg = this.create();
+    const ms = Date.now();
+    msg.seconds = import_runtime5.PbLong.from(Math.floor(ms / 1e3)).toBigInt();
+    msg.nanos = ms % 1e3 * 1e6;
+    return msg;
+  }
+  /**
+   * Converts a `Timestamp` to a JavaScript Date.
+   */
+  toDate(message) {
+    return new Date(
+      import_runtime5.PbLong.from(message.seconds).toNumber() * 1e3 + Math.ceil(message.nanos / 1e6)
+    );
+  }
+  /**
+   * Converts a JavaScript Date to a `Timestamp`.
+   */
+  fromDate(date) {
+    const msg = this.create();
+    const ms = date.getTime();
+    msg.seconds = import_runtime5.PbLong.from(Math.floor(ms / 1e3)).toBigInt();
+    msg.nanos = (ms % 1e3 + (ms < 0 && ms % 1e3 !== 0 ? 1e3 : 0)) * 1e6;
+    return msg;
+  }
+  /**
+   * In JSON format, the `Timestamp` type is encoded as a string
+   * in the RFC 3339 format.
+   */
+  internalJsonWrite(message, options) {
+    let ms = import_runtime5.PbLong.from(message.seconds).toNumber() * 1e3;
+    if (ms < Date.parse("0001-01-01T00:00:00Z") || ms > Date.parse("9999-12-31T23:59:59Z"))
+      throw new Error(
+        "Unable to encode Timestamp to JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive."
+      );
+    if (message.nanos < 0)
+      throw new Error(
+        "Unable to encode invalid Timestamp to JSON. Nanos must not be negative."
+      );
+    let z = "Z";
+    if (message.nanos > 0) {
+      let nanosStr = (message.nanos + 1e9).toString().substring(1);
+      if (nanosStr.substring(3) === "000000")
+        z = "." + nanosStr.substring(0, 3) + "Z";
+      else if (nanosStr.substring(6) === "000")
+        z = "." + nanosStr.substring(0, 6) + "Z";
+      else z = "." + nanosStr + "Z";
+    }
+    return new Date(ms).toISOString().replace(".000Z", z);
+  }
+  /**
+   * In JSON format, the `Timestamp` type is encoded as a string
+   * in the RFC 3339 format.
+   */
+  internalJsonRead(json, options, target) {
+    if (typeof json !== "string")
+      throw new Error(
+        "Unable to parse Timestamp from JSON " + (0, import_runtime4.typeofJsonValue)(json) + "."
+      );
+    let matches = json.match(
+      /^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:Z|\.([0-9]{3,9})Z|([+-][0-9][0-9]:[0-9][0-9]))$/
+    );
+    if (!matches)
+      throw new Error(
+        "Unable to parse Timestamp from JSON. Invalid format."
+      );
+    let ms = Date.parse(
+      matches[1] + "-" + matches[2] + "-" + matches[3] + "T" + matches[4] + ":" + matches[5] + ":" + matches[6] + (matches[8] ? matches[8] : "Z")
+    );
+    if (Number.isNaN(ms))
+      throw new Error(
+        "Unable to parse Timestamp from JSON. Invalid value."
+      );
+    if (ms < Date.parse("0001-01-01T00:00:00Z") || ms > Date.parse("9999-12-31T23:59:59Z"))
+      throw new globalThis.Error(
+        "Unable to parse Timestamp from JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive."
+      );
+    if (!target) target = this.create();
+    target.seconds = import_runtime5.PbLong.from(ms / 1e3).toBigInt();
+    target.nanos = 0;
+    if (matches[7])
+      target.nanos = parseInt("1" + matches[7] + "0".repeat(9 - matches[7].length)) - 1e9;
+    return target;
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.seconds = 0n;
+    message.nanos = 0;
+    if (value !== void 0)
+      (0, import_runtime3.reflectionMergePartial)(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* int64 seconds */
+        1:
+          message.seconds = reader.int64().toBigInt();
+          break;
+        case /* int32 nanos */
+        2:
+          message.nanos = reader.int32();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
+            );
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.seconds !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.seconds);
+    if (message.nanos !== 0)
+      writer.tag(2, import_runtime.WireType.Varint).int32(message.nanos);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const Timestamp = new Timestamp$Type();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Timestamp
+});
+//# sourceMappingURL=timestamp.cjs.map

package/dist/cjs/_proto/google/protobuf/timestamp.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/_proto/google/protobuf/timestamp.ts"],"sourcesContent":["// @generated by protobuf-ts 2.11.1 with parameter generate_dependencies\n// @generated from protobuf file \"google/protobuf/timestamp.proto\" (package \"google.protobuf\", syntax proto3)\n// tslint:disable\n//\n// Protocol Buffers - Google's data interchange format\n// Copyright 2008 Google Inc.  All rights reserved.\n// https://developers.google.com/protocol-buffers/\n//\n// Redistribution and use in source and binary forms, with or without\n// modification, are permitted provided that the following conditions are\n// met:\n//\n//     * Redistributions of source code must retain the above copyright\n// notice, this list of conditions and the following disclaimer.\n//     * Redistributions in binary form must reproduce the above\n// copyright notice, this list of conditions and the following disclaimer\n// in the documentation and/or other materials provided with the\n// distribution.\n//     * Neither the name of Google Inc. nor the names of its\n// contributors may be used to endorse or promote products derived from\n// this software without specific prior written permission.\n//\n// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n// \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n//\nimport type { BinaryWriteOptions } from '@protobuf-ts/runtime'\nimport type { IBinaryWriter } from '@protobuf-ts/runtime'\nimport { WireType } from '@protobuf-ts/runtime'\nimport type { BinaryReadOptions } from '@protobuf-ts/runtime'\nimport type { IBinaryReader } from '@protobuf-ts/runtime'\nimport { UnknownFieldHandler } from '@protobuf-ts/runtime'\nimport type { PartialMessage } from '@protobuf-ts/runtime'\nimport { reflectionMergePartial } from '@protobuf-ts/runtime'\nimport { typeofJsonValue } from '@protobuf-ts/runtime'\nimport type { JsonValue } from '@protobuf-ts/runtime'\nimport type { JsonReadOptions } from '@protobuf-ts/runtime'\nimport type { JsonWriteOptions } from '@protobuf-ts/runtime'\nimport { PbLong } from '@protobuf-ts/runtime'\nimport { MessageType } from '@protobuf-ts/runtime'\n/**\n * A Timestamp represents a point in time independent of any time zone or local\n * calendar, encoded as a count of seconds and fractions of seconds at\n * nanosecond resolution. The count is relative to an epoch at UTC midnight on\n * January 1, 1970, in the proleptic Gregorian calendar which extends the\n * Gregorian calendar backwards to year one.\n *\n * All minutes are 60 seconds long. Leap seconds are \"smeared\" so that no leap\n * second table is needed for interpretation, using a [24-hour linear\n * smear](https://developers.google.com/time/smear).\n *\n * The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By\n * restricting to that range, we ensure that we can convert to and from [RFC\n * 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.\n *\n * # Examples\n *\n * Example 1: Compute Timestamp from POSIX `time()`.\n *\n *     Timestamp timestamp;\n *     timestamp.set_seconds(time(NULL));\n *     timestamp.set_nanos(0);\n *\n * Example 2: Compute Timestamp from POSIX `gettimeofday()`.\n *\n *     struct timeval tv;\n *     gettimeofday(&tv, NULL);\n *\n *     Timestamp timestamp;\n *     timestamp.set_seconds(tv.tv_sec);\n *     timestamp.set_nanos(tv.tv_usec * 1000);\n *\n * Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.\n *\n *     FILETIME ft;\n *     GetSystemTimeAsFileTime(&ft);\n *     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;\n *\n *     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z\n *     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.\n *     Timestamp timestamp;\n *     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));\n *     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));\n *\n * Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.\n *\n *     long millis = System.currentTimeMillis();\n *\n *     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)\n *         .setNanos((int) ((millis % 1000) * 1000000)).build();\n *\n *\n * Example 5: Compute Timestamp from Java `Instant.now()`.\n *\n *     Instant now = Instant.now();\n *\n *     Timestamp timestamp =\n *         Timestamp.newBuilder().setSeconds(now.getEpochSecond())\n *             .setNanos(now.getNano()).build();\n *\n *\n * Example 6: Compute Timestamp from current time in Python.\n *\n *     timestamp = Timestamp()\n *     timestamp.GetCurrentTime()\n *\n * # JSON Mapping\n *\n * In JSON format, the Timestamp type is encoded as a string in the\n * [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the\n * format is \"{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z\"\n * where {year} is always expressed using four digits while {month}, {day},\n * {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional\n * seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),\n * are optional. The \"Z\" suffix indicates the timezone (\"UTC\"); the timezone\n * is required. A proto3 JSON serializer should always use UTC (as indicated by\n * \"Z\") when printing the Timestamp type and a proto3 JSON parser should be\n * able to accept both UTC and other timezones (as indicated by an offset).\n *\n * For example, \"2017-01-15T01:30:15.01Z\" encodes 15.01 seconds past\n * 01:30 UTC on January 15, 2017.\n *\n * In JavaScript, one can convert a Date object to this format using the\n * standard\n * [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)\n * method. In Python, a standard `datetime.datetime` object can be converted\n * to this format using\n * [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with\n * the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use\n * the Joda Time's [`ISODateTimeFormat.dateTime()`](\n * http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D\n * ) to obtain a formatter capable of generating timestamps in this format.\n *\n *\n *\n * @generated from protobuf message google.protobuf.Timestamp\n */\nexport interface Timestamp {\n    /**\n     * Represents seconds of UTC time since Unix epoch\n     * 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to\n     * 9999-12-31T23:59:59Z inclusive.\n     *\n     * @generated from protobuf field: int64 seconds = 1\n     */\n    seconds: bigint\n    /**\n     * Non-negative fractions of a second at nanosecond resolution. Negative\n     * second values with fractions must still have non-negative nanos values\n     * that count forward in time. Must be from 0 to 999,999,999\n     * inclusive.\n     *\n     * @generated from protobuf field: int32 nanos = 2\n     */\n    nanos: number\n}\n// @generated message type with reflection information, may provide speed optimized methods\nclass Timestamp$Type extends MessageType<Timestamp> {\n    constructor() {\n        super('google.protobuf.Timestamp', [\n            {\n                no: 1,\n                name: 'seconds',\n                kind: 'scalar',\n                T: 3 /*ScalarType.INT64*/,\n                L: 0 /*LongType.BIGINT*/,\n            },\n            { no: 2, name: 'nanos', kind: 'scalar', T: 5 /*ScalarType.INT32*/ },\n        ])\n    }\n    /**\n     * Creates a new `Timestamp` for the current time.\n     */\n    now(): Timestamp {\n        const msg = this.create()\n        const ms = Date.now()\n        msg.seconds = PbLong.from(Math.floor(ms / 1000)).toBigInt()\n        msg.nanos = (ms % 1000) * 1000000\n        return msg\n    }\n    /**\n     * Converts a `Timestamp` to a JavaScript Date.\n     */\n    toDate(message: Timestamp): Date {\n        return new Date(\n            PbLong.from(message.seconds).toNumber() * 1000 +\n                Math.ceil(message.nanos / 1000000)\n        )\n    }\n    /**\n     * Converts a JavaScript Date to a `Timestamp`.\n     */\n    fromDate(date: Date): Timestamp {\n        const msg = this.create()\n        const ms = date.getTime()\n        msg.seconds = PbLong.from(Math.floor(ms / 1000)).toBigInt()\n        msg.nanos =\n            ((ms % 1000) + (ms < 0 && ms % 1000 !== 0 ? 1000 : 0)) * 1000000\n        return msg\n    }\n    /**\n     * In JSON format, the `Timestamp` type is encoded as a string\n     * in the RFC 3339 format.\n     */\n    internalJsonWrite(\n        message: Timestamp,\n        options: JsonWriteOptions\n    ): JsonValue {\n        let ms = PbLong.from(message.seconds).toNumber() * 1000\n        if (\n            ms < Date.parse('0001-01-01T00:00:00Z') ||\n            ms > Date.parse('9999-12-31T23:59:59Z')\n        )\n            throw new Error(\n                'Unable to encode Timestamp to JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.'\n            )\n        if (message.nanos < 0)\n            throw new Error(\n                'Unable to encode invalid Timestamp to JSON. Nanos must not be negative.'\n            )\n        let z = 'Z'\n        if (message.nanos > 0) {\n            let nanosStr = (message.nanos + 1000000000).toString().substring(1)\n            if (nanosStr.substring(3) === '000000')\n                z = '.' + nanosStr.substring(0, 3) + 'Z'\n            else if (nanosStr.substring(6) === '000')\n                z = '.' + nanosStr.substring(0, 6) + 'Z'\n            else z = '.' + nanosStr + 'Z'\n        }\n        return new Date(ms).toISOString().replace('.000Z', z)\n    }\n    /**\n     * In JSON format, the `Timestamp` type is encoded as a string\n     * in the RFC 3339 format.\n     */\n    internalJsonRead(\n        json: JsonValue,\n        options: JsonReadOptions,\n        target?: Timestamp\n    ): Timestamp {\n        if (typeof json !== 'string')\n            throw new Error(\n                'Unable to parse Timestamp from JSON ' +\n                    typeofJsonValue(json) +\n                    '.'\n            )\n        let matches = json.match(\n            /^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:Z|\\.([0-9]{3,9})Z|([+-][0-9][0-9]:[0-9][0-9]))$/\n        )\n        if (!matches)\n            throw new Error(\n                'Unable to parse Timestamp from JSON. Invalid format.'\n            )\n        let ms = Date.parse(\n            matches[1] +\n                '-' +\n                matches[2] +\n                '-' +\n                matches[3] +\n                'T' +\n                matches[4] +\n                ':' +\n                matches[5] +\n                ':' +\n                matches[6] +\n                (matches[8] ? matches[8] : 'Z')\n        )\n        if (Number.isNaN(ms))\n            throw new Error(\n                'Unable to parse Timestamp from JSON. Invalid value.'\n            )\n        if (\n            ms < Date.parse('0001-01-01T00:00:00Z') ||\n            ms > Date.parse('9999-12-31T23:59:59Z')\n        )\n            throw new globalThis.Error(\n                'Unable to parse Timestamp from JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.'\n            )\n        if (!target) target = this.create()\n        target.seconds = PbLong.from(ms / 1000).toBigInt()\n        target.nanos = 0\n        if (matches[7])\n            target.nanos =\n                parseInt('1' + matches[7] + '0'.repeat(9 - matches[7].length)) -\n                1000000000\n        return target\n    }\n    create(value?: PartialMessage<Timestamp>): Timestamp {\n        const message = globalThis.Object.create(this.messagePrototype!)\n        message.seconds = 0n\n        message.nanos = 0\n        if (value !== undefined)\n            reflectionMergePartial<Timestamp>(this, message, value)\n        return message\n    }\n    internalBinaryRead(\n        reader: IBinaryReader,\n        length: number,\n        options: BinaryReadOptions,\n        target?: Timestamp\n    ): Timestamp {\n        let message = target ?? this.create(),\n            end = reader.pos + length\n        while (reader.pos < end) {\n            let [fieldNo, wireType] = reader.tag()\n            switch (fieldNo) {\n                case /* int64 seconds */ 1:\n                    message.seconds = reader.int64().toBigInt()\n                    break\n                case /* int32 nanos */ 2:\n                    message.nanos = reader.int32()\n                    break\n                default:\n                    let u = options.readUnknownField\n                    if (u === 'throw')\n                        throw new globalThis.Error(\n                            `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`\n                        )\n                    let d = reader.skip(wireType)\n                    if (u !== false)\n                        (u === true ? UnknownFieldHandler.onRead : u)(\n                            this.typeName,\n                            message,\n                            fieldNo,\n                            wireType,\n                            d\n                        )\n            }\n        }\n        return message\n    }\n    internalBinaryWrite(\n        message: Timestamp,\n        writer: IBinaryWriter,\n        options: BinaryWriteOptions\n    ): IBinaryWriter {\n        /* int64 seconds = 1; */\n        if (message.seconds !== 0n)\n            writer.tag(1, WireType.Varint).int64(message.seconds)\n        /* int32 nanos = 2; */\n        if (message.nanos !== 0)\n            writer.tag(2, WireType.Varint).int32(message.nanos)\n        let u = options.writeUnknownFields\n        if (u !== false)\n            (u == true ? UnknownFieldHandler.onWrite : u)(\n                this.typeName,\n                message,\n                writer\n            )\n        return writer\n    }\n}\n/**\n * @generated MessageType for protobuf message google.protobuf.Timestamp\n */\nexport const Timestamp = new Timestamp$Type()\n"],"mappings":"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","names":["import_runtime"]}

package/dist/cjs/_proto/google/protobuf/timestamp.d.cjs

@@ -0,0 +1,17 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var timestamp_d_exports = {};
+module.exports = __toCommonJS(timestamp_d_exports);
+//# sourceMappingURL=timestamp.d.cjs.map

package/dist/cjs/_proto/google/protobuf/timestamp.d.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/_proto/google/protobuf/timestamp.ts"],"sourcesContent":["// @generated by protobuf-ts 2.11.1 with parameter generate_dependencies\n// @generated from protobuf file \"google/protobuf/timestamp.proto\" (package \"google.protobuf\", syntax proto3)\n// tslint:disable\n//\n// Protocol Buffers - Google's data interchange format\n// Copyright 2008 Google Inc.  All rights reserved.\n// https://developers.google.com/protocol-buffers/\n//\n// Redistribution and use in source and binary forms, with or without\n// modification, are permitted provided that the following conditions are\n// met:\n//\n//     * Redistributions of source code must retain the above copyright\n// notice, this list of conditions and the following disclaimer.\n//     * Redistributions in binary form must reproduce the above\n// copyright notice, this list of conditions and the following disclaimer\n// in the documentation and/or other materials provided with the\n// distribution.\n//     * Neither the name of Google Inc. nor the names of its\n// contributors may be used to endorse or promote products derived from\n// this software without specific prior written permission.\n//\n// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n// \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n//\nimport type { BinaryWriteOptions } from '@protobuf-ts/runtime'\nimport type { IBinaryWriter } from '@protobuf-ts/runtime'\nimport { WireType } from '@protobuf-ts/runtime'\nimport type { BinaryReadOptions } from '@protobuf-ts/runtime'\nimport type { IBinaryReader } from '@protobuf-ts/runtime'\nimport { UnknownFieldHandler } from '@protobuf-ts/runtime'\nimport type { PartialMessage } from '@protobuf-ts/runtime'\nimport { reflectionMergePartial } from '@protobuf-ts/runtime'\nimport { typeofJsonValue } from '@protobuf-ts/runtime'\nimport type { JsonValue } from '@protobuf-ts/runtime'\nimport type { JsonReadOptions } from '@protobuf-ts/runtime'\nimport type { JsonWriteOptions } from '@protobuf-ts/runtime'\nimport { PbLong } from '@protobuf-ts/runtime'\nimport { MessageType } from '@protobuf-ts/runtime'\n/**\n * A Timestamp represents a point in time independent of any time zone or local\n * calendar, encoded as a count of seconds and fractions of seconds at\n * nanosecond resolution. The count is relative to an epoch at UTC midnight on\n * January 1, 1970, in the proleptic Gregorian calendar which extends the\n * Gregorian calendar backwards to year one.\n *\n * All minutes are 60 seconds long. Leap seconds are \"smeared\" so that no leap\n * second table is needed for interpretation, using a [24-hour linear\n * smear](https://developers.google.com/time/smear).\n *\n * The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By\n * restricting to that range, we ensure that we can convert to and from [RFC\n * 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.\n *\n * # Examples\n *\n * Example 1: Compute Timestamp from POSIX `time()`.\n *\n *     Timestamp timestamp;\n *     timestamp.set_seconds(time(NULL));\n *     timestamp.set_nanos(0);\n *\n * Example 2: Compute Timestamp from POSIX `gettimeofday()`.\n *\n *     struct timeval tv;\n *     gettimeofday(&tv, NULL);\n *\n *     Timestamp timestamp;\n *     timestamp.set_seconds(tv.tv_sec);\n *     timestamp.set_nanos(tv.tv_usec * 1000);\n *\n * Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.\n *\n *     FILETIME ft;\n *     GetSystemTimeAsFileTime(&ft);\n *     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;\n *\n *     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z\n *     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.\n *     Timestamp timestamp;\n *     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));\n *     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));\n *\n * Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.\n *\n *     long millis = System.currentTimeMillis();\n *\n *     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)\n *         .setNanos((int) ((millis % 1000) * 1000000)).build();\n *\n *\n * Example 5: Compute Timestamp from Java `Instant.now()`.\n *\n *     Instant now = Instant.now();\n *\n *     Timestamp timestamp =\n *         Timestamp.newBuilder().setSeconds(now.getEpochSecond())\n *             .setNanos(now.getNano()).build();\n *\n *\n * Example 6: Compute Timestamp from current time in Python.\n *\n *     timestamp = Timestamp()\n *     timestamp.GetCurrentTime()\n *\n * # JSON Mapping\n *\n * In JSON format, the Timestamp type is encoded as a string in the\n * [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the\n * format is \"{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z\"\n * where {year} is always expressed using four digits while {month}, {day},\n * {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional\n * seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),\n * are optional. The \"Z\" suffix indicates the timezone (\"UTC\"); the timezone\n * is required. A proto3 JSON serializer should always use UTC (as indicated by\n * \"Z\") when printing the Timestamp type and a proto3 JSON parser should be\n * able to accept both UTC and other timezones (as indicated by an offset).\n *\n * For example, \"2017-01-15T01:30:15.01Z\" encodes 15.01 seconds past\n * 01:30 UTC on January 15, 2017.\n *\n * In JavaScript, one can convert a Date object to this format using the\n * standard\n * [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)\n * method. In Python, a standard `datetime.datetime` object can be converted\n * to this format using\n * [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with\n * the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use\n * the Joda Time's [`ISODateTimeFormat.dateTime()`](\n * http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D\n * ) to obtain a formatter capable of generating timestamps in this format.\n *\n *\n *\n * @generated from protobuf message google.protobuf.Timestamp\n */\nexport interface Timestamp {\n    /**\n     * Represents seconds of UTC time since Unix epoch\n     * 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to\n     * 9999-12-31T23:59:59Z inclusive.\n     *\n     * @generated from protobuf field: int64 seconds = 1\n     */\n    seconds: bigint\n    /**\n     * Non-negative fractions of a second at nanosecond resolution. Negative\n     * second values with fractions must still have non-negative nanos values\n     * that count forward in time. Must be from 0 to 999,999,999\n     * inclusive.\n     *\n     * @generated from protobuf field: int32 nanos = 2\n     */\n    nanos: number\n}\n// @generated message type with reflection information, may provide speed optimized methods\nclass Timestamp$Type extends MessageType<Timestamp> {\n    constructor() {\n        super('google.protobuf.Timestamp', [\n            {\n                no: 1,\n                name: 'seconds',\n                kind: 'scalar',\n                T: 3 /*ScalarType.INT64*/,\n                L: 0 /*LongType.BIGINT*/,\n            },\n            { no: 2, name: 'nanos', kind: 'scalar', T: 5 /*ScalarType.INT32*/ },\n        ])\n    }\n    /**\n     * Creates a new `Timestamp` for the current time.\n     */\n    now(): Timestamp {\n        const msg = this.create()\n        const ms = Date.now()\n        msg.seconds = PbLong.from(Math.floor(ms / 1000)).toBigInt()\n        msg.nanos = (ms % 1000) * 1000000\n        return msg\n    }\n    /**\n     * Converts a `Timestamp` to a JavaScript Date.\n     */\n    toDate(message: Timestamp): Date {\n        return new Date(\n            PbLong.from(message.seconds).toNumber() * 1000 +\n                Math.ceil(message.nanos / 1000000)\n        )\n    }\n    /**\n     * Converts a JavaScript Date to a `Timestamp`.\n     */\n    fromDate(date: Date): Timestamp {\n        const msg = this.create()\n        const ms = date.getTime()\n        msg.seconds = PbLong.from(Math.floor(ms / 1000)).toBigInt()\n        msg.nanos =\n            ((ms % 1000) + (ms < 0 && ms % 1000 !== 0 ? 1000 : 0)) * 1000000\n        return msg\n    }\n    /**\n     * In JSON format, the `Timestamp` type is encoded as a string\n     * in the RFC 3339 format.\n     */\n    internalJsonWrite(\n        message: Timestamp,\n        options: JsonWriteOptions\n    ): JsonValue {\n        let ms = PbLong.from(message.seconds).toNumber() * 1000\n        if (\n            ms < Date.parse('0001-01-01T00:00:00Z') ||\n            ms > Date.parse('9999-12-31T23:59:59Z')\n        )\n            throw new Error(\n                'Unable to encode Timestamp to JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.'\n            )\n        if (message.nanos < 0)\n            throw new Error(\n                'Unable to encode invalid Timestamp to JSON. Nanos must not be negative.'\n            )\n        let z = 'Z'\n        if (message.nanos > 0) {\n            let nanosStr = (message.nanos + 1000000000).toString().substring(1)\n            if (nanosStr.substring(3) === '000000')\n                z = '.' + nanosStr.substring(0, 3) + 'Z'\n            else if (nanosStr.substring(6) === '000')\n                z = '.' + nanosStr.substring(0, 6) + 'Z'\n            else z = '.' + nanosStr + 'Z'\n        }\n        return new Date(ms).toISOString().replace('.000Z', z)\n    }\n    /**\n     * In JSON format, the `Timestamp` type is encoded as a string\n     * in the RFC 3339 format.\n     */\n    internalJsonRead(\n        json: JsonValue,\n        options: JsonReadOptions,\n        target?: Timestamp\n    ): Timestamp {\n        if (typeof json !== 'string')\n            throw new Error(\n                'Unable to parse Timestamp from JSON ' +\n                    typeofJsonValue(json) +\n                    '.'\n            )\n        let matches = json.match(\n            /^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:Z|\\.([0-9]{3,9})Z|([+-][0-9][0-9]:[0-9][0-9]))$/\n        )\n        if (!matches)\n            throw new Error(\n                'Unable to parse Timestamp from JSON. Invalid format.'\n            )\n        let ms = Date.parse(\n            matches[1] +\n                '-' +\n                matches[2] +\n                '-' +\n                matches[3] +\n                'T' +\n                matches[4] +\n                ':' +\n                matches[5] +\n                ':' +\n                matches[6] +\n                (matches[8] ? matches[8] : 'Z')\n        )\n        if (Number.isNaN(ms))\n            throw new Error(\n                'Unable to parse Timestamp from JSON. Invalid value.'\n            )\n        if (\n            ms < Date.parse('0001-01-01T00:00:00Z') ||\n            ms > Date.parse('9999-12-31T23:59:59Z')\n        )\n            throw new globalThis.Error(\n                'Unable to parse Timestamp from JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.'\n            )\n        if (!target) target = this.create()\n        target.seconds = PbLong.from(ms / 1000).toBigInt()\n        target.nanos = 0\n        if (matches[7])\n            target.nanos =\n                parseInt('1' + matches[7] + '0'.repeat(9 - matches[7].length)) -\n                1000000000\n        return target\n    }\n    create(value?: PartialMessage<Timestamp>): Timestamp {\n        const message = globalThis.Object.create(this.messagePrototype!)\n        message.seconds = 0n\n        message.nanos = 0\n        if (value !== undefined)\n            reflectionMergePartial<Timestamp>(this, message, value)\n        return message\n    }\n    internalBinaryRead(\n        reader: IBinaryReader,\n        length: number,\n        options: BinaryReadOptions,\n        target?: Timestamp\n    ): Timestamp {\n        let message = target ?? this.create(),\n            end = reader.pos + length\n        while (reader.pos < end) {\n            let [fieldNo, wireType] = reader.tag()\n            switch (fieldNo) {\n                case /* int64 seconds */ 1:\n                    message.seconds = reader.int64().toBigInt()\n                    break\n                case /* int32 nanos */ 2:\n                    message.nanos = reader.int32()\n                    break\n                default:\n                    let u = options.readUnknownField\n                    if (u === 'throw')\n                        throw new globalThis.Error(\n                            `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`\n                        )\n                    let d = reader.skip(wireType)\n                    if (u !== false)\n                        (u === true ? UnknownFieldHandler.onRead : u)(\n                            this.typeName,\n                            message,\n                            fieldNo,\n                            wireType,\n                            d\n                        )\n            }\n        }\n        return message\n    }\n    internalBinaryWrite(\n        message: Timestamp,\n        writer: IBinaryWriter,\n        options: BinaryWriteOptions\n    ): IBinaryWriter {\n        /* int64 seconds = 1; */\n        if (message.seconds !== 0n)\n            writer.tag(1, WireType.Varint).int64(message.seconds)\n        /* int32 nanos = 2; */\n        if (message.nanos !== 0)\n            writer.tag(2, WireType.Varint).int32(message.nanos)\n        let u = options.writeUnknownFields\n        if (u !== false)\n            (u == true ? UnknownFieldHandler.onWrite : u)(\n                this.typeName,\n                message,\n                writer\n            )\n        return writer\n    }\n}\n/**\n * @generated MessageType for protobuf message google.protobuf.Timestamp\n */\nexport const Timestamp = new Timestamp$Type()\n"],"mappings":";;;;;;;;;;;;;;AAkCA;;","names":[]}

package/dist/cjs/_proto/google/rpc/code.cjs

@@ -0,0 +1,48 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var code_exports = {};
+__export(code_exports, {
+  Code: () => Code
+});
+module.exports = __toCommonJS(code_exports);
+var Code = /* @__PURE__ */ ((Code2) => {
+  Code2[Code2["OK"] = 0] = "OK";
+  Code2[Code2["CANCELLED"] = 1] = "CANCELLED";
+  Code2[Code2["UNKNOWN"] = 2] = "UNKNOWN";
+  Code2[Code2["INVALID_ARGUMENT"] = 3] = "INVALID_ARGUMENT";
+  Code2[Code2["DEADLINE_EXCEEDED"] = 4] = "DEADLINE_EXCEEDED";
+  Code2[Code2["NOT_FOUND"] = 5] = "NOT_FOUND";
+  Code2[Code2["ALREADY_EXISTS"] = 6] = "ALREADY_EXISTS";
+  Code2[Code2["PERMISSION_DENIED"] = 7] = "PERMISSION_DENIED";
+  Code2[Code2["UNAUTHENTICATED"] = 16] = "UNAUTHENTICATED";
+  Code2[Code2["RESOURCE_EXHAUSTED"] = 8] = "RESOURCE_EXHAUSTED";
+  Code2[Code2["FAILED_PRECONDITION"] = 9] = "FAILED_PRECONDITION";
+  Code2[Code2["ABORTED"] = 10] = "ABORTED";
+  Code2[Code2["OUT_OF_RANGE"] = 11] = "OUT_OF_RANGE";
+  Code2[Code2["UNIMPLEMENTED"] = 12] = "UNIMPLEMENTED";
+  Code2[Code2["INTERNAL"] = 13] = "INTERNAL";
+  Code2[Code2["UNAVAILABLE"] = 14] = "UNAVAILABLE";
+  Code2[Code2["DATA_LOSS"] = 15] = "DATA_LOSS";
+  return Code2;
+})(Code || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Code
+});
+//# sourceMappingURL=code.cjs.map

package/dist/cjs/_proto/google/rpc/code.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/_proto/google/rpc/code.ts"],"sourcesContent":["// @generated by protobuf-ts 2.11.1 with parameter generate_dependencies\n// @generated from protobuf file \"google/rpc/code.proto\" (package \"google.rpc\", syntax proto3)\n// tslint:disable\n//\n// Copyright 2024 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n//     http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n/**\n * The canonical error codes for gRPC APIs.\n *\n *\n * Sometimes multiple error codes may apply.  Services should return\n * the most specific error code that applies.  For example, prefer\n * `OUT_OF_RANGE` over `FAILED_PRECONDITION` if both codes apply.\n * Similarly prefer `NOT_FOUND` or `ALREADY_EXISTS` over `FAILED_PRECONDITION`.\n *\n * @generated from protobuf enum google.rpc.Code\n */\nexport enum Code {\n    /**\n     * Not an error; returned on success.\n     *\n     * HTTP Mapping: 200 OK\n     *\n     * @generated from protobuf enum value: OK = 0;\n     */\n    OK = 0,\n    /**\n     * The operation was cancelled, typically by the caller.\n     *\n     * HTTP Mapping: 499 Client Closed Request\n     *\n     * @generated from protobuf enum value: CANCELLED = 1;\n     */\n    CANCELLED = 1,\n    /**\n     * Unknown error.  For example, this error may be returned when\n     * a `Status` value received from another address space belongs to\n     * an error space that is not known in this address space.  Also\n     * errors raised by APIs that do not return enough error information\n     * may be converted to this error.\n     *\n     * HTTP Mapping: 500 Internal Server Error\n     *\n     * @generated from protobuf enum value: UNKNOWN = 2;\n     */\n    UNKNOWN = 2,\n    /**\n     * The client specified an invalid argument.  Note that this differs\n     * from `FAILED_PRECONDITION`.  `INVALID_ARGUMENT` indicates arguments\n     * that are problematic regardless of the state of the system\n     * (e.g., a malformed file name).\n     *\n     * HTTP Mapping: 400 Bad Request\n     *\n     * @generated from protobuf enum value: INVALID_ARGUMENT = 3;\n     */\n    INVALID_ARGUMENT = 3,\n    /**\n     * The deadline expired before the operation could complete. For operations\n     * that change the state of the system, this error may be returned\n     * even if the operation has completed successfully.  For example, a\n     * successful response from a server could have been delayed long\n     * enough for the deadline to expire.\n     *\n     * HTTP Mapping: 504 Gateway Timeout\n     *\n     * @generated from protobuf enum value: DEADLINE_EXCEEDED = 4;\n     */\n    DEADLINE_EXCEEDED = 4,\n    /**\n     * Some requested entity (e.g., file or directory) was not found.\n     *\n     * Note to server developers: if a request is denied for an entire class\n     * of users, such as gradual feature rollout or undocumented allowlist,\n     * `NOT_FOUND` may be used. If a request is denied for some users within\n     * a class of users, such as user-based access control, `PERMISSION_DENIED`\n     * must be used.\n     *\n     * HTTP Mapping: 404 Not Found\n     *\n     * @generated from protobuf enum value: NOT_FOUND = 5;\n     */\n    NOT_FOUND = 5,\n    /**\n     * The entity that a client attempted to create (e.g., file or directory)\n     * already exists.\n     *\n     * HTTP Mapping: 409 Conflict\n     *\n     * @generated from protobuf enum value: ALREADY_EXISTS = 6;\n     */\n    ALREADY_EXISTS = 6,\n    /**\n     * The caller does not have permission to execute the specified\n     * operation. `PERMISSION_DENIED` must not be used for rejections\n     * caused by exhausting some resource (use `RESOURCE_EXHAUSTED`\n     * instead for those errors). `PERMISSION_DENIED` must not be\n     * used if the caller can not be identified (use `UNAUTHENTICATED`\n     * instead for those errors). This error code does not imply the\n     * request is valid or the requested entity exists or satisfies\n     * other pre-conditions.\n     *\n     * HTTP Mapping: 403 Forbidden\n     *\n     * @generated from protobuf enum value: PERMISSION_DENIED = 7;\n     */\n    PERMISSION_DENIED = 7,\n    /**\n     * The request does not have valid authentication credentials for the\n     * operation.\n     *\n     * HTTP Mapping: 401 Unauthorized\n     *\n     * @generated from protobuf enum value: UNAUTHENTICATED = 16;\n     */\n    UNAUTHENTICATED = 16,\n    /**\n     * Some resource has been exhausted, perhaps a per-user quota, or\n     * perhaps the entire file system is out of space.\n     *\n     * HTTP Mapping: 429 Too Many Requests\n     *\n     * @generated from protobuf enum value: RESOURCE_EXHAUSTED = 8;\n     */\n    RESOURCE_EXHAUSTED = 8,\n    /**\n     * The operation was rejected because the system is not in a state\n     * required for the operation's execution.  For example, the directory\n     * to be deleted is non-empty, an rmdir operation is applied to\n     * a non-directory, etc.\n     *\n     * Service implementors can use the following guidelines to decide\n     * between `FAILED_PRECONDITION`, `ABORTED`, and `UNAVAILABLE`:\n     *  (a) Use `UNAVAILABLE` if the client can retry just the failing call.\n     *  (b) Use `ABORTED` if the client should retry at a higher level. For\n     *      example, when a client-specified test-and-set fails, indicating the\n     *      client should restart a read-modify-write sequence.\n     *  (c) Use `FAILED_PRECONDITION` if the client should not retry until\n     *      the system state has been explicitly fixed. For example, if an \"rmdir\"\n     *      fails because the directory is non-empty, `FAILED_PRECONDITION`\n     *      should be returned since the client should not retry unless\n     *      the files are deleted from the directory.\n     *\n     * HTTP Mapping: 400 Bad Request\n     *\n     * @generated from protobuf enum value: FAILED_PRECONDITION = 9;\n     */\n    FAILED_PRECONDITION = 9,\n    /**\n     * The operation was aborted, typically due to a concurrency issue such as\n     * a sequencer check failure or transaction abort.\n     *\n     * See the guidelines above for deciding between `FAILED_PRECONDITION`,\n     * `ABORTED`, and `UNAVAILABLE`.\n     *\n     * HTTP Mapping: 409 Conflict\n     *\n     * @generated from protobuf enum value: ABORTED = 10;\n     */\n    ABORTED = 10,\n    /**\n     * The operation was attempted past the valid range.  E.g., seeking or\n     * reading past end-of-file.\n     *\n     * Unlike `INVALID_ARGUMENT`, this error indicates a problem that may\n     * be fixed if the system state changes. For example, a 32-bit file\n     * system will generate `INVALID_ARGUMENT` if asked to read at an\n     * offset that is not in the range [0,2^32-1], but it will generate\n     * `OUT_OF_RANGE` if asked to read from an offset past the current\n     * file size.\n     *\n     * There is a fair bit of overlap between `FAILED_PRECONDITION` and\n     * `OUT_OF_RANGE`.  We recommend using `OUT_OF_RANGE` (the more specific\n     * error) when it applies so that callers who are iterating through\n     * a space can easily look for an `OUT_OF_RANGE` error to detect when\n     * they are done.\n     *\n     * HTTP Mapping: 400 Bad Request\n     *\n     * @generated from protobuf enum value: OUT_OF_RANGE = 11;\n     */\n    OUT_OF_RANGE = 11,\n    /**\n     * The operation is not implemented or is not supported/enabled in this\n     * service.\n     *\n     * HTTP Mapping: 501 Not Implemented\n     *\n     * @generated from protobuf enum value: UNIMPLEMENTED = 12;\n     */\n    UNIMPLEMENTED = 12,\n    /**\n     * Internal errors.  This means that some invariants expected by the\n     * underlying system have been broken.  This error code is reserved\n     * for serious errors.\n     *\n     * HTTP Mapping: 500 Internal Server Error\n     *\n     * @generated from protobuf enum value: INTERNAL = 13;\n     */\n    INTERNAL = 13,\n    /**\n     * The service is currently unavailable.  This is most likely a\n     * transient condition, which can be corrected by retrying with\n     * a backoff. Note that it is not always safe to retry\n     * non-idempotent operations.\n     *\n     * See the guidelines above for deciding between `FAILED_PRECONDITION`,\n     * `ABORTED`, and `UNAVAILABLE`.\n     *\n     * HTTP Mapping: 503 Service Unavailable\n     *\n     * @generated from protobuf enum value: UNAVAILABLE = 14;\n     */\n    UNAVAILABLE = 14,\n    /**\n     * Unrecoverable data loss or corruption.\n     *\n     * HTTP Mapping: 500 Internal Server Error\n     *\n     * @generated from protobuf enum value: DATA_LOSS = 15;\n     */\n    DATA_LOSS = 15,\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA6BO,IAAK,OAAL,kBAAKA,UAAL;AAQH,EAAAA,YAAA,QAAK,KAAL;AAQA,EAAAA,YAAA,eAAY,KAAZ;AAYA,EAAAA,YAAA,aAAU,KAAV;AAWA,EAAAA,YAAA,sBAAmB,KAAnB;AAYA,EAAAA,YAAA,uBAAoB,KAApB;AAcA,EAAAA,YAAA,eAAY,KAAZ;AASA,EAAAA,YAAA,oBAAiB,KAAjB;AAeA,EAAAA,YAAA,uBAAoB,KAApB;AASA,EAAAA,YAAA,qBAAkB,MAAlB;AASA,EAAAA,YAAA,wBAAqB,KAArB;AAuBA,EAAAA,YAAA,yBAAsB,KAAtB;AAYA,EAAAA,YAAA,aAAU,MAAV;AAsBA,EAAAA,YAAA,kBAAe,MAAf;AASA,EAAAA,YAAA,mBAAgB,MAAhB;AAUA,EAAAA,YAAA,cAAW,MAAX;AAcA,EAAAA,YAAA,iBAAc,MAAd;AAQA,EAAAA,YAAA,eAAY,MAAZ;AA7MQ,SAAAA;AAAA,GAAA;","names":["Code"]}