@aptre/protobuf-es-lite 0.4.9 → 0.5.1

package/dist/google/protobuf/struct.pb.d.ts

@@ -1,141 +0,0 @@
-import type { JsonReadOptions, JsonValue, JsonWriteOptions, MessageType } from "../../index.js";
-export declare const protobufPackage = "google.protobuf";
-/**
- * `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 declare enum NullValue {
-    /**
-     * Null value.
-     *
-     * @generated from enum value: NULL_VALUE = 0;
-     */
-    NULL_VALUE = 0
-}
-export declare const NullValue_Enum: import("../../enum.js").EnumType;
-/**
- * `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 interface ListValue {
-    /**
-     * Repeated field of dynamically typed values.
-     *
-     * @generated from field: repeated google.protobuf.Value values = 1;
-     */
-    values?: Value[];
-}
-declare const ListValue_Wkt: {
-    toJson(msg: ListValue, options?: Partial<JsonWriteOptions>): JsonValue;
-    fromJson(json: JsonValue | null | undefined, options?: Partial<JsonReadOptions>): ListValue;
-};
-export declare const ListValue: MessageType<ListValue> & typeof ListValue_Wkt;
-/**
- * `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 interface Value {
-    /**
-     * The kind of value.
-     *
-     * @generated from oneof google.protobuf.Value.kind
-     */
-    kind?: {
-        value?: undefined;
-        case: undefined;
-    } | {
-        /**
-         * Represents a null value.
-         *
-         * @generated from field: google.protobuf.NullValue null_value = 1;
-         */
-        value: NullValue;
-        case: "nullValue";
-    } | {
-        /**
-         * Represents a double value.
-         *
-         * @generated from field: double number_value = 2;
-         */
-        value: number;
-        case: "numberValue";
-    } | {
-        /**
-         * Represents a string value.
-         *
-         * @generated from field: string string_value = 3;
-         */
-        value: string;
-        case: "stringValue";
-    } | {
-        /**
-         * Represents a boolean value.
-         *
-         * @generated from field: bool bool_value = 4;
-         */
-        value: boolean;
-        case: "boolValue";
-    } | {
-        /**
-         * Represents a structured value.
-         *
-         * @generated from field: google.protobuf.Struct struct_value = 5;
-         */
-        value: Struct;
-        case: "structValue";
-    } | {
-        /**
-         * Represents a repeated `Value`.
-         *
-         * @generated from field: google.protobuf.ListValue list_value = 6;
-         */
-        value: ListValue;
-        case: "listValue";
-    };
-}
-declare const Value_Wkt: {
-    toJson(msg: Value, options?: Partial<JsonWriteOptions>): JsonValue;
-    fromJson(json: JsonValue | null | undefined, _options?: Partial<JsonReadOptions>): Value;
-};
-export declare const Value: MessageType<Value> & typeof Value_Wkt;
-/**
- * `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 interface Struct {
-    /**
-     * Unordered map of dynamically typed values.
-     *
-     * @generated from field: map<string, google.protobuf.Value> fields = 1;
-     */
-    fields?: {
-        [key: string]: Value;
-    };
-}
-declare const Struct_Wkt: {
-    toJson(msg: Struct, options?: Partial<JsonWriteOptions>): JsonValue;
-    fromJson(json: JsonValue | null | undefined, _options?: Partial<JsonReadOptions>): Struct;
-};
-export declare const Struct: MessageType<Struct> & typeof Struct_Wkt;
-export {};

package/dist/google/protobuf/struct.pb.js

