@bufbuild/protobuf 0.0.1-alpha.1

package/dist/esm/google/protobuf/struct_pb.js

@@ -0,0 +1,282 @@
+/* eslint-disable */
+// @generated by protoc-gen-es v0.0.1-alpha.1 with parameter "bootstrap_wkt=true,ts_nocheck=false"
+// @generated from file google/protobuf/struct.proto (package google.protobuf, syntax proto3)
+//
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+import { Message, proto3 } from "../../index.js";
+/**
+ * `NullValue` is a singleton enumeration to represent the null value for the
+ * `Value` type union.
+ *
+ *  The JSON representation for `NullValue` is JSON `null`.
+ *
+ * @generated from enum google.protobuf.NullValue
+ */
+export var NullValue;
+(function (NullValue) {
+  /**
+   * Null value.
+   *
+   * @generated from enum value: NULL_VALUE = 0;
+   */
+  NullValue[(NullValue["NULL_VALUE"] = 0)] = "NULL_VALUE";
+})(NullValue || (NullValue = {}));
+// Retrieve enum metadata with: proto3.getEnumType(NullValue)
+proto3.util.setEnumType(NullValue, "google.protobuf.NullValue", [
+  { no: 0, name: "NULL_VALUE" },
+]);
+/**
+ * `Struct` represents a structured data value, consisting of fields
+ * which map to dynamically typed values. In some languages, `Struct`
+ * might be supported by a native representation. For example, in
+ * scripting languages like JS a struct is represented as an
+ * object. The details of that representation are described together
+ * with the proto support for the language.
+ *
+ * The JSON representation for `Struct` is JSON object.
+ *
+ * @generated from message google.protobuf.Struct
+ */
+export class Struct extends Message {
+  constructor(data) {
+    super();
+    /**
+     * Unordered map of dynamically typed values.
+     *
+     * @generated from field: map<string, google.protobuf.Value> fields = 1;
+     */
+    this.fields = {};
+    proto3.util.initPartial(data, this);
+  }
+  toJson(options) {
+    const json = {};
+    for (const [k, v] of Object.entries(this.fields)) {
+      json[k] = v.toJson(options);
+    }
+    return json;
+  }
+  fromJson(json, options) {
+    if (typeof json != "object" || json == null || Array.isArray(json)) {
+      throw new Error(
+        "cannot decode google.protobuf.Struct from JSON " +
+          proto3.json.debug(json)
+      );
+    }
+    for (const [k, v] of Object.entries(json)) {
+      this.fields[k] = Value.fromJson(v);
+    }
+    return this;
+  }
+  static fromBinary(bytes, options) {
+    return new Struct().fromBinary(bytes, options);
+  }
+  static fromJson(jsonValue, options) {
+    return new Struct().fromJson(jsonValue, options);
+  }
+  static fromJsonString(jsonString, options) {
+    return new Struct().fromJsonString(jsonString, options);
+  }
+  static equals(a, b) {
+    return proto3.util.equals(Struct, a, b);
+  }
+}
+Struct.runtime = proto3;
+Struct.typeName = "google.protobuf.Struct";
+Struct.fields = proto3.util.newFieldList(() => [
+  {
+    no: 1,
+    name: "fields",
+    kind: "map",
+    K: 9 /* ScalarType.STRING */,
+    V: { kind: "message", T: Value },
+  },
+]);
+/**
+ * `Value` represents a dynamically typed value which can be either
+ * null, a number, a string, a boolean, a recursive struct value, or a
+ * list of values. A producer of value is expected to set one of these
+ * variants. Absence of any variant indicates an error.
+ *
+ * The JSON representation for `Value` is JSON value.
+ *
+ * @generated from message google.protobuf.Value
+ */
+export class Value extends Message {
+  constructor(data) {
+    super();
+    /**
+     * The kind of value.
+     *
+     * @generated from oneof google.protobuf.Value.kind
+     */
+    this.kind = { case: undefined };
+    proto3.util.initPartial(data, this);
+  }
+  toJson(options) {
+    switch (this.kind.case) {
+      case "nullValue":
+        return null;
+      case "boolValue":
+      case "numberValue":
+      case "stringValue":
+        return this.kind.value;
+      case "structValue":
+      case "listValue":
+        return this.kind.value.toJson({ ...options, emitDefaultValues: true });
+    }
+    throw new Error("google.protobuf.Value must have a value");
+  }
+  fromJson(json, options) {
+    switch (typeof json) {
+      case "number":
+        this.kind = { case: "numberValue", value: json };
+        break;
+      case "string":
+        this.kind = { case: "stringValue", value: json };
+        break;
+      case "boolean":
+        this.kind = { case: "boolValue", value: json };
+        break;
+      case "object":
+        if (json === null) {
+          this.kind = { case: "nullValue", value: NullValue.NULL_VALUE };
+        } else if (Array.isArray(json)) {
+          this.kind = { case: "listValue", value: ListValue.fromJson(json) };
+        } else {
+          this.kind = { case: "structValue", value: Struct.fromJson(json) };
+        }
+        break;
+      default:
+        throw new Error(
+          "cannot decode google.protobuf.Value from JSON " +
+            proto3.json.debug(json)
+        );
+    }
+    return this;
+  }
+  static fromBinary(bytes, options) {
+    return new Value().fromBinary(bytes, options);
+  }
+  static fromJson(jsonValue, options) {
+    return new Value().fromJson(jsonValue, options);
+  }
+  static fromJsonString(jsonString, options) {
+    return new Value().fromJsonString(jsonString, options);
+  }
+  static equals(a, b) {
+    return proto3.util.equals(Value, a, b);
+  }
+}
+Value.runtime = proto3;
+Value.typeName = "google.protobuf.Value";
+Value.fields = proto3.util.newFieldList(() => [
+  {
+    no: 1,
+    name: "null_value",
+    kind: "enum",
+    T: proto3.getEnumType(NullValue),
+    oneof: "kind",
+  },
+  {
+    no: 2,
+    name: "number_value",
+    kind: "scalar",
+    T: 1 /* ScalarType.DOUBLE */,
+    oneof: "kind",
+  },
+  {
+    no: 3,
+    name: "string_value",
+    kind: "scalar",
+    T: 9 /* ScalarType.STRING */,
+    oneof: "kind",
+  },
+  {
+    no: 4,
+    name: "bool_value",
+    kind: "scalar",
+    T: 8 /* ScalarType.BOOL */,
+    oneof: "kind",
+  },
+  { no: 5, name: "struct_value", kind: "message", T: Struct, oneof: "kind" },
+  { no: 6, name: "list_value", kind: "message", T: ListValue, oneof: "kind" },
+]);
+/**
+ * `ListValue` is a wrapper around a repeated field of values.
+ *
+ * The JSON representation for `ListValue` is JSON array.
+ *
+ * @generated from message google.protobuf.ListValue
+ */
+export class ListValue extends Message {
+  constructor(data) {
+    super();
+    /**
+     * Repeated field of dynamically typed values.
+     *
+     * @generated from field: repeated google.protobuf.Value values = 1;
+     */
+    this.values = [];
+    proto3.util.initPartial(data, this);
+  }
+  toJson(options) {
+    return this.values.map((v) => v.toJson());
+  }
+  fromJson(json, options) {
+    if (!Array.isArray(json)) {
+      throw new Error(
+        "cannot decode google.protobuf.ListValue from JSON " +
+          proto3.json.debug(json)
+      );
+    }
+    for (let e of json) {
+      this.values.push(Value.fromJson(e));
+    }
+    return this;
+  }
+  static fromBinary(bytes, options) {
+    return new ListValue().fromBinary(bytes, options);
+  }
+  static fromJson(jsonValue, options) {
+    return new ListValue().fromJson(jsonValue, options);
+  }
+  static fromJsonString(jsonString, options) {
+    return new ListValue().fromJsonString(jsonString, options);
+  }
+  static equals(a, b) {
+    return proto3.util.equals(ListValue, a, b);
+  }
+}
+ListValue.runtime = proto3;
+ListValue.typeName = "google.protobuf.ListValue";
+ListValue.fields = proto3.util.newFieldList(() => [
+  { no: 1, name: "values", kind: "message", T: Value, repeated: true },
+]);

