@bufbuild/protobuf 2.0.0-alpha.2 → 2.0.0-alpha.4

package/dist/esm/proto-int64.js

@@ -11,8 +11,11 @@
 // 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 { assert } from "./reflect/assert.js";
 import { int64FromString, int64ToString, uInt64ToString, } from "./wire/varint.js";
+/**
+ * Int64Support for the current environment.
+ */
+export const protoInt64 = /*@__PURE__*/ makeInt64Support();
 function makeInt64Support() {
     const dv = new DataView(new ArrayBuffer(8));
     // note that Safari 14 implements BigInt, but not the DataView methods
@@ -32,14 +35,14 @@ function makeInt64Support() {
             parse(value) {
                 const bi = typeof value == "bigint" ? value : BigInt(value);
                 if (bi > MAX || bi < MIN) {
-                    throw new Error(`int64 invalid: ${value}`);
+                    throw new Error(`invalid int64: ${value}`);
                 }
                 return bi;
             },
             uParse(value) {
                 const bi = typeof value == "bigint" ? value : BigInt(value);
                 if (bi > UMAX || bi < UMIN) {
-                    throw new Error(`uint64 invalid: ${value}`);
+                    throw new Error(`invalid uint64: ${value}`);
                 }
                 return bi;
             },
@@ -69,8 +72,6 @@ function makeInt64Support() {
             },
         };
     }
-    const assertInt64String = (value) => assert(/^-?[0-9]+$/.test(value), `int64 invalid: ${value}`);
-    const assertUInt64String = (value) => assert(/^[0-9]+$/.test(value), `uint64 invalid: ${value}`);
     return {
         zero: "0",
         supported: false,
@@ -110,4 +111,13 @@ function makeInt64Support() {
         },
     };
 }
-export const protoInt64 = makeInt64Support();
+function assertInt64String(value) {
+    if (!/^-?[0-9]+$/.test(value)) {
+        throw new Error("invalid int64: " + value);
+    }
+}
+function assertUInt64String(value) {
+    if (!/^[0-9]+$/.test(value)) {
+        throw new Error("invalid uint64: " + value);
+    }
+}

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

