@aptre/protobuf-es-lite 0.2.15 → 0.3.1

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

@@ -1,4 +1,4 @@
-import type { MessageType } from "../../index.js";
+import type { JsonReadOptions, JsonValue, MessageType } from "../../index.js";
 import { Message } from "../../index.js";
 export declare const protobufPackage = "google.protobuf";
 /**
@@ -86,4 +86,9 @@ export type Duration = Message<{
      */
     nanos?: number;
 }>;
-export declare const Duration: MessageType<Duration>;
+declare const Duration_Wkt: {
+    fromJson(json: JsonValue | null | undefined, _options?: Partial<JsonReadOptions>): Duration;
+    toJson(msg: Duration): JsonValue;
+};
+export declare const Duration: MessageType<Duration> & typeof Duration_Wkt;
+export {};

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

@@ -27,13 +27,63 @@
 // 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 } from "../../index.js";
+import { createMessageType, jsonDebugValue, protoInt64, ScalarType, } from "../../index.js";
 export const protobufPackage = "google.protobuf";
+// Duration_Wkt contains the well-known-type overrides for Duration.
+const Duration_Wkt = {
+    fromJson(json, _options) {
+        if (typeof json !== "string") {
+            throw new Error(`cannot decode google.protobuf.Duration from JSON: ${jsonDebugValue(json)}`);
+        }
+        const match = json.match(/^(-?[0-9]+)(?:\.([0-9]+))?s/);
+        if (match === null) {
+            throw new Error(`cannot decode google.protobuf.Duration from JSON: ${jsonDebugValue(json)}`);
+        }
+        const longSeconds = Number(match[1]);
+        if (longSeconds > 315576000000 || longSeconds < -315576000000) {
+            throw new Error(`cannot decode google.protobuf.Duration from JSON: ${jsonDebugValue(json)}`);
+        }
+        const msg = {};
+        msg.seconds = protoInt64.parse(longSeconds);
+        if (typeof match[2] == "string") {
+            const nanosStr = match[2] + "0".repeat(9 - match[2].length);
+            msg.nanos = parseInt(nanosStr);
+            if (longSeconds < 0 || Object.is(longSeconds, -0)) {
+                msg.nanos = -msg.nanos;
+            }
+        }
+        return msg;
+    },
+    toJson(msg) {
+        const secs = Number(msg.seconds ?? 0);
+        const nanos = Number(msg.nanos ?? 0);
+        if (secs > 315576000000 || secs < -315576000000) {
+            throw new Error(`cannot encode google.protobuf.Duration to JSON: value out of range`);
+        }
+        let text = secs.toString();
+        if (nanos !== 0) {
+            let nanosStr = Math.abs(nanos).toString();
+            nanosStr = "0".repeat(9 - nanosStr.length) + nanosStr;
+            if (nanosStr.substring(3) === "000000") {
+                nanosStr = nanosStr.substring(0, 3);
+            }
+            else if (nanosStr.substring(6) === "000") {
+                nanosStr = nanosStr.substring(0, 6);
+            }
+            text += "." + nanosStr;
+            if (nanos < 0 && secs === 0) {
+                text = "-" + text;
+            }
+        }
+        return text + "s";
+    },
+};
+// Duration contains the message type declaration for Duration.
 export const Duration = createMessageType({
     typeName: "google.protobuf.Duration",
     fields: [
-        { no: 1, name: "seconds", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
-        { no: 2, name: "nanos", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+        { no: 1, name: "seconds", kind: "scalar", T: ScalarType.INT64 },
+        { no: 2, name: "nanos", kind: "scalar", T: ScalarType.INT32 },
     ],
     packedByDefault: true,
-});
+}, Duration_Wkt);

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

@@ -29,6 +29,7 @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 import { createMessageType } from "../../index.js";
 export const protobufPackage = "google.protobuf";
+// Empty contains the message type declaration for Empty.
 export const Empty = createMessageType({
     typeName: "google.protobuf.Empty",
     fields: [],

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

@@ -27,12 +27,13 @@
 // 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 } from "../../index.js";
+import { createMessageType, ScalarType } from "../../index.js";
 export const protobufPackage = "google.protobuf";
+// SourceContext contains the message type declaration for SourceContext.
 export const SourceContext = createMessageType({
     typeName: "google.protobuf.SourceContext",
     fields: [
-        { no: 1, name: "file_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+        { no: 1, name: "file_name", kind: "scalar", T: ScalarType.STRING },
     ],
     packedByDefault: true,
 });

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

@@ -1,4 +1,4 @@
-import type { MessageType } from "../../index.js";
+import type { JsonReadOptions, JsonValue, JsonWriteOptions, MessageType } from "../../index.js";
 import { Message } from "../../index.js";
 export declare const protobufPackage = "google.protobuf";
 /**
@@ -33,7 +33,11 @@ export type ListValue = Message<{
      */
     values?: Value[];
 }>;
-export declare const ListValue: MessageType<ListValue>;
+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
@@ -103,7 +107,11 @@ export type Value = Message<{
         case: "listValue";
     };
 }>;
-export declare const Value: MessageType<Value>;
+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`
@@ -126,4 +134,9 @@ export type Struct = Message<{
         [key: string]: Value;
     };
 }>;
-export declare const Struct: MessageType<Struct>;
+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

@@ -27,7 +27,7 @@
 // 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 } from "../../index.js";
+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
@@ -50,29 +50,179 @@ export var 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 },
+        {
+            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: 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" },
+        {
+            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: 9 /* ScalarType.STRING */, V: { kind: "message", T: () => Value } },
+        {
+            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,4 +1,4 @@
-import type { MessageType } from "../../index.js";
+import type { JsonValue, MessageType } from "../../index.js";
 import { Message } from "../../index.js";
 export declare const protobufPackage = "google.protobuf";
 /**
@@ -115,4 +115,10 @@ export type Timestamp = Message<{
      */
     nanos?: number;
 }>;
-export declare const Timestamp: MessageType<Timestamp>;
+declare const Timestamp_Wkt: {
+    fromJson(json: JsonValue): Timestamp;
+    toJson(msg: Timestamp): JsonValue;
+    toDate(msg: Timestamp): Date;
+};
+export declare const Timestamp: MessageType<Timestamp> & typeof Timestamp_Wkt;
+export {};

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

@@ -27,13 +27,77 @@
 // 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 } from "../../index.js";
+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) {
+        return new Date(Number(msg.seconds ?? 0) * 1000 + Math.ceil((msg.nanos ?? 0) / 1000000));
+    },
+};
+// Timestamp contains the message type declaration for Timestamp.
 export const Timestamp = createMessageType({
     typeName: "google.protobuf.Timestamp",
     fields: [
-        { no: 1, name: "seconds", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
-        { no: 2, name: "nanos", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+        { no: 1, name: "seconds", kind: "scalar", T: ScalarType.INT64 },
+        { no: 2, name: "nanos", kind: "scalar", T: ScalarType.INT32 },
     ],
     packedByDefault: true,
-});
+}, Timestamp_Wkt);

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

@@ -27,7 +27,7 @@
 // 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 } from "../../index.js";
+import { createEnumType, createMessageType, ScalarType, } from "../../index.js";
 import { Any } from "./any.pb.js";
 import { SourceContext } from "./source_context.pb.js";
 export const protobufPackage = "google.protobuf";
@@ -246,61 +246,102 @@ export const Field_Cardinality_Enum = createEnumType("google.protobuf.Field.Card
     { no: 2, name: "CARDINALITY_REQUIRED" },
     { no: 3, name: "CARDINALITY_REPEATED" },
 ]);
+// Option contains the message type declaration for Option.
 export const Option = createMessageType({
     typeName: "google.protobuf.Option",
     fields: [
-        { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+        { no: 1, name: "name", kind: "scalar", T: ScalarType.STRING },
         { no: 2, name: "value", kind: "message", T: () => Any },
     ],
     packedByDefault: true,
 });
+// Field contains the message type declaration for Field.
 export const Field = createMessageType({
     typeName: "google.protobuf.Field",
     fields: [
         { no: 1, name: "kind", kind: "enum", T: Field_Kind_Enum },
         { no: 2, name: "cardinality", kind: "enum", T: Field_Cardinality_Enum },
-        { no: 3, name: "number", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
-        { no: 4, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-        { no: 6, name: "type_url", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-        { no: 7, name: "oneof_index", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
-        { no: 8, name: "packed", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
-        { no: 9, name: "options", kind: "message", T: () => Option, repeated: true },
-        { no: 10, name: "json_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-        { no: 11, name: "default_value", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+        { no: 3, name: "number", kind: "scalar", T: ScalarType.INT32 },
+        { no: 4, name: "name", kind: "scalar", T: ScalarType.STRING },
+        { no: 6, name: "type_url", kind: "scalar", T: ScalarType.STRING },
+        { no: 7, name: "oneof_index", kind: "scalar", T: ScalarType.INT32 },
+        { no: 8, name: "packed", kind: "scalar", T: ScalarType.BOOL },
+        {
+            no: 9,
+            name: "options",
+            kind: "message",
+            T: () => Option,
+            repeated: true,
+        },
+        { no: 10, name: "json_name", kind: "scalar", T: ScalarType.STRING },
+        { no: 11, name: "default_value", kind: "scalar", T: ScalarType.STRING },
     ],
     packedByDefault: true,
 });
+// Type contains the message type declaration for Type.
 export const Type = createMessageType({
     typeName: "google.protobuf.Type",
     fields: [
-        { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+        { no: 1, name: "name", kind: "scalar", T: ScalarType.STRING },
         { no: 2, name: "fields", kind: "message", T: () => Field, repeated: true },
-        { no: 3, name: "oneofs", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
-        { no: 4, name: "options", kind: "message", T: () => Option, repeated: true },
+        {
+            no: 3,
+            name: "oneofs",
+            kind: "scalar",
+            T: ScalarType.STRING,
+            repeated: true,
+        },
+        {
+            no: 4,
+            name: "options",
+            kind: "message",
+            T: () => Option,
+            repeated: true,
+        },
         { no: 5, name: "source_context", kind: "message", T: () => SourceContext },
         { no: 6, name: "syntax", kind: "enum", T: Syntax_Enum },
-        { no: 7, name: "edition", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+        { no: 7, name: "edition", kind: "scalar", T: ScalarType.STRING },
     ],
     packedByDefault: true,
 });
+// EnumValue contains the message type declaration for EnumValue.
 export const EnumValue = createMessageType({
     typeName: "google.protobuf.EnumValue",
     fields: [
-        { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-        { no: 2, name: "number", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
-        { no: 3, name: "options", kind: "message", T: () => Option, repeated: true },
+        { no: 1, name: "name", kind: "scalar", T: ScalarType.STRING },
+        { no: 2, name: "number", kind: "scalar", T: ScalarType.INT32 },
+        {
+            no: 3,
+            name: "options",
+            kind: "message",
+            T: () => Option,
+            repeated: true,
+        },
     ],
     packedByDefault: true,
 });
+// Enum contains the message type declaration for Enum.
 export const Enum = createMessageType({
     typeName: "google.protobuf.Enum",
     fields: [
-        { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-        { no: 2, name: "enumvalue", kind: "message", T: () => EnumValue, repeated: true },
-        { no: 3, name: "options", kind: "message", T: () => Option, repeated: true },
+        { no: 1, name: "name", kind: "scalar", T: ScalarType.STRING },
+        {
+            no: 2,
+            name: "enumvalue",
+            kind: "message",
+            T: () => EnumValue,
+            repeated: true,
+        },
+        {
+            no: 3,
+            name: "options",
+            kind: "message",
+            T: () => Option,
+            repeated: true,
+        },
         { no: 4, name: "source_context", kind: "message", T: () => SourceContext },
         { no: 5, name: "syntax", kind: "enum", T: Syntax_Enum },
-        { no: 6, name: "edition", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+        { no: 6, name: "edition", kind: "scalar", T: ScalarType.STRING },
     ],
     packedByDefault: true,
 });