package/dist/esm/google/protobuf/timestamp_pb.js

@@ -0,0 +1,267 @@
+/* eslint-disable */
+// @generated by protoc-gen-es v0.0.1-alpha.1 with parameter "bootstrap_wkt=true,ts_nocheck=false"
+// @generated from file google/protobuf/timestamp.proto (package google.protobuf, syntax proto3)
+//
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+import { Message, proto3, protoInt64 } from "../../index.js";
+/**
+ * A Timestamp represents a point in time independent of any time zone or local
+ * calendar, encoded as a count of seconds and fractions of seconds at
+ * nanosecond resolution. The count is relative to an epoch at UTC midnight on
+ * January 1, 1970, in the proleptic Gregorian calendar which extends the
+ * Gregorian calendar backwards to year one.
+ *
+ * All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
+ * second table is needed for interpretation, using a [24-hour linear
+ * smear](https://developers.google.com/time/smear).
+ *
+ * The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
+ * restricting to that range, we ensure that we can convert to and from [RFC
+ * 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
+ *
+ * # Examples
+ *
+ * Example 1: Compute Timestamp from POSIX `time()`.
+ *
+ *     Timestamp timestamp;
+ *     timestamp.set_seconds(time(NULL));
+ *     timestamp.set_nanos(0);
+ *
+ * Example 2: Compute Timestamp from POSIX `gettimeofday()`.
+ *
+ *     struct timeval tv;
+ *     gettimeofday(&tv, NULL);
+ *
+ *     Timestamp timestamp;
+ *     timestamp.set_seconds(tv.tv_sec);
+ *     timestamp.set_nanos(tv.tv_usec * 1000);
+ *
+ * Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
+ *
+ *     FILETIME ft;
+ *     GetSystemTimeAsFileTime(&ft);
+ *     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
+ *
+ *     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
+ *     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
+ *     Timestamp timestamp;
+ *     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
+ *     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
+ *
+ * Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
+ *
+ *     long millis = System.currentTimeMillis();
+ *
+ *     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
+ *         .setNanos((int) ((millis % 1000) * 1000000)).build();
+ *
+ *
+ * Example 5: Compute Timestamp from Java `Instant.now()`.
+ *
+ *     Instant now = Instant.now();
+ *
+ *     Timestamp timestamp =
+ *         Timestamp.newBuilder().setSeconds(now.getEpochSecond())
+ *             .setNanos(now.getNano()).build();
+ *
+ *
+ * Example 6: Compute Timestamp from current time in Python.
+ *
+ *     timestamp = Timestamp()
+ *     timestamp.GetCurrentTime()
+ *
+ * # JSON Mapping
+ *
+ * In JSON format, the Timestamp type is encoded as a string in the
+ * [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
+ * format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
+ * where {year} is always expressed using four digits while {month}, {day},
+ * {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
+ * seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
+ * are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
+ * is required. A proto3 JSON serializer should always use UTC (as indicated by
+ * "Z") when printing the Timestamp type and a proto3 JSON parser should be
+ * able to accept both UTC and other timezones (as indicated by an offset).
+ *
+ * For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
+ * 01:30 UTC on January 15, 2017.
+ *
+ * In JavaScript, one can convert a Date object to this format using the
+ * standard
+ * [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
+ * method. In Python, a standard `datetime.datetime` object can be converted
+ * to this format using
+ * [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
+ * the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
+ * the Joda Time's [`ISODateTimeFormat.dateTime()`](
+ * http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D
+ * ) to obtain a formatter capable of generating timestamps in this format.
+ *
+ *
+ *
+ * @generated from message google.protobuf.Timestamp
+ */
+export class Timestamp extends Message {
+  constructor(data) {
+    super();
+    /**
+     * Represents seconds of UTC time since Unix epoch
+     * 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
+     * 9999-12-31T23:59:59Z inclusive.
+     *
+     * @generated from field: int64 seconds = 1;
+     */
+    this.seconds = protoInt64.zero;
+    /**
+     * Non-negative fractions of a second at nanosecond resolution. Negative
+     * second values with fractions must still have non-negative nanos values
+     * that count forward in time. Must be from 0 to 999,999,999
+     * inclusive.
+     *
+     * @generated from field: int32 nanos = 2;
+     */
+    this.nanos = 0;
+    proto3.util.initPartial(data, this);
+  }
+  fromJson(json, options) {
+    if (typeof json !== "string") {
+      throw new Error(
+        `cannot decode google.protobuf.Timestamp from JSON: ${proto3.json.debug(
+          json
+        )}`
+      );
+    }
+    const 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(
+        `cannot decode google.protobuf.Timestamp from JSON: invalid RFC 3339 string`
+      );
+    }
+    const 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(
+        `cannot decode google.protobuf.Timestamp from JSON: invalid RFC 3339 string`
+      );
+    }
+    if (
+      ms < Date.parse("0001-01-01T00:00:00Z") ||
+      ms > Date.parse("9999-12-31T23:59:59Z")
+    ) {
+      throw new Error(
+        `cannot decode message google.protobuf.Timestamp from JSON: must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive`
+      );
+    }
+    this.seconds = protoInt64.parse(ms / 1000);
+    this.nanos = 0;
+    if (matches[7]) {
+      this.nanos =
+        parseInt("1" + matches[7] + "0".repeat(9 - matches[7].length)) -
+        1000000000;
+    }
+    return this;
+  }
+  toJson(options) {
+    const ms = Number(this.seconds) * 1000;
+    if (
+      ms < Date.parse("0001-01-01T00:00:00Z") ||
+      ms > Date.parse("9999-12-31T23:59:59Z")
+    ) {
+      throw new Error(
+        `cannot encode google.protobuf.Timestamp to JSON: must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive`
+      );
+    }
+    if (this.nanos < 0) {
+      throw new Error(
+        `cannot encode google.protobuf.Timestamp to JSON: nanos must not be negative`
+      );
+    }
+    let z = "Z";
+    if (this.nanos > 0) {
+      const nanosStr = (this.nanos + 1000000000).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);
+  }
+  toDate() {
+    return new Date(
+      Number(this.seconds) * 1000 + Math.ceil(this.nanos / 1000000)
+    );
+  }
+  static now() {
+    return Timestamp.fromDate(new Date());
+  }
+  static fromDate(date) {
+    const ms = date.getTime();
+    return new Timestamp({
+      seconds: protoInt64.parse(Math.floor(ms / 1000)),
+      nanos: (ms % 1000) * 1000000,
+    });
+  }
+  static fromBinary(bytes, options) {
+    return new Timestamp().fromBinary(bytes, options);
+  }
+  static fromJson(jsonValue, options) {
+    return new Timestamp().fromJson(jsonValue, options);
+  }
+  static fromJsonString(jsonString, options) {
+    return new Timestamp().fromJsonString(jsonString, options);
+  }
+  static equals(a, b) {
+    return proto3.util.equals(Timestamp, a, b);
+  }
+}
+Timestamp.runtime = proto3;
+Timestamp.typeName = "google.protobuf.Timestamp";
+Timestamp.fields = proto3.util.newFieldList(() => [
+  { no: 1, name: "seconds", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
+  { no: 2, name: "nanos", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+]);