@@ -1,4 +1,4 @@
-import type { DescField, DescOneof } from "../desc-types.js";
+import type { DescField, DescOneof } from "../descriptors.js";
 declare const errorNames: string[];
 export declare class FieldError extends Error {
     readonly name: (typeof errorNames)[number];

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

@@ -1,7 +1,7 @@
 import type { Message } from "../types.js";
 import type { ScalarValue } from "./scalar.js";
 import type { ReflectList, ReflectMap, ReflectMessage } from "./reflect-types.js";
-import type { DescField, DescMessage } from "../desc-types.js";
+import type { DescField, DescMessage } from "../descriptors.js";
 export declare function isObject(arg: unknown): arg is Record<string, unknown>;
 export declare function isOneofADT(arg: unknown): arg is OneofADT;
 export type OneofADT = {

package/dist/esm/reflect/guard.js

@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 import { unsafeLocal } from "./unsafe.js";
-import { isMessage } from "../is-message.js";
 export function isObject(arg) {
     return arg !== null && typeof arg == "object" && !Array.isArray(arg);
 }
@@ -64,7 +63,8 @@ export function isReflectMap(arg, field) {
 export function isReflectMessage(arg, messageDesc) {
     return (isObject(arg) &&
         unsafeLocal in arg &&
-        "message" in arg &&
-        isMessage(arg.message) &&
-        (messageDesc === undefined || arg.message.$typeName == messageDesc.typeName));
+        "desc" in arg &&
+        isObject(arg.desc) &&
+        arg.desc.kind === "message" &&
+        (messageDesc === undefined || arg.desc.typeName == messageDesc.typeName));
 }

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

@@ -3,6 +3,5 @@ export * from "./names.js";
 export * from "./nested-types.js";
 export * from "./reflect.js";
 export * from "./reflect-types.js";
-export * from "./registry.js";
 export * from "./scalar.js";
 export { isReflectList, isReflectMap, isReflectMessage } from "./guard.js";

package/dist/esm/reflect/index.js

@@ -16,6 +16,5 @@ export * from "./names.js";
 export * from "./nested-types.js";
 export * from "./reflect.js";
 export * from "./reflect-types.js";
-export * from "./registry.js";
 export * from "./scalar.js";
 export { isReflectList, isReflectMap, isReflectMessage } from "./guard.js";

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

@@ -6,6 +6,6 @@ export declare function protoCamelCase(snakeCase: string): string;
 /**
  * Escapes names that are reserved for ECMAScript built-in object properties.
  *
- * Also see safeIdentifier() from @bufbuild/protoplugin/ecmascript.
+ * Also see safeIdentifier() from @bufbuild/protoplugin.
  */
 export declare function safeObjectProperty(name: string): string;

package/dist/esm/reflect/names.js

@@ -62,7 +62,7 @@ const reservedObjectProperties = new Set([
 /**
  * Escapes names that are reserved for ECMAScript built-in object properties.
  *
- * Also see safeIdentifier() from @bufbuild/protoplugin/ecmascript.
+ * Also see safeIdentifier() from @bufbuild/protoplugin.
  */
 export function safeObjectProperty(name) {
     return reservedObjectProperties.has(name) ? name + "$" : name;

package/dist/esm/reflect/nested-types.d.ts

@@ -1,4 +1,4 @@
-import type { AnyDesc, DescEnum, DescExtension, DescFile, DescMessage, DescService } from "../desc-types.js";
+import type { AnyDesc, DescEnum, DescExtension, DescFile, DescMessage, DescService } from "../descriptors.js";
 /**
  * Iterate over all types - enumerations, extensions, services, messages -
  * and enumerations, extensions and messages nested in messages.

package/dist/esm/reflect/reflect-check.d.ts

@@ -1,9 +1,18 @@
-import type { DescField } from "../desc-types.js";
+import { type DescField } from "../descriptors.js";
 import { FieldError } from "./error.js";
+/**
+ * Check whether the given field value is valid for the reflect API.
+ */
 export declare function checkField(field: DescField, value: unknown): FieldError | undefined;
+/**
+ * Check whether the given list item is valid for the reflect API.
+ */
 export declare function checkListItem(field: DescField & {
     fieldKind: "list";
 }, index: number, value: unknown): FieldError | undefined;
+/**
+ * Check whether the given map key and value are valid for the reflect API.
+ */
 export declare function checkMapEntry(field: DescField & {
     fieldKind: "map";
 }, key: unknown, value: unknown): FieldError | undefined;

package/dist/esm/reflect/reflect-check.js

@@ -11,11 +11,16 @@
 // 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, scalarTypeDescription } from "./scalar.js";
-import { checkScalarValue } from "./scalar.js";
+import { ScalarType, } from "../descriptors.js";
 import { isMessage } from "../is-message.js";
 import { FieldError } from "./error.js";
 import { isReflectList, isReflectMap, isReflectMessage } from "./guard.js";
+import { FLOAT32_MAX, FLOAT32_MIN, INT32_MAX, INT32_MIN, UINT32_MAX, } from "../wire/binary-encoding.js";
+import { getTextEncoding } from "../wire/text-encoding.js";
+import { protoInt64 } from "../proto-int64.js";
+/**
+ * Check whether the given field value is valid for the reflect API.
+ */
 export function checkField(field, value) {
     const check = field.fieldKind == "list"
         ? isReflectList(value, field)
@@ -39,6 +44,9 @@ export function checkField(field, value) {
     }
     return new FieldError(field, reason);
 }
+/**
+ * Check whether the given list item is valid for the reflect API.
+ */
 export function checkListItem(field, index, value) {
     const check = checkSingular(field, value);
     if (check !== true) {
@@ -46,6 +54,9 @@ export function checkListItem(field, index, value) {
     }
     return undefined;
 }
+/**
+ * Check whether the given map key and value are valid for the reflect API.
+ */
 export function checkMapEntry(field, key, value) {
     const checkKey = checkScalarValue(key, field.mapKey);
     if (checkKey !== true) {
@@ -69,6 +80,84 @@ function checkSingular(field, value) {
     }
     return isReflectMessage(value, field.message);
 }
+function checkScalarValue(value, scalar) {
+    switch (scalar) {
+        case ScalarType.DOUBLE:
+            return typeof value == "number";
+        case ScalarType.FLOAT:
+            if (typeof value != "number") {
+                return false;
+            }
+            if (Number.isNaN(value) || !Number.isFinite(value)) {
+                return true;
+            }
+            if (value > FLOAT32_MAX || value < FLOAT32_MIN) {
+                return `${value.toFixed()} out of range`;
+            }
+            return true;
+        case ScalarType.INT32:
+        case ScalarType.SFIXED32:
+        case ScalarType.SINT32:
+            // signed
+            if (typeof value !== "number" || !Number.isInteger(value)) {
+                return false;
+            }
+            if (value > INT32_MAX || value < INT32_MIN) {
+                return `${value.toFixed()} out of range`;
+            }
+            return true;
+        case ScalarType.FIXED32:
+        case ScalarType.UINT32:
+            // unsigned
+            if (typeof value !== "number" || !Number.isInteger(value)) {
+                return false;
+            }
+            if (value > UINT32_MAX || value < 0) {
+                return `${value.toFixed()} out of range`;
+            }
+            return true;
+        case ScalarType.BOOL:
+            return typeof value == "boolean";
+        case ScalarType.STRING:
+            if (typeof value != "string") {
+                return false;
+            }
+            return getTextEncoding().checkUtf8(value) || "invalid UTF8";
+        case ScalarType.BYTES:
+            return value instanceof Uint8Array;
+        case ScalarType.INT64:
+        case ScalarType.SFIXED64:
+        case ScalarType.SINT64:
+            // signed
+            if (typeof value != "string" &&
+                typeof value !== "bigint" &&
+                typeof value !== "number") {
+                return false;
+            }
+            try {
+                protoInt64.parse(value);
+            }
+            catch (e) {
+                return `${value} out of range`;
+            }
+            return true;
+        case ScalarType.FIXED64:
+        case ScalarType.UINT64:
+            // unsigned
+            if (typeof value != "string" &&
+                typeof value !== "bigint" &&
+                typeof value !== "number") {
+                return false;
+            }
+            try {
+                protoInt64.uParse(value);
+            }
+            catch (e) {
+                return `${value} out of range`;
+            }
+            return true;
+    }
+}
 function reasonSingular(field, val, details) {
     details =
         typeof details == "string" ? `: ${details}` : `, got ${formatVal(val)}`;
@@ -141,3 +230,31 @@ function formatReflectMap(field) {
             return `ReflectMap (${ScalarType[field.mapKey]}, ${ScalarType[field.scalar]})`;
     }
 }
+function scalarTypeDescription(scalar) {
+    switch (scalar) {
+        case ScalarType.STRING:
+            return "string";
+        case ScalarType.BOOL:
+            return "boolean";
+        case ScalarType.INT64:
+        case ScalarType.SINT64:
+        case ScalarType.SFIXED64:
+            return "bigint (int64)";
+        case ScalarType.UINT64:
+        case ScalarType.FIXED64:
+            return "bigint (uint64)";
+        case ScalarType.BYTES:
+            return "Uint8Array";
+        case ScalarType.DOUBLE:
+            return "number (float64)";
+        case ScalarType.FLOAT:
+            return "number (float32)";
+        case ScalarType.FIXED32:
+        case ScalarType.UINT32:
+            return "number (uint32)";
+        case ScalarType.INT32:
+        case ScalarType.SFIXED32:
+        case ScalarType.SINT32:
+            return "number (int32)";
+    }
+}

package/dist/esm/reflect/reflect-types.d.ts

@@ -1,8 +1,8 @@
-import type { DescField, DescMessage, DescOneof } from "../desc-types.js";
+import { type DescField, type DescMessage, type DescOneof } from "../descriptors.js";
 import { FieldError } from "./error.js";
 import { unsafeLocal } from "./unsafe.js";
 import type { Message, UnknownField } from "../types.js";
-import type { LongType, ScalarValue } from "./scalar.js";
+import type { ScalarValue } from "./scalar.js";
 /**
  * ReflectMessage provides dynamic access and manipulation of a message.
  */
@@ -109,18 +109,6 @@ export interface ReflectMessage {
      * a valid value. To reset a field, use clear().
      */
     set<Field extends DescField>(field: Field, value: ReflectSetValue<Field>): FieldError | undefined;
-    /**
-     * Add an item to a list field.
-     */
-    addListItem<Field extends DescField & {
-        fieldKind: "list";
-    }>(field: Field, value: ReflectAddListItemValue<Field>): FieldError | undefined;
-    /**
-     * Set a map entry.
-     */
-    setMapEntry<Field extends DescField & {
-        fieldKind: "map";
-    }>(field: Field, key: MapEntryKey, value: ReflectSetMapEntryValue<Field>): FieldError | undefined;
     /**
      * Returns the unknown fields of the message.
      */
@@ -230,7 +218,7 @@ export type ReflectGetValue<Field extends DescField = DescField> = (Field extend
 } ? ReflectMap<MapEntryKey, enumVal> : Field extends {
     mapKind: "scalar";
     scalar: infer T;
-} ? ReflectMap<MapEntryKey, ScalarValue<T, LongType.BIGINT>> : never) : Field extends {
+} ? ReflectMap<MapEntryKey, ScalarValue<T>> : never) : Field extends {
     fieldKind: "list";
 } ? ReflectList : Field extends {
     fieldKind: "enum";
@@ -255,30 +243,4 @@ export type ReflectSetValue<Field extends DescField = DescField> = (Field extend
     fieldKind: "scalar";
     scalar: infer T;
 } ? ScalarValue<T> : never);
-/**
- * The type of the "value" argument of ReflectMessage.addListItem()
- */
-export type ReflectAddListItemValue<Field extends DescField & {
-    fieldKind: "list";
-}> = (Field extends {
-    listKind: "scalar";
-    scalar: infer T;
-} ? ScalarValue<T> : Field extends {
-    listKind: "enum";
-} ? enumVal : Field extends {
-    listKind: "message";
-} ? ReflectMessage : never);
-/**
- * The type of the "value" argument of ReflectMessage.setMapEntry()
- */
-export type ReflectSetMapEntryValue<Field extends DescField & {
-    fieldKind: "map";
-}> = (Field extends {
-    mapKind: "enum";
-} ? enumVal : Field extends {
-    mapKind: "message";
-} ? ReflectMessage : Field extends {
-    mapKind: "scalar";
-    scalar: infer T;
-} ? ScalarValue<T, LongType.BIGINT> : never);
 export {};

package/dist/esm/reflect/reflect-types.js

@@ -11,5 +11,6 @@
 // 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 {} from "../descriptors.js";
 import { FieldError } from "./error.js";
 import { unsafeLocal } from "./unsafe.js";

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

@@ -1,4 +1,4 @@
-import type { DescField, DescMessage } from "../desc-types.js";
+import { type DescField, type DescMessage } from "../descriptors.js";
 import type { MessageShape } from "../types.js";
 import type { MapEntryKey, ReflectList, ReflectMap, ReflectMessage } from "./reflect-types.js";
 /**

package/dist/esm/reflect/reflect.js

@@ -11,12 +11,13 @@
 // 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 "../descriptors.js";
 import { checkField, checkListItem, checkMapEntry } from "./reflect-check.js";
 import { FieldError } from "./error.js";
-import { unsafeAddListItem, unsafeClear, unsafeGet, unsafeIsSet, unsafeLocal, unsafeOneofCase, unsafeSet, unsafeSetMapEntry, } from "./unsafe.js";
+import { unsafeClear, unsafeGet, unsafeIsSet, unsafeLocal, unsafeOneofCase, unsafeSet, } from "./unsafe.js";
 import { create } from "../create.js";
 import { isWrapper, isWrapperDesc } from "../wkt/wrappers.js";
-import { LongType, ScalarType, scalarZeroValue } from "./scalar.js";
+import { scalarZeroValue } from "./scalar.js";
 import { protoInt64 } from "../proto-int64.js";
 import { isReflectList, isReflectMap, isReflectMessage } from "./guard.js";
 /**
@@ -37,6 +38,8 @@ class ReflectMessageImpl {
     constructor(messageDesc, message, 
     // TODO either remove this option, or support it in reflect-list and reflect-map as well
     check = true) {
+        this.lists = new Map();
+        this.maps = new Map();
         this.check = check;
         this.desc = messageDesc;
         this.message = this[unsafeLocal] = message !== null && message !== void 0 ? message : create(messageDesc);
@@ -67,11 +70,19 @@ class ReflectMessageImpl {
         let value = unsafeGet(this.message, field);
         switch (field.fieldKind) {
             case "list":
-                return new ReflectListImpl(field, value, this.check);
+                // eslint-disable-next-line no-case-declarations
+                let list = this.lists.get(field);
+                if (!list || list[unsafeLocal] !== value) {
+                    this.lists.set(field, (list = new ReflectListImpl(field, value, this.check)));
+                }
+                return list;
             case "map":
-                // TODO fix types
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-                return reflectMap(field, value, this.check); // eslint-disable-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-return
+                // eslint-disable-next-line no-case-declarations
+                let map = this.maps.get(field);
+                if (!map || map[unsafeLocal] !== value) {
+                    this.maps.set(field, (map = new ReflectMapImpl(field, value, this.check)));
+                }
+                return map;
             case "message":
                 if (value !== undefined &&
                     !field.oneof &&
@@ -84,7 +95,7 @@ class ReflectMessageImpl {
                 return new ReflectMessageImpl(field.message, value, this.check);
             case "scalar":
                 return (value === undefined
-                    ? scalarZeroValue(field.scalar, LongType.BIGINT)
+                    ? scalarZeroValue(field.scalar, false)
                     : longToReflect(field, value));
             case "enum":
                 return (value !== null && value !== void 0 ? value : field.enum.values[0].number);
@@ -98,7 +109,7 @@ class ReflectMessageImpl {
                 return err;
             }
         }
-        let local = value;
+        let local;
         if (isReflectMap(value) || isReflectList(value)) {
             local = value[unsafeLocal];
         }
@@ -112,30 +123,6 @@ class ReflectMessageImpl {
         unsafeSet(this.message, field, local);
         return undefined;
     }
-    addListItem(field, value) {
-        assertOwn(this.message, field);
-        assertKind(field, "list");
-        if (this.check) {
-            if (checkListItem(field, 0, value)) {
-                const arr = unsafeGet(this.message, field);
-                return checkListItem(field, arr.length, value);
-            }
-        }
-        unsafeAddListItem(this.message, field, listItemToLocal(field, value));
-        return undefined;
-    }
-    setMapEntry(field, key, value) {
-        assertOwn(this.message, field);
-        assertKind(field, "map");
-        if (this.check) {
-            const err = checkMapEntry(field, key, value);
-            if (err) {
-                return err;
-            }
-        }
-        unsafeSetMapEntry(this.message, field, mapKeyToLocal(key), mapValueToLocal(field, value));
-        return undefined;
-    }
     getUnknown() {
         return this.message.$unknown;
     }
@@ -143,11 +130,6 @@ class ReflectMessageImpl {
         this.message.$unknown = value;
     }
 }
-function assertKind(field, kind) {
-    if (field.fieldKind != kind) {
-        throw new FieldError(field, `${field.toString()} is ${field.fieldKind}`, "ForeignFieldError");
-    }
-}
 function assertOwn(owner, member) {
     if (member.parent.typeName !== owner.$typeName) {
         throw new FieldError(member, `cannot use ${member.toString()} with message ${owner.$typeName}`, "ForeignFieldError");
@@ -384,16 +366,16 @@ function longToReflect(field, value) {
         case ScalarType.INT64:
         case ScalarType.SFIXED64:
         case ScalarType.SINT64:
-            if ("longType" in field &&
-                field.longType == LongType.STRING &&
+            if ("longAsString" in field &&
+                field.longAsString &&
                 typeof value == "string") {
                 value = protoInt64.parse(value);
             }
             break;
         case ScalarType.FIXED64:
         case ScalarType.UINT64:
-            if ("longType" in field &&
-                field.longType == LongType.STRING &&
+            if ("longAsString" in field &&
+                field.longAsString &&
                 typeof value == "string") {
                 value = protoInt64.uParse(value);
             }
@@ -407,7 +389,7 @@ function longToLocal(field, value) {
         case ScalarType.INT64:
         case ScalarType.SFIXED64:
         case ScalarType.SINT64:
-            if ("longType" in field && field.longType == LongType.STRING) {
+            if ("longAsString" in field && field.longAsString) {
                 value = String(value);
             }
             else if (typeof value == "string" || typeof value == "number") {
@@ -416,7 +398,7 @@ function longToLocal(field, value) {
             break;
         case ScalarType.FIXED64:
         case ScalarType.UINT64:
-            if ("longType" in field && field.longType == LongType.STRING) {
+            if ("longAsString" in field && field.longAsString) {
                 value = String(value);
             }
             else if (typeof value == "string" || typeof value == "number") {

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

@@ -1,56 +1,8 @@
-/**
- * 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
-}
+import { ScalarType } from "../descriptors.js";
 /**
  * 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;
+export type ScalarValue<T = ScalarType, LongAsString extends boolean = false> = T extends ScalarType.STRING ? string : T extends ScalarType.INT32 ? 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 ? LongAsString extends true ? string : bigint : T extends ScalarType.SINT64 ? LongAsString extends true ? string : bigint : T extends ScalarType.SFIXED64 ? LongAsString extends true ? string : bigint : T extends ScalarType.UINT64 ? LongAsString extends true ? string : bigint : T extends ScalarType.FIXED64 ? LongAsString extends true ? string : bigint : T extends ScalarType.BOOL ? boolean : T extends ScalarType.BYTES ? Uint8Array : never;
 /**
  * Returns true if both scalar values are equal.
  */
@@ -58,7 +10,7 @@ export declare function scalarEquals(type: ScalarType, a: string | boolean | num
 /**
  * Returns the zero value for the given scalar type.
  */
-export declare function scalarZeroValue<T extends ScalarType, L extends LongType>(type: T, longType: L): ScalarValue<T, L>;
+export declare function scalarZeroValue<T extends ScalarType, LongAsString extends boolean>(type: T, longAsString: LongAsString): ScalarValue<T, LongAsString>;
 /**
  * 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.
@@ -67,7 +19,3 @@ export declare function scalarZeroValue<T extends ScalarType, L extends LongType
  * optional or repeated.
  */
 export declare function isScalarZeroValue(type: ScalarType, value: unknown): boolean;
-export type InvalidScalarValueErr = false | "invalid UTF8" | `${string} out of range`;
-export declare function checkScalarValue(value: unknown, scalar: ScalarType): true | InvalidScalarValueErr;
-export declare function scalarTypeDescription(scalar: ScalarType): string;
-export declare function scalarTypeScriptType(scalar: ScalarType, long: LongType): "string" | "boolean" | "bigint" | "bigint | string" | "Uint8Array" | "number";