@@ -1,228 +0,0 @@
-// 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 { createEnumType, createMessageType, jsonDebugValue, ScalarType, } from "../../index.js";
-export const protobufPackage = "google.protobuf";
-/**
- * `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 = {}));
-// NullValue_Enum is the enum type for NullValue.
-export const NullValue_Enum = createEnumType("google.protobuf.NullValue", [
-    { no: 0, name: "NULL_VALUE" },
-]);
-// ListValue_Wkt contains the well-known-type overrides for ListValue.
-const ListValue_Wkt = {
-    toJson(msg, options) {
-        return msg.values?.map((v) => Value.toJson(v, options)) ?? [];
-    },
-    fromJson(json, options) {
-        if (json == null) {
-            return {};
-        }
-        if (!Array.isArray(json)) {
-            throw new Error(`cannot decode google.protobuf.ListValue from JSON ${jsonDebugValue(json)}`);
-        }
-        const values = json.map((v) => Value.fromJson(v, options));
-        return { values: values };
-    },
-};
-// ListValue contains the message type declaration for ListValue.
-export const ListValue = createMessageType({
-    typeName: "google.protobuf.ListValue",
-    fields: [
-        {
-            no: 1,
-            name: "values",
-            kind: "message",
-            T: () => Value,
-            repeated: true,
-        },
-    ],
-    packedByDefault: true,
-}, ListValue_Wkt);
-// Value_Wkt contains the well-known-type overrides for Value.
-const Value_Wkt = {
-    toJson(msg, options) {
-        switch (msg.kind?.case) {
-            case "nullValue":
-                return null;
-            case "numberValue":
-                if (!Number.isFinite(msg.kind.value)) {
-                    throw new Error("google.protobuf.Value cannot be NaN or Infinity");
-                }
-                return msg.kind.value;
-            case "boolValue":
-                return msg.kind.value;
-            case "stringValue":
-                return msg.kind.value;
-            case "structValue":
-                return Struct.toJson(msg.kind.value, {
-                    ...options,
-                    emitDefaultValues: true,
-                });
-            case "listValue":
-                return ListValue.toJson(msg.kind.value, {
-                    ...options,
-                    emitDefaultValues: true,
-                });
-            case null:
-            case undefined:
-            default:
-                return null;
-        }
-    },
-    fromJson(json, _options) {
-        const msg = {};
-        switch (typeof json) {
-            case "number":
-                msg.kind = { case: "numberValue", value: json };
-                break;
-            case "string":
-                msg.kind = { case: "stringValue", value: json };
-                break;
-            case "boolean":
-                msg.kind = { case: "boolValue", value: json };
-                break;
-            case "object":
-                if (json == null) {
-                    msg.kind = { case: "nullValue", value: NullValue.NULL_VALUE };
-                }
-                else if (Array.isArray(json)) {
-                    msg.kind = { case: "listValue", value: ListValue.fromJson(json) };
-                }
-                else {
-                    msg.kind = { case: "structValue", value: Struct.fromJson(json) };
-                }
-                break;
-            default:
-                throw new Error(`cannot decode google.protobuf.Value from JSON ${jsonDebugValue(json)}`);
-        }
-        return msg;
-    },
-};
-// Value contains the message type declaration for Value.
-export const Value = createMessageType({
-    typeName: "google.protobuf.Value",
-    fields: [
-        {
-            no: 1,
-            name: "null_value",
-            kind: "enum",
-            T: NullValue_Enum,
-            oneof: "kind",
-        },
-        {
-            no: 2,
-            name: "number_value",
-            kind: "scalar",
-            T: ScalarType.DOUBLE,
-            oneof: "kind",
-        },
-        {
-            no: 3,
-            name: "string_value",
-            kind: "scalar",
-            T: ScalarType.STRING,
-            oneof: "kind",
-        },
-        {
-            no: 4,
-            name: "bool_value",
-            kind: "scalar",
-            T: 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",
-        },
-    ],
-    packedByDefault: true,
-}, Value_Wkt);
-// Struct_Wkt contains the well-known-type overrides for Struct.
-const Struct_Wkt = {
-    toJson(msg, options) {
-        const json = {};
-        if (!msg.fields) {
-            return json;
-        }
-        for (const [k, v] of Object.entries(msg.fields)) {
-            json[k] = v != null ? Value.toJson(v, options) : null;
-        }
-        return json;
-    },
-    fromJson(json, _options) {
-        if (typeof json != "object" || json == null || Array.isArray(json)) {
-            throw new Error(`cannot decode google.protobuf.Struct from JSON ${jsonDebugValue(json)}`);
-        }
-        const fields = {};
-        for (const [k, v] of Object.entries(json)) {
-            fields[k] = Value.fromJson(v);
-        }
-        return { fields: fields };
-    },
-};
-// Struct contains the message type declaration for Struct.
-export const Struct = createMessageType({
-    typeName: "google.protobuf.Struct",
-    fields: [
-        {
-            no: 1,
-            name: "fields",
-            kind: "map",
-            K: ScalarType.STRING,
-            V: { kind: "message", T: () => Value },
-        },
-    ],
-    packedByDefault: true,
-}, Struct_Wkt);

package/dist/google/protobuf/timestamp.pb.d.ts

@@ -1,125 +0,0 @@
-import type { JsonValue, MessageType } from "../../index.js";
-export declare const protobufPackage = "google.protobuf";
-/**
- * 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://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
- * ) to obtain a formatter capable of generating timestamps in this format.
- *
- * protobuf-go-lite:disable-text
- *
- * @generated from 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 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 nanos values
-     * that count forward in time. Must be from 0 to 999,999,999
-     * inclusive.
-     *
-     * @generated from field: int32 nanos = 2;
-     */
-    nanos?: number;
-}
-declare const Timestamp_Wkt: {
-    fromJson(json: JsonValue): Timestamp;
-    toJson(msg: Timestamp): JsonValue;
-    toDate(msg: Timestamp | null | undefined): Date | null;
-    fromDate(value: Date | null | undefined): Timestamp;
-    equals(a: Timestamp | Date | undefined | null, b: Timestamp | Date | undefined | null): boolean;
-};
-export declare const Timestamp: MessageType<Timestamp> & typeof Timestamp_Wkt;
-export {};

