@bufbuild/protobuf 1.7.2 → 1.9.0

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

@@ -0,0 +1,9 @@
+import type { FieldInfo } from "../field.js";
+/**
+ * Returns true if the field is set.
+ */
+export declare function isFieldSet(field: FieldInfo, target: Record<string, any>): boolean;
+/**
+ * Resets the field, so that isFieldSet() will return false.
+ */
+export declare function clearField(field: FieldInfo, target: Record<string, any>): void;

package/dist/esm/private/reflect.js

@@ -0,0 +1,74 @@
+// Copyright 2021-2024 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// 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 { isScalarZeroValue, scalarZeroValue } from "./scalars.js";
+/**
+ * Returns true if the field is set.
+ */
+export function isFieldSet(field, target) {
+    const localName = field.localName;
+    if (field.repeated) {
+        return target[localName].length > 0;
+    }
+    if (field.oneof) {
+        return target[field.oneof.localName].case === localName; // eslint-disable-line @typescript-eslint/no-unsafe-member-access
+    }
+    switch (field.kind) {
+        case "enum":
+        case "scalar":
+            if (field.opt || field.req) {
+                // explicit presence
+                return target[localName] !== undefined;
+            }
+            // implicit presence
+            if (field.kind == "enum") {
+                return target[localName] !== field.T.values[0].no;
+            }
+            return !isScalarZeroValue(field.T, target[localName]);
+        case "message":
+            return target[localName] !== undefined;
+        case "map":
+            return Object.keys(target[localName]).length > 0; // eslint-disable-line @typescript-eslint/no-unsafe-argument
+    }
+}
+/**
+ * Resets the field, so that isFieldSet() will return false.
+ */
+export function clearField(field, target) {
+    const localName = field.localName;
+    const implicitPresence = !field.opt && !field.req;
+    if (field.repeated) {
+        target[localName] = [];
+    }
+    else if (field.oneof) {
+        target[field.oneof.localName] = { case: undefined };
+    }
+    else {
+        switch (field.kind) {
+            case "map":
+                target[localName] = {};
+                break;
+            case "enum":
+                target[localName] = implicitPresence ? field.T.values[0].no : undefined;
+                break;
+            case "scalar":
+                target[localName] = implicitPresence
+                    ? scalarZeroValue(field.T, field.L)
+                    : undefined;
+                break;
+            case "message":
+                target[localName] = undefined;
+                break;
+        }
+    }
+}

package/dist/esm/private/reify-wkt.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 { ScalarType } from "../scalar.js";
 /**
  * @deprecated please use reifyWkt from @bufbuild/protoplugin/ecmascript instead
  *

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

@@ -1,27 +1,18 @@
-import { LongType, ScalarType } from "../field.js";
-import type { IBinaryWriter } from "../binary-encoding.js";
-import { WireType } from "../binary-encoding.js";
+import { LongType, ScalarType } from "../scalar.js";
+import type { ScalarValue } from "../scalar.js";
 /**
  * Returns true if both scalar values are equal.
  */
 export declare function scalarEquals(type: ScalarType, a: string | boolean | number | bigint | Uint8Array | undefined, b: string | boolean | number | bigint | Uint8Array | undefined): boolean;
 /**
- * Returns the default value for the given scalar type, following
- * proto3 semantics.
+ * Returns the zero value for the given scalar type.
  */
-export declare function scalarDefaultValue(type: ScalarType, longType: LongType): any;
+export declare function scalarZeroValue<T extends ScalarType, L extends LongType>(type: T, longType: L): ScalarValue<T, L>;
 /**
- * Get information for writing a scalar value.
+ * Returns true for a zero-value. For example, an integer has the zero-value `0`,
+ * a boolean is `false`, a string is `""`, and bytes is an empty Uint8Array.
  *
- * Returns tuple:
- * [0]: appropriate WireType
- * [1]: name of the appropriate method of IBinaryWriter
- * [2]: whether the given value is a default value for proto3 semantics
- *
- * If argument `value` is omitted, [2] is always false.
+ * In proto3, zero-values are not written to the wire, unless the field is
+ * optional or repeated.
  */
-export declare function scalarTypeInfo(type: ScalarType, value?: any): [
-    WireType,
-    Exclude<keyof IBinaryWriter, "tag" | "raw" | "fork" | "join" | "finish">,
-    boolean
-];
+export declare function isScalarZeroValue(type: ScalarType, value: unknown): boolean;

