@bufbuild/protobuf 1.3.2 → 1.4.0

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

@@ -267,10 +267,9 @@ export class ExtensionRangeOptions extends Message {
          */
         this.uninterpretedOption = [];
         /**
-         * go/protobuf-stripping-extension-declarations
-         * Like Metadata, but we use a repeated field to hold all extension
-         * declarations. This should avoid the size increases of transforming a large
-         * extension range into small ranges in generated binaries.
+         * For external users: DO NOT USE. We are in the process of open sourcing
+         * extension declaration and executing internal cleanups before it can be
+         * used externally.
          *
          * @generated from field: repeated google.protobuf.ExtensionRangeOptions.Declaration declaration = 2;
          */
@@ -295,6 +294,7 @@ ExtensionRangeOptions.typeName = "google.protobuf.ExtensionRangeOptions";
 ExtensionRangeOptions.fields = proto2.util.newFieldList(() => [
     { no: 999, name: "uninterpreted_option", kind: "message", T: UninterpretedOption, repeated: true },
     { no: 2, name: "declaration", kind: "message", T: ExtensionRangeOptions_Declaration, repeated: true },
+    { no: 50, name: "features", kind: "message", T: FeatureSet, opt: true },
     { no: 3, name: "verification", kind: "enum", T: proto2.getEnumType(ExtensionRangeOptions_VerificationState), opt: true, default: ExtensionRangeOptions_VerificationState.UNVERIFIED },
 ]);
 /**
@@ -347,7 +347,6 @@ ExtensionRangeOptions_Declaration.fields = proto2.util.newFieldList(() => [
     { no: 1, name: "number", kind: "scalar", T: 5 /* ScalarType.INT32 */, opt: true },
     { no: 2, name: "full_name", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
     { no: 3, name: "type", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
-    { no: 4, name: "is_repeated", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
     { no: 5, name: "reserved", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
     { no: 6, name: "repeated", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
 ]);
@@ -798,6 +797,7 @@ FileOptions.fields = proto2.util.newFieldList(() => [
     { no: 41, name: "php_namespace", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
     { no: 44, name: "php_metadata_namespace", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
     { no: 45, name: "ruby_package", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 50, name: "features", kind: "message", T: FeatureSet, opt: true },
     { no: 999, name: "uninterpreted_option", kind: "message", T: UninterpretedOption, repeated: true },
 ]);
 /**
@@ -869,6 +869,7 @@ MessageOptions.fields = proto2.util.newFieldList(() => [
     { no: 3, name: "deprecated", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true, default: false },
     { no: 7, name: "map_entry", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
     { no: 11, name: "deprecated_legacy_json_field_conflicts", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
+    { no: 12, name: "features", kind: "message", T: FeatureSet, opt: true },
     { no: 999, name: "uninterpreted_option", kind: "message", T: UninterpretedOption, repeated: true },
 ]);
 /**
@@ -881,6 +882,10 @@ export class FieldOptions extends Message {
          * @generated from field: repeated google.protobuf.FieldOptions.OptionTargetType targets = 19;
          */
         this.targets = [];
+        /**
+         * @generated from field: repeated google.protobuf.FieldOptions.EditionDefault edition_defaults = 20;
+         */
+        this.editionDefaults = [];
         /**
          * The parser stores options it doesn't recognize here. See above.
          *
@@ -914,8 +919,9 @@ FieldOptions.fields = proto2.util.newFieldList(() => [
     { no: 10, name: "weak", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true, default: false },
     { no: 16, name: "debug_redact", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true, default: false },
     { no: 17, name: "retention", kind: "enum", T: proto2.getEnumType(FieldOptions_OptionRetention), opt: true },
-    { no: 18, name: "target", kind: "enum", T: proto2.getEnumType(FieldOptions_OptionTargetType), opt: true },
     { no: 19, name: "targets", kind: "enum", T: proto2.getEnumType(FieldOptions_OptionTargetType), repeated: true },
+    { no: 20, name: "edition_defaults", kind: "message", T: FieldOptions_EditionDefault, repeated: true },
+    { no: 21, name: "features", kind: "message", T: FeatureSet, opt: true },
     { no: 999, name: "uninterpreted_option", kind: "message", T: UninterpretedOption, repeated: true },
 ]);
 /**
@@ -1073,6 +1079,33 @@ proto2.util.setEnumType(FieldOptions_OptionTargetType, "google.protobuf.FieldOpt
     { no: 8, name: "TARGET_TYPE_SERVICE" },
     { no: 9, name: "TARGET_TYPE_METHOD" },
 ]);
+/**
+ * @generated from message google.protobuf.FieldOptions.EditionDefault
+ */
+export class FieldOptions_EditionDefault extends Message {
+    constructor(data) {
+        super();
+        proto2.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new FieldOptions_EditionDefault().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new FieldOptions_EditionDefault().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new FieldOptions_EditionDefault().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto2.util.equals(FieldOptions_EditionDefault, a, b);
+    }
+}
+FieldOptions_EditionDefault.runtime = proto2;
+FieldOptions_EditionDefault.typeName = "google.protobuf.FieldOptions.EditionDefault";
+FieldOptions_EditionDefault.fields = proto2.util.newFieldList(() => [
+    { no: 1, name: "edition", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 2, name: "value", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+]);
 /**
  * @generated from message google.protobuf.OneofOptions
  */
@@ -1103,6 +1136,7 @@ export class OneofOptions extends Message {
 OneofOptions.runtime = proto2;
 OneofOptions.typeName = "google.protobuf.OneofOptions";
 OneofOptions.fields = proto2.util.newFieldList(() => [
+    { no: 1, name: "features", kind: "message", T: FeatureSet, opt: true },
     { no: 999, name: "uninterpreted_option", kind: "message", T: UninterpretedOption, repeated: true },
 ]);
 /**
@@ -1138,6 +1172,7 @@ EnumOptions.fields = proto2.util.newFieldList(() => [
     { no: 2, name: "allow_alias", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
     { no: 3, name: "deprecated", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true, default: false },
     { no: 6, name: "deprecated_legacy_json_field_conflicts", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
+    { no: 7, name: "features", kind: "message", T: FeatureSet, opt: true },
     { no: 999, name: "uninterpreted_option", kind: "message", T: UninterpretedOption, repeated: true },
 ]);
 /**
@@ -1171,6 +1206,8 @@ EnumValueOptions.runtime = proto2;
 EnumValueOptions.typeName = "google.protobuf.EnumValueOptions";
 EnumValueOptions.fields = proto2.util.newFieldList(() => [
     { no: 1, name: "deprecated", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true, default: false },
+    { no: 2, name: "features", kind: "message", T: FeatureSet, opt: true },
+    { no: 3, name: "debug_redact", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true, default: false },
     { no: 999, name: "uninterpreted_option", kind: "message", T: UninterpretedOption, repeated: true },
 ]);
 /**
@@ -1203,6 +1240,7 @@ export class ServiceOptions extends Message {
 ServiceOptions.runtime = proto2;
 ServiceOptions.typeName = "google.protobuf.ServiceOptions";
 ServiceOptions.fields = proto2.util.newFieldList(() => [
+    { no: 34, name: "features", kind: "message", T: FeatureSet, opt: true },
     { no: 33, name: "deprecated", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true, default: false },
     { no: 999, name: "uninterpreted_option", kind: "message", T: UninterpretedOption, repeated: true },
 ]);
@@ -1238,6 +1276,7 @@ MethodOptions.typeName = "google.protobuf.MethodOptions";
 MethodOptions.fields = proto2.util.newFieldList(() => [
     { no: 33, name: "deprecated", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true, default: false },
     { no: 34, name: "idempotency_level", kind: "enum", T: proto2.getEnumType(MethodOptions_IdempotencyLevel), opt: true, default: MethodOptions_IdempotencyLevel.IDEMPOTENCY_UNKNOWN },
+    { no: 35, name: "features", kind: "message", T: FeatureSet, opt: true },
     { no: 999, name: "uninterpreted_option", kind: "message", T: UninterpretedOption, repeated: true },
 ]);
 /**
@@ -1348,6 +1387,199 @@ UninterpretedOption_NamePart.fields = proto2.util.newFieldList(() => [
     { no: 1, name: "name_part", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 2, name: "is_extension", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
 ]);
+/**
+ * TODO(b/274655146) Enums in C++ gencode (and potentially other languages) are
+ * not well scoped.  This means that each of the feature enums below can clash
+ * with each other.  The short names we've chosen maximize call-site
+ * readability, but leave us very open to this scenario.  A future feature will
+ * be designed and implemented to handle this, hopefully before we ever hit a
+ * conflict here.
+ *
+ * @generated from message google.protobuf.FeatureSet
+ */
+export class FeatureSet extends Message {
+    constructor(data) {
+        super();
+        proto2.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new FeatureSet().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new FeatureSet().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new FeatureSet().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto2.util.equals(FeatureSet, a, b);
+    }
+}
+FeatureSet.runtime = proto2;
+FeatureSet.typeName = "google.protobuf.FeatureSet";
+FeatureSet.fields = proto2.util.newFieldList(() => [
+    { no: 1, name: "field_presence", kind: "enum", T: proto2.getEnumType(FeatureSet_FieldPresence), opt: true },
+    { no: 2, name: "enum_type", kind: "enum", T: proto2.getEnumType(FeatureSet_EnumType), opt: true },
+    { no: 3, name: "repeated_field_encoding", kind: "enum", T: proto2.getEnumType(FeatureSet_RepeatedFieldEncoding), opt: true },
+    { no: 4, name: "string_field_validation", kind: "enum", T: proto2.getEnumType(FeatureSet_StringFieldValidation), opt: true },
+    { no: 5, name: "message_encoding", kind: "enum", T: proto2.getEnumType(FeatureSet_MessageEncoding), opt: true },
+    { no: 6, name: "json_format", kind: "enum", T: proto2.getEnumType(FeatureSet_JsonFormat), opt: true },
+    { no: 999, name: "raw_features", kind: "message", T: FeatureSet, opt: true },
+]);
+/**
+ * @generated from enum google.protobuf.FeatureSet.FieldPresence
+ */
+export var FeatureSet_FieldPresence;
+(function (FeatureSet_FieldPresence) {
+    /**
+     * @generated from enum value: FIELD_PRESENCE_UNKNOWN = 0;
+     */
+    FeatureSet_FieldPresence[FeatureSet_FieldPresence["FIELD_PRESENCE_UNKNOWN"] = 0] = "FIELD_PRESENCE_UNKNOWN";
+    /**
+     * @generated from enum value: EXPLICIT = 1;
+     */
+    FeatureSet_FieldPresence[FeatureSet_FieldPresence["EXPLICIT"] = 1] = "EXPLICIT";
+    /**
+     * @generated from enum value: IMPLICIT = 2;
+     */
+    FeatureSet_FieldPresence[FeatureSet_FieldPresence["IMPLICIT"] = 2] = "IMPLICIT";
+    /**
+     * @generated from enum value: LEGACY_REQUIRED = 3;
+     */
+    FeatureSet_FieldPresence[FeatureSet_FieldPresence["LEGACY_REQUIRED"] = 3] = "LEGACY_REQUIRED";
+})(FeatureSet_FieldPresence || (FeatureSet_FieldPresence = {}));
+// Retrieve enum metadata with: proto2.getEnumType(FeatureSet_FieldPresence)
+proto2.util.setEnumType(FeatureSet_FieldPresence, "google.protobuf.FeatureSet.FieldPresence", [
+    { no: 0, name: "FIELD_PRESENCE_UNKNOWN" },
+    { no: 1, name: "EXPLICIT" },
+    { no: 2, name: "IMPLICIT" },
+    { no: 3, name: "LEGACY_REQUIRED" },
+]);
+/**
+ * @generated from enum google.protobuf.FeatureSet.EnumType
+ */
+export var FeatureSet_EnumType;
+(function (FeatureSet_EnumType) {
+    /**
+     * @generated from enum value: ENUM_TYPE_UNKNOWN = 0;
+     */
+    FeatureSet_EnumType[FeatureSet_EnumType["ENUM_TYPE_UNKNOWN"] = 0] = "ENUM_TYPE_UNKNOWN";
+    /**
+     * @generated from enum value: OPEN = 1;
+     */
+    FeatureSet_EnumType[FeatureSet_EnumType["OPEN"] = 1] = "OPEN";
+    /**
+     * @generated from enum value: CLOSED = 2;
+     */
+    FeatureSet_EnumType[FeatureSet_EnumType["CLOSED"] = 2] = "CLOSED";
+})(FeatureSet_EnumType || (FeatureSet_EnumType = {}));
+// Retrieve enum metadata with: proto2.getEnumType(FeatureSet_EnumType)
+proto2.util.setEnumType(FeatureSet_EnumType, "google.protobuf.FeatureSet.EnumType", [
+    { no: 0, name: "ENUM_TYPE_UNKNOWN" },
+    { no: 1, name: "OPEN" },
+    { no: 2, name: "CLOSED" },
+]);
+/**
+ * @generated from enum google.protobuf.FeatureSet.RepeatedFieldEncoding
+ */
+export var FeatureSet_RepeatedFieldEncoding;
+(function (FeatureSet_RepeatedFieldEncoding) {
+    /**
+     * @generated from enum value: REPEATED_FIELD_ENCODING_UNKNOWN = 0;
+     */
+    FeatureSet_RepeatedFieldEncoding[FeatureSet_RepeatedFieldEncoding["REPEATED_FIELD_ENCODING_UNKNOWN"] = 0] = "REPEATED_FIELD_ENCODING_UNKNOWN";
+    /**
+     * @generated from enum value: PACKED = 1;
+     */
+    FeatureSet_RepeatedFieldEncoding[FeatureSet_RepeatedFieldEncoding["PACKED"] = 1] = "PACKED";
+    /**
+     * @generated from enum value: EXPANDED = 2;
+     */
+    FeatureSet_RepeatedFieldEncoding[FeatureSet_RepeatedFieldEncoding["EXPANDED"] = 2] = "EXPANDED";
+})(FeatureSet_RepeatedFieldEncoding || (FeatureSet_RepeatedFieldEncoding = {}));
+// Retrieve enum metadata with: proto2.getEnumType(FeatureSet_RepeatedFieldEncoding)
+proto2.util.setEnumType(FeatureSet_RepeatedFieldEncoding, "google.protobuf.FeatureSet.RepeatedFieldEncoding", [
+    { no: 0, name: "REPEATED_FIELD_ENCODING_UNKNOWN" },
+    { no: 1, name: "PACKED" },
+    { no: 2, name: "EXPANDED" },
+]);
+/**
+ * @generated from enum google.protobuf.FeatureSet.StringFieldValidation
+ */
+export var FeatureSet_StringFieldValidation;
+(function (FeatureSet_StringFieldValidation) {
+    /**
+     * @generated from enum value: STRING_FIELD_VALIDATION_UNKNOWN = 0;
+     */
+    FeatureSet_StringFieldValidation[FeatureSet_StringFieldValidation["STRING_FIELD_VALIDATION_UNKNOWN"] = 0] = "STRING_FIELD_VALIDATION_UNKNOWN";
+    /**
+     * @generated from enum value: MANDATORY = 1;
+     */
+    FeatureSet_StringFieldValidation[FeatureSet_StringFieldValidation["MANDATORY"] = 1] = "MANDATORY";
+    /**
+     * @generated from enum value: HINT = 2;
+     */
+    FeatureSet_StringFieldValidation[FeatureSet_StringFieldValidation["HINT"] = 2] = "HINT";
+    /**
+     * @generated from enum value: NONE = 3;
+     */
+    FeatureSet_StringFieldValidation[FeatureSet_StringFieldValidation["NONE"] = 3] = "NONE";
+})(FeatureSet_StringFieldValidation || (FeatureSet_StringFieldValidation = {}));
+// Retrieve enum metadata with: proto2.getEnumType(FeatureSet_StringFieldValidation)
+proto2.util.setEnumType(FeatureSet_StringFieldValidation, "google.protobuf.FeatureSet.StringFieldValidation", [
+    { no: 0, name: "STRING_FIELD_VALIDATION_UNKNOWN" },
+    { no: 1, name: "MANDATORY" },
+    { no: 2, name: "HINT" },
+    { no: 3, name: "NONE" },
+]);
+/**
+ * @generated from enum google.protobuf.FeatureSet.MessageEncoding
+ */
+export var FeatureSet_MessageEncoding;
+(function (FeatureSet_MessageEncoding) {
+    /**
+     * @generated from enum value: MESSAGE_ENCODING_UNKNOWN = 0;
+     */
+    FeatureSet_MessageEncoding[FeatureSet_MessageEncoding["MESSAGE_ENCODING_UNKNOWN"] = 0] = "MESSAGE_ENCODING_UNKNOWN";
+    /**
+     * @generated from enum value: LENGTH_PREFIXED = 1;
+     */
+    FeatureSet_MessageEncoding[FeatureSet_MessageEncoding["LENGTH_PREFIXED"] = 1] = "LENGTH_PREFIXED";
+    /**
+     * @generated from enum value: DELIMITED = 2;
+     */
+    FeatureSet_MessageEncoding[FeatureSet_MessageEncoding["DELIMITED"] = 2] = "DELIMITED";
+})(FeatureSet_MessageEncoding || (FeatureSet_MessageEncoding = {}));
+// Retrieve enum metadata with: proto2.getEnumType(FeatureSet_MessageEncoding)
+proto2.util.setEnumType(FeatureSet_MessageEncoding, "google.protobuf.FeatureSet.MessageEncoding", [
+    { no: 0, name: "MESSAGE_ENCODING_UNKNOWN" },
+    { no: 1, name: "LENGTH_PREFIXED" },
+    { no: 2, name: "DELIMITED" },
+]);
+/**
+ * @generated from enum google.protobuf.FeatureSet.JsonFormat
+ */
+export var FeatureSet_JsonFormat;
+(function (FeatureSet_JsonFormat) {
+    /**
+     * @generated from enum value: JSON_FORMAT_UNKNOWN = 0;
+     */
+    FeatureSet_JsonFormat[FeatureSet_JsonFormat["JSON_FORMAT_UNKNOWN"] = 0] = "JSON_FORMAT_UNKNOWN";
+    /**
+     * @generated from enum value: ALLOW = 1;
+     */
+    FeatureSet_JsonFormat[FeatureSet_JsonFormat["ALLOW"] = 1] = "ALLOW";
+    /**
+     * @generated from enum value: LEGACY_BEST_EFFORT = 2;
+     */
+    FeatureSet_JsonFormat[FeatureSet_JsonFormat["LEGACY_BEST_EFFORT"] = 2] = "LEGACY_BEST_EFFORT";
+})(FeatureSet_JsonFormat || (FeatureSet_JsonFormat = {}));
+// Retrieve enum metadata with: proto2.getEnumType(FeatureSet_JsonFormat)
+proto2.util.setEnumType(FeatureSet_JsonFormat, "google.protobuf.FeatureSet.JsonFormat", [
+    { no: 0, name: "JSON_FORMAT_UNKNOWN" },
+    { no: 1, name: "ALLOW" },
+    { no: 2, name: "LEGACY_BEST_EFFORT" },
+]);
 /**
  * Encapsulates information about the original source file from which a
  * FileDescriptorProto was generated.

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

@@ -138,7 +138,7 @@ export class Duration extends Message {
                 nanosStr = nanosStr.substring(0, 6);
             }
             text += "." + nanosStr;
-            if (this.nanos < 0 && this.seconds === protoInt64.zero) {
+            if (this.nanos < 0 && Number(this.seconds) == 0) {
                 text = "-" + text;
             }
         }

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

@@ -11,7 +11,7 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-// @generated by protoc-gen-es v1.3.2 with parameter "bootstrap_wkt=true,ts_nocheck=false,target=ts"
+// @generated by protoc-gen-es v1.4.0 with parameter "bootstrap_wkt=true,ts_nocheck=false,target=ts"
 // @generated from file google/protobuf/struct.proto (package google.protobuf, syntax proto3)
 /* eslint-disable */
 import { proto3 } from "../../proto3.js";

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

@@ -11,7 +11,7 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-// @generated by protoc-gen-es v1.3.2 with parameter "bootstrap_wkt=true,ts_nocheck=false,target=ts"
+// @generated by protoc-gen-es v1.4.0 with parameter "bootstrap_wkt=true,ts_nocheck=false,target=ts"
 // @generated from file google/protobuf/type.proto (package google.protobuf, syntax proto3)
 /* eslint-disable */
 import { proto3 } from "../../proto3.js";

package/dist/esm/index.d.ts

@@ -9,7 +9,7 @@ export { Message } from "./message.js";
 export type { AnyMessage, PartialMessage, PlainMessage } from "./message.js";
 export type { FieldInfo } from "./field.js";
 export type { FieldList } from "./field-list.js";
-export { ScalarType } from "./field.js";
+export { ScalarType, LongType } from "./field.js";
 export type { MessageType } from "./message-type.js";
 export type { EnumType, EnumValueInfo } from "./enum.js";
 export type { ServiceType, MethodInfo, MethodInfoUnary, MethodInfoServerStreaming, MethodInfoClientStreaming, MethodInfoBiDiStreaming, } from "./service-type.js";

package/dist/esm/index.js

@@ -19,7 +19,7 @@ export { protoBase64 } from "./proto-base64.js";
 export { protoDelimited } from "./proto-delimited.js";
 export { codegenInfo } from "./codegen-info.js";
 export { Message } from "./message.js";
-export { ScalarType } from "./field.js";
+export { ScalarType, LongType } from "./field.js";
 export { MethodKind, MethodIdempotency } from "./service-type.js";
 export { WireType, BinaryWriter, BinaryReader } from "./binary-encoding.js";
 export { createDescriptorSet } from "./create-descriptor-set.js";

package/dist/esm/json-format.d.ts

@@ -1,6 +1,7 @@
 import type { Message } from "./message.js";
 import type { MessageType } from "./message-type.js";
 import type { ScalarType } from "./field.js";
+import { LongType } from "./field.js";
 import type { IMessageTypeRegistry } from "./type-registry.js";
 /**
  * JsonFormat is the contract for serializing messages to and from JSON.
@@ -26,10 +27,11 @@ export interface JsonFormat {
     writeMessage(message: Message, options: JsonWriteOptions): JsonValue;
     /**
      * Parse a single scalar value from JSON.
+     *
      * This method may throw an error, but it may have a blank error message.
      * Callers are expected to provide context.
      */
-    readScalar(type: ScalarType, json: JsonValue): any;
+    readScalar(type: ScalarType, json: JsonValue, longType?: LongType): any;
     /**
      * Serialize a single scalar value to JSON.
      */

package/dist/esm/json-format.js

@@ -11,4 +11,4 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-export {};
+import { LongType } from "./field.js";

package/dist/esm/private/binary-format-common.d.ts

@@ -1,10 +1,10 @@
-import type { IBinaryWriter } from "../binary-encoding.js";
-import type { BinaryWriteOptions } from "../binary-format.js";
-import type { BinaryFormat } from "../binary-format.js";
-import { ScalarType } from "../field.js";
+import type { IBinaryReader, IBinaryWriter } from "../binary-encoding.js";
+import type { BinaryFormat, BinaryWriteOptions } from "../binary-format.js";
 import type { FieldInfo } from "../field.js";
+import { ScalarType } from "../field.js";
 import type { MessageType } from "../message-type.js";
 export declare function makeBinaryFormatCommon(): Omit<BinaryFormat, "writeMessage">;
+export declare function readScalarLTString(reader: IBinaryReader, type: ScalarType): any;
 export declare function writeMapEntry(writer: IBinaryWriter, options: BinaryWriteOptions, field: FieldInfo & {
     kind: "map";
 }, key: any, value: any): void;

package/dist/esm/private/binary-format-common.js

@@ -13,7 +13,7 @@
 // limitations under the License.
 import { BinaryReader, BinaryWriter, WireType } from "../binary-encoding.js";
 import { Message } from "../message.js";
-import { ScalarType } from "../field.js";
+import { LongType, ScalarType } from "../field.js";
 import { wrapField } from "./field-wrapper.js";
 import { scalarDefaultValue, scalarTypeInfo } from "./scalars.js";
 import { assert } from "./assert.js";
@@ -87,6 +87,11 @@ export function makeBinaryFormatCommon() {
                     case "scalar":
                     case "enum":
                         const scalarType = field.kind == "enum" ? ScalarType.INT32 : field.T;
+                        let read = readScalar;
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- acceptable since it's covered by tests
+                        if (field.kind == "scalar" && field.L > 0) {
+                            read = readScalarLTString;
+                        }
                         if (repeated) {
                             let arr = target[localName]; // safe to assume presence of array, oneof cannot contain repeated values
                             if (wireType == WireType.LengthDelimited &&
@@ -94,15 +99,15 @@ export function makeBinaryFormatCommon() {
                                 scalarType != ScalarType.BYTES) {
                                 let e = reader.uint32() + reader.pos;
                                 while (reader.pos < e) {
-                                    arr.push(readScalar(reader, scalarType));
+                                    arr.push(read(reader, scalarType));
                                 }
                             }
                             else {
-                                arr.push(readScalar(reader, scalarType));
+                                arr.push(read(reader, scalarType));
                             }
                         }
                         else {
-                            target[localName] = readScalar(reader, scalarType);
+                            target[localName] = read(reader, scalarType);
                         }
                         break;
                     case "message":
@@ -168,7 +173,7 @@ function readMapEntry(field, reader, options) {
         }
     }
     if (key === undefined) {
-        let keyRaw = scalarDefaultValue(field.K);
+        let keyRaw = scalarDefaultValue(field.K, LongType.BIGINT);
         key =
             field.K == ScalarType.BOOL
                 ? keyRaw.toString()
@@ -180,7 +185,7 @@ function readMapEntry(field, reader, options) {
     if (val === undefined) {
         switch (field.V.kind) {
             case "scalar":
-                val = scalarDefaultValue(field.V.T);
+                val = scalarDefaultValue(field.V.T, LongType.BIGINT);
                 break;
             case "enum":
                 val = 0;
@@ -192,6 +197,12 @@ function readMapEntry(field, reader, options) {
     }
     return [key, val];
 }
+// Read a scalar value, but return 64 bit integral types (int64, uint64,
+// sint64, fixed64, sfixed64) as string instead of bigint.
+export function readScalarLTString(reader, type) {
+    const v = readScalar(reader, type);
+    return typeof v == "bigint" ? v.toString() : v;
+}
 // Does not use scalarTypeInfo() for better performance.
 function readScalar(reader, type) {
     switch (type) {

package/dist/esm/private/json-format-common.d.ts

@@ -1,6 +1,6 @@
 import type { JsonFormat, JsonValue, JsonWriteOptions } from "../json-format.js";
-import { ScalarType } from "../field.js";
 import type { FieldInfo } from "../field.js";
+import { ScalarType } from "../field.js";
 import type { EnumType } from "../enum.js";
 type JsonFormatWriteFieldFn = (field: FieldInfo, value: any, options: JsonWriteOptions) => JsonValue | undefined;
 export declare function makeJsonFormatCommon(makeWriteField: (writeEnumFn: typeof writeEnum, writeScalarFn: typeof writeScalar) => JsonFormatWriteFieldFn): JsonFormat;

package/dist/esm/private/json-format-common.js

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 import { Message } from "../message.js";
-import { ScalarType } from "../field.js";
+import { LongType, ScalarType } from "../field.js";
 import { assert, assertFloat32, assertInt32, assertUInt32 } from "./assert.js";
 import { protoInt64 } from "../proto-int64.js";
 import { protoBase64 } from "../proto-base64.js";
@@ -93,7 +93,7 @@ export function makeJsonFormatCommon(makeWriteField) {
                                 break;
                             case "scalar":
                                 try {
-                                    val = readScalar(field.T, jsonItem);
+                                    val = readScalar(field.T, jsonItem, field.L);
                                 }
                                 catch (e) {
                                     let m = `cannot decode field ${type.typeName}.${field.name} from JSON: ${this.debug(jsonItem)}`;
@@ -131,7 +131,7 @@ export function makeJsonFormatCommon(makeWriteField) {
                                 break;
                             case "scalar":
                                 try {
-                                    val = readScalar(field.V.T, jsonMapValue);
+                                    val = readScalar(field.V.T, jsonMapValue, LongType.BIGINT);
                                 }
                                 catch (e) {
                                     let m = `cannot decode map value for field ${type.typeName}.${field.name} from JSON: ${this.debug(jsonValue)}`;
@@ -149,7 +149,7 @@ export function makeJsonFormatCommon(makeWriteField) {
                                     : jsonMapKey == "false"
                                         ? false
                                         : jsonMapKey
-                                : jsonMapKey).toString()] = val;
+                                : jsonMapKey, LongType.BIGINT).toString()] = val;
                         }
                         catch (e) {
                             let m = `cannot decode map key for field ${type.typeName}.${field.name} from JSON: ${this.debug(jsonValue)}`;
@@ -189,7 +189,7 @@ export function makeJsonFormatCommon(makeWriteField) {
                             break;
                         case "scalar":
                             try {
-                                target[localName] = readScalar(field.T, jsonValue);
+                                target[localName] = readScalar(field.T, jsonValue, field.L);
                             }
                             catch (e) {
                                 let m = `cannot decode field ${type.typeName}.${field.name} from JSON: ${this.debug(jsonValue)}`;
@@ -261,7 +261,7 @@ function debugJsonValue(json) {
 }
 // May throw an error. If the error message is non-blank, it should be shown.
 // It is up to the caller to provide context.
-function readScalar(type, json) {
+function readScalar(type, json, longType) {
     // every valid case in the switch below returns, and every fall
     // through is regarded as a failure.
     switch (type) {
@@ -330,14 +330,18 @@ function readScalar(type, json) {
                 return protoInt64.zero;
             if (typeof json != "number" && typeof json != "string")
                 break;
-            return protoInt64.parse(json);
+            const long = protoInt64.parse(json);
+            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+            return longType ? long.toString() : long;
         case ScalarType.FIXED64:
         case ScalarType.UINT64:
             if (json === null)
                 return protoInt64.zero;
             if (typeof json != "number" && typeof json != "string")
                 break;
-            return protoInt64.uParse(json);
+            const uLong = protoInt64.uParse(json);
+            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+            return longType ? uLong.toString() : uLong;
         // bool:
         case ScalarType.BOOL:
             if (json === null)

package/dist/esm/private/scalars.d.ts

@@ -1,4 +1,4 @@
-import { ScalarType } from "../field.js";
+import { LongType, ScalarType } from "../field.js";
 import type { IBinaryWriter } from "../binary-encoding.js";
 import { WireType } from "../binary-encoding.js";
 /**
@@ -9,7 +9,7 @@ export declare function scalarEquals(type: ScalarType, a: string | boolean | num
  * Returns the default value for the given scalar type, following
  * proto3 semantics.
  */
-export declare function scalarDefaultValue(type: ScalarType): any;
+export declare function scalarDefaultValue(type: ScalarType, longType: LongType): any;
 /**
  * Get information for writing a scalar value.
  *

package/dist/esm/private/scalars.js

@@ -11,7 +11,7 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-import { ScalarType } from "../field.js";
+import { LongType, ScalarType } from "../field.js";
 import { WireType } from "../binary-encoding.js";
 import { protoInt64 } from "../proto-int64.js";
 /* eslint-disable @typescript-eslint/no-explicit-any */
@@ -57,7 +57,7 @@ export function scalarEquals(type, a, b) {
  * Returns the default value for the given scalar type, following
  * proto3 semantics.
  */
-export function scalarDefaultValue(type) {
+export function scalarDefaultValue(type, longType) {
     switch (type) {
         case ScalarType.BOOL:
             return false;
@@ -66,7 +66,8 @@ export function scalarDefaultValue(type) {
         case ScalarType.INT64:
         case ScalarType.SFIXED64:
         case ScalarType.SINT64:
-            return protoInt64.zero;
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- acceptable since it's covered by tests
+            return longType == 0 ? protoInt64.zero : "0";
         case ScalarType.DOUBLE:
         case ScalarType.FLOAT:
             return 0.0;
@@ -110,13 +111,13 @@ export function scalarTypeInfo(type, value) {
             wireType = WireType.Bit32;
             break;
         case ScalarType.INT64:
-            isIntrinsicDefault = isUndefined || value == 0;
+            isIntrinsicDefault = isUndefined || value == 0; // Loose comparison matches 0n, 0 and "0"
             break;
         case ScalarType.UINT64:
-            isIntrinsicDefault = isUndefined || value == 0;
+            isIntrinsicDefault = isUndefined || value == 0; // Loose comparison matches 0n, 0 and "0"
             break;
         case ScalarType.FIXED64:
-            isIntrinsicDefault = isUndefined || value == 0;
+            isIntrinsicDefault = isUndefined || value == 0; // Loose comparison matches 0n, 0 and "0"
             wireType = WireType.Bit64;
             break;
         case ScalarType.BYTES: