wowok 1.8.2 → 2.1.9

package/dist/cjs/grpc/proto/google/protobuf/timestamp.d.ts

@@ -0,0 +1,145 @@
+import type { JsonValue } from "@protobuf-ts/runtime";
+import type { JsonReadOptions } from "@protobuf-ts/runtime";
+import type { JsonWriteOptions } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+/**
+ * A Timestamp represents a point in time independent of any time zone
+ * or calendar, represented as seconds and fractions of seconds at
+ * nanosecond resolution in UTC Epoch time. It is encoded using the
+ * Proleptic Gregorian Calendar which extends the Gregorian calendar
+ * backwards to year one. It is encoded assuming all minutes are 60
+ * seconds long, i.e. leap seconds are "smeared" so that no leap second
+ * table is needed for interpretation. Range is from
+ * `0001-01-01T00:00:00Z` to `9999-12-31T23:59:59.999999999Z`.
+ * Restricting to that range ensures that conversion to
+ * and from RFC 3339 date strings is possible.
+ * See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt).
+ *
+ * # 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 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 (so up to 1 nanosecond resolution),
+ * are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
+ * is required, though only UTC (as indicated by "Z") is presently supported.
+ *
+ * For example, `2017-01-15T01:30:15.01Z` encodes 15.01 seconds past
+ * 01:30 UTC on January 15, 2017.
+ *
+ * In JavaScript, you 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, you can convert a standard `datetime.datetime` object
+ * 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, you
+ * can use the Joda Time's [`ISODateTimeFormat.dateTime()`](
+ * http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime--)
+ * to obtain a formatter capable of generating timestamps in this format.
+ *
+ *
+ *
+ * @generated from protobuf message google.protobuf.Timestamp
+ */
+export interface Timestamp {
+    /**
+     * 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 protobuf field: int64 seconds = 1;
+     */
+    seconds: bigint;
+    /**
+     * Non-negative fractions of a second at nanosecond resolution. Negative
+     * second values with fractions must still have non-negative nano values
+     * that count forward in time. Must be from 0 to 999,999,999
+     * inclusive.
+     *
+     * @generated from protobuf field: int32 nanos = 2;
+     */
+    nanos: number;
+}
+declare class Timestamp$Type extends MessageType<Timestamp> {
+    constructor();
+    /**
+     * Creates a new `Timestamp` for the current time.
+     */
+    now(): Timestamp;
+    /**
+     * Converts a `Timestamp` to a JavaScript Date.
+     */
+    toDate(message: Timestamp): Date;
+    /**
+     * Converts a JavaScript Date to a `Timestamp`.
+     */
+    fromDate(date: Date): Timestamp;
+    /**
+     * In JSON format, the `Timestamp` type is encoded as a string
+     * in the RFC 3339 format.
+     */
+    internalJsonWrite(message: Timestamp, options: JsonWriteOptions): JsonValue;
+    /**
+     * In JSON format, the `Timestamp` type is encoded as a string
+     * in the RFC 3339 format.
+     */
+    internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: Timestamp): Timestamp;
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.Timestamp
+ */
+export declare const Timestamp: Timestamp$Type;
+export {};

package/dist/cjs/grpc/proto/google/protobuf/timestamp.js

@@ -0,0 +1,134 @@
+"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");
+class Timestamp$Type extends import_runtime3.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_runtime2.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_runtime2.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_runtime2.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_runtime2.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_runtime.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_runtime2.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;
+  }
+}
+const Timestamp = new Timestamp$Type();