package/dist/esm/private/scalars.js

@@ -11,10 +11,8 @@
 // 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 { LongType, ScalarType } from "../field.js";
-import { WireType } from "../binary-encoding.js";
 import { protoInt64 } from "../proto-int64.js";
-/* eslint-disable @typescript-eslint/no-explicit-any */
+import { LongType, ScalarType } from "../scalar.js";
 /**
  * Returns true if both scalar values are equal.
  */
@@ -54,10 +52,9 @@ export function scalarEquals(type, a, b) {
     return false;
 }
 /**
- * Returns the default value for the given scalar type, following
- * proto3 semantics.
+ * Returns the zero value for the given scalar type.
  */
-export function scalarDefaultValue(type, longType) {
+export function scalarZeroValue(type, longType) {
     switch (type) {
         case ScalarType.BOOL:
             return false;
@@ -67,7 +64,7 @@ export function scalarDefaultValue(type, longType) {
         case ScalarType.SFIXED64:
         case ScalarType.SINT64:
             // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- acceptable since it's covered by tests
-            return longType == 0 ? protoInt64.zero : "0";
+            return (longType == 0 ? protoInt64.zero : "0");
         case ScalarType.DOUBLE:
         case ScalarType.FLOAT:
             return 0.0;
@@ -82,62 +79,21 @@ export function scalarDefaultValue(type, longType) {
     }
 }
 /**
- * Get information for writing a scalar value.
+ * Returns true for a zero-value. For example, an integer has the zero-value `0`,
+ * a boolean is `false`, a string is `""`, and bytes is an empty Uint8Array.
  *
- * Returns tuple:
- * [0]: appropriate WireType
- * [1]: name of the appropriate method of IBinaryWriter
- * [2]: whether the given value is a default value for proto3 semantics
- *
- * If argument `value` is omitted, [2] is always false.
+ * In proto3, zero-values are not written to the wire, unless the field is
+ * optional or repeated.
  */
-export function scalarTypeInfo(type, value) {
-    const isUndefined = value === undefined;
-    let wireType = WireType.Varint;
-    let isIntrinsicDefault = value === 0;
-    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- INT32, UINT32, SINT32 are covered by the defaults
+export function isScalarZeroValue(type, value) {
     switch (type) {
-        case ScalarType.STRING:
-            isIntrinsicDefault = isUndefined || !value.length;
-            wireType = WireType.LengthDelimited;
-            break;
         case ScalarType.BOOL:
-            isIntrinsicDefault = value === false;
-            break;
-        case ScalarType.DOUBLE:
-            wireType = WireType.Bit64;
-            break;
-        case ScalarType.FLOAT:
-            wireType = WireType.Bit32;
-            break;
-        case ScalarType.INT64:
-            isIntrinsicDefault = isUndefined || value == 0; // Loose comparison matches 0n, 0 and "0"
-            break;
-        case ScalarType.UINT64:
-            isIntrinsicDefault = isUndefined || value == 0; // Loose comparison matches 0n, 0 and "0"
-            break;
-        case ScalarType.FIXED64:
-            isIntrinsicDefault = isUndefined || value == 0; // Loose comparison matches 0n, 0 and "0"
-            wireType = WireType.Bit64;
-            break;
+            return value === false;
+        case ScalarType.STRING:
+            return value === "";
         case ScalarType.BYTES:
-            isIntrinsicDefault = isUndefined || !value.byteLength;
-            wireType = WireType.LengthDelimited;
-            break;
-        case ScalarType.FIXED32:
-            wireType = WireType.Bit32;
-            break;
-        case ScalarType.SFIXED32:
-            wireType = WireType.Bit32;
-            break;
-        case ScalarType.SFIXED64:
-            isIntrinsicDefault = isUndefined || value == 0;
-            wireType = WireType.Bit64;
-            break;
-        case ScalarType.SINT64:
-            isIntrinsicDefault = isUndefined || value == 0;
-            break;
+            return value instanceof Uint8Array && !value.byteLength;
+        default:
+            return value == 0; // Loose comparison matches 0n, 0 and "0"
     }
-    const method = ScalarType[type].toLowerCase();
-    return [wireType, method, isUndefined || isIntrinsicDefault];
 }

package/dist/esm/private/text-format.d.ts

@@ -1,4 +1,4 @@
 import type { DescEnum } from "../descriptor-set.js";
-import { ScalarType } from "../field.js";
+import { ScalarType } from "../scalar.js";
 export declare function parseTextFormatEnumValue(descEnum: DescEnum, value: string): number;
 export declare function parseTextFormatScalarValue(type: ScalarType, value: string): number | boolean | string | bigint | Uint8Array;

package/dist/esm/private/text-format.js

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 import { assert } from "./assert.js";
-import { ScalarType } from "../field.js";
 import { protoInt64 } from "../proto-int64.js";
+import { ScalarType } from "../scalar.js";
 export function parseTextFormatEnumValue(descEnum, value) {
     const enumValue = descEnum.values.find((v) => v.name === value);
     assert(enumValue, `cannot parse ${descEnum.name} default value: ${value}`);

package/dist/esm/private/util-common.js

@@ -13,8 +13,9 @@
 // limitations under the License.
 import { setEnumType } from "./enum.js";
 import { Message } from "../message.js";
-import { ScalarType } from "../field.js";
 import { scalarEquals } from "./scalars.js";
+import { ScalarType } from "../scalar.js";
+import { isMessage } from "../is-message.js";
 /* eslint-disable @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-return,@typescript-eslint/no-unsafe-argument,no-case-declarations */
 export function makeUtilCommon() {
     return {
@@ -27,6 +28,7 @@ export function makeUtilCommon() {
             for (const member of type.fields.byMember()) {
                 const localName = member.localName, t = target, s = source;
                 if (s[localName] === undefined) {
+                    // TODO if source is a Message instance, we should use isFieldSet() here to support future field presence
                     continue;
                 }
                 switch (member.kind) {
@@ -39,7 +41,7 @@ export function makeUtilCommon() {
                         let val = s[localName].value;
                         if (sourceField &&
                             sourceField.kind == "message" &&
-                            !(val instanceof sourceField.T)) {
+                            !isMessage(val, sourceField.T)) {
                             val = new sourceField.T(val);
                         }
                         else if (sourceField &&
@@ -89,9 +91,9 @@ export function makeUtilCommon() {
                     case "message":
                         const mt = member.T;
                         if (member.repeated) {
-                            t[localName] = s[localName].map((val) => val instanceof mt ? val : new mt(val));
+                            t[localName] = s[localName].map((val) => isMessage(val, mt) ? val : new mt(val));
                         }
-                        else if (s[localName] !== undefined) {
+                        else {
                             const val = s[localName];
                             if (mt.fieldWrapper) {
                                 if (
@@ -104,13 +106,14 @@ export function makeUtilCommon() {
                                 }
                             }
                             else {
-                                t[localName] = val instanceof mt ? val : new mt(val);
+                                t[localName] = isMessage(val, mt) ? val : new mt(val);
                             }
                         }
                         break;
                 }
             }
         },
+        // TODO use isFieldSet() here to support future field presence
         equals(type, a, b) {
             if (a === b) {
                 return true;
@@ -177,6 +180,7 @@ export function makeUtilCommon() {
                 }
             });
         },
+        // TODO use isFieldSet() here to support future field presence
         clone(message) {
             const type = message.getType(), target = new type(), any = target;
             for (const member of type.fields.byMember()) {
@@ -202,6 +206,9 @@ export function makeUtilCommon() {
                 }
                 any[member.localName] = copy;
             }
+            for (const uf of type.runtime.bin.listUnknownFields(message)) {
+                type.runtime.bin.onUnknownField(any, uf.no, uf.wireType, uf.data);
+            }
             return target;
         },
     };
@@ -211,7 +218,7 @@ function cloneSingularField(value) {
     if (value === undefined) {
         return value;
     }
-    if (value instanceof Message) {
+    if (isMessage(value)) {
         return value.clone();
     }
     if (value instanceof Uint8Array) {

package/dist/esm/proto-delimited.js

@@ -31,7 +31,6 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar
     function reject(value) { resume("throw", value); }
     function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
 };
-import { makeBinaryFormatCommon } from "./private/binary-format-common.js";
 import { BinaryReader } from "./binary-encoding.js";
 /**
  * protoDelimited provides functions to serialize and parse size-delimited
@@ -48,14 +47,14 @@ export const protoDelimited = {
      * Serialize a message, prefixing it with its size.
      */
     enc(message, options) {
-        const opt = makeBinaryFormatCommon().makeWriteOptions(options);
+        const opt = message.getType().runtime.bin.makeWriteOptions(options);
         return opt.writerFactory().bytes(message.toBinary(opt)).finish();
     },
     /**
      * Parse a size-delimited message, ignoring extra bytes.
      */
     dec(type, bytes, options) {
-        const opt = makeBinaryFormatCommon().makeReadOptions(options);
+        const opt = type.runtime.bin.makeReadOptions(options);
         return type.fromBinary(opt.readerFactory(bytes).bytes(), opt);
     },
     /**

package/dist/esm/proto2.js

@@ -12,78 +12,39 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 import { makeProtoRuntime } from "./private/proto-runtime.js";
-import { makeBinaryFormatProto2 } from "./private/binary-format-proto2.js";
-import { makeUtilCommon } from "./private/util-common.js";
 import { InternalFieldList } from "./private/field-list.js";
-import { InternalOneofInfo } from "./private/field.js";
-import { localFieldName, fieldJsonName } from "./private/names.js";
-import { makeJsonFormatProto2 } from "./private/json-format-proto2.js";
-import { LongType } from "./field.js";
+import { normalizeFieldInfos } from "./private/field-normalize.js";
 /**
  * Provides functionality for messages defined with the proto2 syntax.
  */
-export const proto2 = makeProtoRuntime("proto2", makeJsonFormatProto2(), makeBinaryFormatProto2(), Object.assign(Object.assign({}, makeUtilCommon()), { newFieldList(fields) {
-        return new InternalFieldList(fields, normalizeFieldInfosProto2);
-    },
-    initFields(target) {
-        for (const member of target.getType().fields.byMember()) {
-            const name = member.localName, t = target;
-            if (member.repeated) {
-                t[name] = [];
-                continue;
-            }
-            switch (member.kind) {
-                case "oneof":
-                    t[name] = { case: undefined };
-                    break;
-                case "map":
-                    t[name] = {};
-                    break;
-                case "scalar":
-                case "enum":
-                case "message":
-                    // In contrast to proto3, enum and scalar fields have no intrinsic default value,
-                    // only an optional explicit default value.
-                    // Unlike proto3 intrinsic default values, proto2 explicit default values are not
-                    // set on construction, because they are not omitted on the wire. If we did set
-                    // default values on construction, a deserialize-serialize round-trip would add
-                    // fields to a message.
-                    break;
-            }
+export const proto2 = makeProtoRuntime("proto2", (fields) => {
+    return new InternalFieldList(fields, (source) => normalizeFieldInfos(source, false));
+}, 
+// TODO merge with proto3 and initExtensionField, also see initPartial, equals, clone
+(target) => {
+    for (const member of target.getType().fields.byMember()) {
+        const name = member.localName, t = target;
+        if (member.repeated) {
+            t[name] = [];
+            continue;
         }
-    } }));
-/* eslint-disable @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-argument */
-function normalizeFieldInfosProto2(fieldInfos) {
-    var _a, _b, _c, _d, _e;
-    const r = [];
-    let o;
-    for (const field of typeof fieldInfos == "function"
-        ? fieldInfos()
-        : fieldInfos) {
-        const f = field;
-        f.localName = localFieldName(field.name, field.oneof !== undefined);
-        f.jsonName = (_a = field.jsonName) !== null && _a !== void 0 ? _a : fieldJsonName(field.name);
-        f.repeated = (_b = field.repeated) !== null && _b !== void 0 ? _b : false;
-        if (field.kind == "scalar") {
-            f.L = (_c = field.L) !== null && _c !== void 0 ? _c : LongType.BIGINT;
+        switch (member.kind) {
+            case "oneof":
+                t[name] = { case: undefined };
+                break;
+            case "map":
+                t[name] = {};
+                break;
+            case "scalar":
+            case "enum":
+            case "message":
+                // In contrast to proto3, enum and scalar fields have no intrinsic default value,
+                // only an optional explicit default value.
+                // Unlike proto3 intrinsic default values, proto2 explicit default values are not
+                // set on construction, because they are not omitted on the wire. If we did set
+                // default values on construction, a deserialize-serialize round-trip would add
+                // fields to a message.
+                break;
         }
-        // We do not surface options at this time
-        // f.options = field.options ?? emptyReadonlyObject;
-        if (field.oneof !== undefined) {
-            const ooname = typeof field.oneof == "string" ? field.oneof : field.oneof.name;
-            if (!o || o.name != ooname) {
-                o = new InternalOneofInfo(ooname);
-            }
-            f.oneof = o;
-            o.addField(f);
-        }
-        // proto2 specific:
-        if (field.kind == "message") {
-            f.delimited = (_d = field.delimited) !== null && _d !== void 0 ? _d : false;
-        }
-        // In contrast to proto3, repeated fields are unpacked except when explicitly specified.
-        f.packed = (_e = field.packed) !== null && _e !== void 0 ? _e : false;
-        r.push(f);
     }
-    return r;
-}
+});

package/dist/esm/proto3.js

@@ -12,89 +12,42 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 import { makeProtoRuntime } from "./private/proto-runtime.js";
-import { makeBinaryFormatProto3 } from "./private/binary-format-proto3.js";
-import { makeJsonFormatProto3 } from "./private/json-format-proto3.js";
-import { makeUtilCommon } from "./private/util-common.js";
 import { InternalFieldList } from "./private/field-list.js";
-import { scalarDefaultValue } from "./private/scalars.js";
-import { LongType, ScalarType } from "./field.js";
-import { InternalOneofInfo } from "./private/field.js";
-import { localFieldName, fieldJsonName } from "./private/names.js";
+import { scalarZeroValue } from "./private/scalars.js";
+import { normalizeFieldInfos } from "./private/field-normalize.js";
 /**
  * Provides functionality for messages defined with the proto3 syntax.
  */
-export const proto3 = makeProtoRuntime("proto3", makeJsonFormatProto3(), makeBinaryFormatProto3(), Object.assign(Object.assign({}, makeUtilCommon()), { newFieldList(fields) {
-        return new InternalFieldList(fields, normalizeFieldInfosProto3);
-    },
-    initFields(target) {
-        for (const member of target.getType().fields.byMember()) {
-            if (member.opt) {
-                continue;
-            }
-            const name = member.localName, t = target;
-            if (member.repeated) {
-                t[name] = [];
-                continue;
-            }
-            switch (member.kind) {
-                case "oneof":
-                    t[name] = { case: undefined };
-                    break;
-                case "enum":
-                    t[name] = 0;
-                    break;
-                case "map":
-                    t[name] = {};
-                    break;
-                case "scalar":
-                    t[name] = scalarDefaultValue(member.T, member.L); // eslint-disable-line @typescript-eslint/no-unsafe-assignment
-                    break;
-                case "message":
-                    // message fields are always optional in proto3
-                    break;
-            }
+export const proto3 = makeProtoRuntime("proto3", (fields) => {
+    return new InternalFieldList(fields, (source) => normalizeFieldInfos(source, true));
+}, 
+// TODO merge with proto2 and initExtensionField, also see initPartial, equals, clone
+(target) => {
+    for (const member of target.getType().fields.byMember()) {
+        if (member.opt) {
+            continue;
         }
-    } }));
-/* eslint-disable @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-argument */
-function normalizeFieldInfosProto3(fieldInfos) {
-    var _a, _b, _c, _d;
-    const r = [];
-    let o;
-    for (const field of typeof fieldInfos == "function"
-        ? fieldInfos()
-        : fieldInfos) {
-        const f = field;
-        f.localName = localFieldName(field.name, field.oneof !== undefined);
-        f.jsonName = (_a = field.jsonName) !== null && _a !== void 0 ? _a : fieldJsonName(field.name);
-        f.repeated = (_b = field.repeated) !== null && _b !== void 0 ? _b : false;
-        if (field.kind == "scalar") {
-            f.L = (_c = field.L) !== null && _c !== void 0 ? _c : LongType.BIGINT;
+        const name = member.localName, t = target;
+        if (member.repeated) {
+            t[name] = [];
+            continue;
         }
-        // We do not surface options at this time
-        // f.options = field.options ?? emptyReadonlyObject;
-        if (field.oneof !== undefined) {
-            const ooname = typeof field.oneof == "string" ? field.oneof : field.oneof.name;
-            if (!o || o.name != ooname) {
-                o = new InternalOneofInfo(ooname);
-            }
-            f.oneof = o;
-            o.addField(f);
+        switch (member.kind) {
+            case "oneof":
+                t[name] = { case: undefined };
+                break;
+            case "enum":
+                t[name] = 0;
+                break;
+            case "map":
+                t[name] = {};
+                break;
+            case "scalar":
+                t[name] = scalarZeroValue(member.T, member.L);
+                break;
+            case "message":
+                // message fields are always optional in proto3
+                break;
         }
-        // proto3 specific:
-        if (field.kind == "message") {
-            f.delimited = false;
-        }
-        // From the proto3 language guide:
-        // > In proto3, repeated fields of scalar numeric types are packed by default.
-        // This information is incomplete - according to the conformance tests, BOOL
-        // and ENUM are packed by default as well. This means only STRING and BYTES
-        // are not packed by default, which makes sense because they are length-delimited.
-        f.packed =
-            (_d = field.packed) !== null && _d !== void 0 ? _d : (field.kind == "enum" ||
-                (field.kind == "scalar" &&
-                    field.T != ScalarType.BYTES &&
-                    field.T != ScalarType.STRING));
-        r.push(f);
     }
-    return r;
-}
+});

package/dist/esm/scalar.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Scalar value types. This is a subset of field types declared by protobuf
+ * enum google.protobuf.FieldDescriptorProto.Type The types GROUP and MESSAGE
+ * are omitted, but the numerical values are identical.
+ */
+export declare enum ScalarType {
+    DOUBLE = 1,
+    FLOAT = 2,
+    INT64 = 3,
+    UINT64 = 4,
+    INT32 = 5,
+    FIXED64 = 6,
+    FIXED32 = 7,
+    BOOL = 8,
+    STRING = 9,
+    BYTES = 12,
+    UINT32 = 13,
+    SFIXED32 = 15,
+    SFIXED64 = 16,
+    SINT32 = 17,// Uses ZigZag encoding.
+    SINT64 = 18
+}
+/**
+ * JavaScript representation of fields with 64 bit integral types (int64, uint64,
+ * sint64, fixed64, sfixed64).
+ *
+ * This is a subset of google.protobuf.FieldOptions.JSType, which defines JS_NORMAL,
+ * JS_STRING, and JS_NUMBER. Protobuf-ES uses BigInt by default, but will use
+ * String if `[jstype = JS_STRING]` is specified.
+ *
+ * ```protobuf
+ * uint64 field_a = 1; // BigInt
+ * uint64 field_b = 2 [jstype = JS_NORMAL]; // BigInt
+ * uint64 field_b = 2 [jstype = JS_NUMBER]; // BigInt
+ * uint64 field_b = 2 [jstype = JS_STRING]; // String
+ * ```
+ */
+export declare enum LongType {
+    /**
+     * Use JavaScript BigInt.
+     */
+    BIGINT = 0,
+    /**
+     * Use JavaScript String.
+     *
+     * Field option `[jstype = JS_STRING]`.
+     */
+    STRING = 1
+}
+/**
+ * ScalarValue maps from a scalar field type to a TypeScript value type.
+ */
+export type ScalarValue<T = ScalarType, L extends LongType = LongType.STRING | LongType.BIGINT> = T extends ScalarType.STRING ? string : T extends ScalarType.INT32 ? number : T extends ScalarType.UINT32 ? number : T extends ScalarType.UINT32 ? number : T extends ScalarType.SINT32 ? number : T extends ScalarType.FIXED32 ? number : T extends ScalarType.SFIXED32 ? number : T extends ScalarType.FLOAT ? number : T extends ScalarType.DOUBLE ? number : T extends ScalarType.INT64 ? (L extends LongType.STRING ? string : bigint) : T extends ScalarType.SINT64 ? (L extends LongType.STRING ? string : bigint) : T extends ScalarType.SFIXED64 ? (L extends LongType.STRING ? string : bigint) : T extends ScalarType.UINT64 ? (L extends LongType.STRING ? string : bigint) : T extends ScalarType.FIXED64 ? (L extends LongType.STRING ? string : bigint) : T extends ScalarType.BOOL ? boolean : T extends ScalarType.BYTES ? Uint8Array : never;