package/dist/google/protobuf/timestamp.pb.js

@@ -1,137 +0,0 @@
-// 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 { createMessageType, protoInt64, ScalarType } from "../../index.js";
-export const protobufPackage = "google.protobuf";
-// Timestamp_Wkt contains the well-known-type overrides for Timestamp.
-const Timestamp_Wkt = {
-    fromJson(json) {
-        if (typeof json !== "string") {
-            throw new Error(`cannot decode google.protobuf.Timestamp(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`);
-        }
-        return {
-            seconds: protoInt64.parse(ms / 1000),
-            nanos: !matches[7] ? 0 : (parseInt("1" + matches[7] + "0".repeat(9 - matches[7].length)) -
-                1000000000),
-        };
-    },
-    toJson(msg) {
-        const ms = Number(msg.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 (msg.nanos != null && msg.nanos < 0) {
-            throw new Error(`cannot encode google.protobuf.Timestamp to JSON: nanos must not be negative`);
-        }
-        let z = "Z";
-        if (msg.nanos != null && msg.nanos > 0) {
-            const nanosStr = (msg.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(msg) {
-        if (!msg?.seconds && !msg?.nanos) {
-            return null;
-        }
-        return new Date(Number(msg.seconds ?? 0) * 1000 + Math.ceil((msg.nanos ?? 0) / 1000000));
-    },
-    fromDate(value) {
-        if (value == null) {
-            return {};
-        }
-        const ms = value.getTime();
-        const seconds = Math.floor(ms / 1000);
-        const nanos = (ms % 1000) * 1000000;
-        return { seconds: protoInt64.parse(seconds), nanos: nanos };
-    },
-    equals(a, b) {
-        const aDate = a instanceof Date ? a : Timestamp_Wkt.toDate(a);
-        const bDate = b instanceof Date ? b : Timestamp_Wkt.toDate(b);
-        if (aDate === bDate) {
-            return true;
-        }
-        if (aDate == null || bDate == null) {
-            return aDate === bDate;
-        }
-        return +aDate === +bDate;
-    },
-};
-// Timestamp contains the message type declaration for Timestamp.
-export const Timestamp = createMessageType({
-    typeName: "google.protobuf.Timestamp",
-    fields: [
-        { no: 1, name: "seconds", kind: "scalar", T: ScalarType.INT64 },
-        { no: 2, name: "nanos", kind: "scalar", T: ScalarType.INT32 },
-    ],
-    packedByDefault: true,
-    fieldWrapper: {
-        wrapField(value) {
-            if (value == null || value instanceof Date) {
-                return Timestamp_Wkt.fromDate(value);
-            }
-            return Timestamp.createComplete(value);
-        },
-        unwrapField(msg) {
-            return Timestamp_Wkt.toDate(msg);
-        },
-    },
-}, Timestamp_Wkt);