@bufbuild/protobuf 2.0.0-alpha.3 → 2.0.0-beta.1

package/dist/esm/is-message.js

@@ -15,7 +15,7 @@
  * Determine whether the given `arg` is a message.
  * If `desc` is set, determine whether `arg` is this specific message.
  */
-export function isMessage(arg, desc) {
+export function isMessage(arg, schema) {
     const isMessage = arg !== null &&
         typeof arg == "object" &&
         "$typeName" in arg &&
@@ -23,8 +23,8 @@ export function isMessage(arg, desc) {
     if (!isMessage) {
         return false;
     }
-    if (desc === undefined) {
+    if (schema === undefined) {
         return true;
     }
-    return desc.typeName === arg.$typeName;
+    return schema.typeName === arg.$typeName;
 }

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/reflect-types.d.ts

@@ -1,5 +1,4 @@
 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 { ScalarValue } from "./scalar.js";
@@ -87,7 +86,7 @@ export interface ReflectMessage {
      * Note that get() never returns `undefined`. To determine whether a field is
      * set, use isSet().
      */
-    get<Field extends DescField>(field: Field): ReflectGetValue<Field>;
+    get<Field extends DescField>(field: Field): ReflectMessageGet<Field>;
     /**
      * Set a field value.
      *
@@ -105,22 +104,10 @@ export interface ReflectMessage {
      * - Map fields:
      *   ReflectMap.
      *
-     * Returns an error if the value is invalid for the field. `undefined` is not
+     * Throws an error if the value is invalid for the field. `undefined` is not
      * 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;
+    set<Field extends DescField>(field: Field, value: unknown): void;
     /**
      * Returns the unknown fields of the message.
      */
@@ -159,16 +146,16 @@ export interface ReflectList<V = unknown> extends Iterable<V> {
      */
     get(index: number): V | undefined;
     /**
-     * Adds an item - or several items - at the end of the list.
-     * Returns an error if an item is invalid for this list.
+     * Adds an item at the end of the list.
+     * Throws an error if an item is invalid for this list.
      */
-    add(...item: V[]): FieldError | undefined;
+    add(item: V): void;
     /**
      * Replaces the item at the specified index with the specified item.
-     * Returns an error if the index is out of range (index < 0 || index >= size).
-     * Returns an error if the item is invalid for this list.
+     * Throws an error if the index is out of range (index < 0 || index >= size).
+     * Throws an error if the item is invalid for this list.
      */
-    set(index: number, item: V): FieldError | undefined;
+    set(index: number, item: V): void;
     /**
      * Removes all items from the list.
      */
@@ -190,7 +177,7 @@ export interface ReflectList<V = unknown> extends Iterable<V> {
  *   ReflectMap converts keys to their closest possible type in TypeScript.
  * - Messages are wrapped in a ReflectMessage.
  */
-export interface ReflectMap<K extends MapEntryKey = MapEntryKey, V = unknown> extends ReadonlyMap<K, V> {
+export interface ReflectMap<K = unknown, V = unknown> extends ReadonlyMap<K, V> {
     /**
      * Returns the map field.
      */
@@ -204,46 +191,19 @@ export interface ReflectMap<K extends MapEntryKey = MapEntryKey, V = unknown> ex
     delete(key: K): boolean;
     /**
      * Sets or replaces the item at the specified key with the specified value.
-     * Returns an error if the key or value is invalid for this map.
+     * Throws an error if the key or value is invalid for this map.
      */
-    set(key: K, value: V): FieldError | undefined;
+    set(key: K, value: V): this;
     /**
      * Removes all entries from the map.
      */
     clear(): void;
     [unsafeLocal]: Record<string, unknown>;
 }
-/**
- * A ReflectMap key.
- */
-export type MapEntryKey = string | number | bigint | boolean;
-type enumVal = number;
 /**
  * The return type of ReflectMessage.get()
  */
-export type ReflectGetValue<Field extends DescField = DescField> = (Field extends {
-    fieldKind: "map";
-} ? (Field extends {
-    mapKind: "message";
-} ? ReflectMap<MapEntryKey, ReflectMessage> : Field extends {
-    mapKind: "enum";
-} ? ReflectMap<MapEntryKey, enumVal> : Field extends {
-    mapKind: "scalar";
-    scalar: infer T;
-} ? ReflectMap<MapEntryKey, ScalarValue<T>> : never) : Field extends {
-    fieldKind: "list";
-} ? ReflectList : Field extends {
-    fieldKind: "enum";
-} ? number : Field extends {
-    fieldKind: "message";
-} ? ReflectMessage : Field extends {
-    fieldKind: "scalar";
-    scalar: infer T;
-} ? ScalarValue<T> : never);
-/**
- * The type of the "value" argument of ReflectMessage.set()
- */
-export type ReflectSetValue<Field extends DescField = DescField> = (Field extends {
+export type ReflectMessageGet<Field extends DescField = DescField> = (Field extends {
     fieldKind: "map";
 } ? ReflectMap : Field extends {
     fieldKind: "list";
@@ -255,30 +215,3 @@ 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> : never);
-export {};

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

@@ -12,5 +12,4 @@
 // 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,32 +1,43 @@
 import { type DescField, type DescMessage } from "../descriptors.js";
 import type { MessageShape } from "../types.js";
-import type { MapEntryKey, ReflectList, ReflectMap, ReflectMessage } from "./reflect-types.js";
+import type { ReflectList, ReflectMap, ReflectMessage } from "./reflect-types.js";
 /**
  * Create a ReflectMessage.
  */
-export declare function reflect<Desc extends DescMessage>(messageDesc: Desc, message?: MessageShape<Desc>, opt?: {
-    /**
-     * By default, field values are validated when setting them. For example,
-     * a value for an uint32 field must be a ECMAScript Number >= 0.
-     *
-     * Note that setting a message field validates the type of the message,
-     * but does not check its fields.
-     *
-     * In some contexts, field values are trusted, and performance can be
-     * improved by disabling validation by setting disableFieldValueCheck to
-     * `false`.
-     */
-    disableFieldValueCheck?: boolean;
-}): ReflectMessage;
+export declare function reflect<Desc extends DescMessage>(messageDesc: Desc, message?: MessageShape<Desc>, 
+/**
+ * By default, field values are validated when setting them. For example,
+ * a value for an uint32 field must be a ECMAScript Number >= 0.
+ *
+ * When field values are trusted, performance can be improved by disabling
+ * checks.
+ */
+check?: boolean): ReflectMessage;
 /**
  * Create a ReflectList.
  */
 export declare function reflectList<V>(field: DescField & {
     fieldKind: "list";
-}, unsafeInput?: unknown[], check?: boolean): ReflectList<V>;
+}, unsafeInput?: unknown[], 
+/**
+ * By default, field values are validated when setting them. For example,
+ * a value for an uint32 field must be a ECMAScript Number >= 0.
+ *
+ * When field values are trusted, performance can be improved by disabling
+ * checks.
+ */
+check?: boolean): ReflectList<V>;
 /**
  * Create a ReflectMap.
  */
-export declare function reflectMap<K extends MapEntryKey, V>(field: DescField & {
+export declare function reflectMap<K = unknown, V = unknown>(field: DescField & {
     fieldKind: "map";
-}, unsafeInput?: Record<string, unknown>, check?: boolean): ReflectMap<K, V>;
+}, unsafeInput?: Record<string, unknown>, 
+/**
+ * By default, field values are validated when setting them. For example,
+ * a value for an uint32 field must be a ECMAScript Number >= 0.
+ *
+ * When field values are trusted, performance can be improved by disabling
+ * checks.
+ */
+check?: boolean): ReflectMap<K, V>;

package/dist/esm/reflect/reflect.js

@@ -14,19 +14,25 @@
 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 { scalarZeroValue } from "./scalar.js";
 import { protoInt64 } from "../proto-int64.js";
-import { isReflectList, isReflectMap, isReflectMessage } from "./guard.js";
+import { isObject, isReflectList, isReflectMap, isReflectMessage, } from "./guard.js";
 /**
  * Create a ReflectMessage.
  */
 export function reflect(messageDesc, message, 
-// TODO either remove this option, or support it in reflect-list and reflect-map as well
-opt) {
-    return new ReflectMessageImpl(messageDesc, message, (opt === null || opt === void 0 ? void 0 : opt.disableFieldValueCheck) !== true);
+/**
+ * By default, field values are validated when setting them. For example,
+ * a value for an uint32 field must be a ECMAScript Number >= 0.
+ *
+ * When field values are trusted, performance can be improved by disabling
+ * checks.
+ */
+check = true) {
+    return new ReflectMessageImpl(messageDesc, message, check);
 }
 class ReflectMessageImpl {
     get sortedFields() {
@@ -35,9 +41,9 @@ class ReflectMessageImpl {
             .concat()
             .sort((a, b) => a.number - b.number)));
     }
-    constructor(messageDesc, message, 
-    // TODO either remove this option, or support it in reflect-list and reflect-map as well
-    check = true) {
+    constructor(messageDesc, message, 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);
@@ -65,24 +71,24 @@ class ReflectMessageImpl {
     }
     get(field) {
         assertOwn(this.message, field);
-        let value = unsafeGet(this.message, field);
+        const 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
-            case "message":
-                if (value !== undefined &&
-                    !field.oneof &&
-                    isWrapperDesc(field.message)) {
-                    value = {
-                        $typeName: field.message.typeName,
-                        value: longToReflect(field.message.fields[0], value),
-                    };
+                // 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 new ReflectMessageImpl(field.message, value, this.check);
+                return map;
+            case "message":
+                return messageToReflect(field, value, this.check);
             case "scalar":
                 return (value === undefined
                     ? scalarZeroValue(field.scalar, false)
@@ -96,46 +102,20 @@ class ReflectMessageImpl {
         if (this.check) {
             const err = checkField(field, value);
             if (err) {
-                return err;
+                throw err;
             }
         }
         let local;
-        if (isReflectMap(value) || isReflectList(value)) {
-            local = value[unsafeLocal];
+        if (field.fieldKind == "message") {
+            local = messageToLocal(field, value);
         }
-        else if (isReflectMessage(value)) {
-            const msg = value.message;
-            local = !field.oneof && isWrapper(msg) ? msg.value : msg;
+        else if (isReflectMap(value) || isReflectList(value)) {
+            local = value[unsafeLocal];
         }
         else {
             local = longToLocal(field, value);
         }
         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;
@@ -144,11 +124,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");
@@ -157,7 +132,15 @@ function assertOwn(owner, member) {
 /**
  * Create a ReflectList.
  */
-export function reflectList(field, unsafeInput, check = true) {
+export function reflectList(field, unsafeInput, 
+/**
+ * By default, field values are validated when setting them. For example,
+ * a value for an uint32 field must be a ECMAScript Number >= 0.
+ *
+ * When field values are trusted, performance can be improved by disabling
+ * checks.
+ */
+check = true) {
     return new ReflectListImpl(field, unsafeInput !== null && unsafeInput !== void 0 ? unsafeInput : [], check);
 }
 class ReflectListImpl {
@@ -180,29 +163,24 @@ class ReflectListImpl {
     }
     set(index, item) {
         if (index < 0 || index >= this._arr.length) {
-            return new FieldError(this._field, `list item #${index + 1}: out of range`);
+            throw new FieldError(this._field, `list item #${index + 1}: out of range`);
         }
         if (this.check) {
             const err = checkListItem(this._field, index, item);
             if (err) {
-                return err;
+                throw err;
             }
         }
         this._arr[index] = listItemToLocal(this._field, item);
-        return undefined;
     }
-    add(...items) {
+    add(item) {
         if (this.check) {
-            for (let i = 0; i < items.length; i++) {
-                const err = checkListItem(this._field, this._arr.length + i, items[i]);
-                if (err) {
-                    return err;
-                }
+            const err = checkListItem(this._field, this._arr.length, item);
+            if (err) {
+                throw err;
             }
         }
-        for (const item of items) {
-            this._arr.push(listItemToLocal(this._field, item));
-        }
+        this._arr.push(listItemToLocal(this._field, item));
         return undefined;
     }
     clear() {
@@ -228,7 +206,15 @@ class ReflectListImpl {
 /**
  * Create a ReflectMap.
  */
-export function reflectMap(field, unsafeInput, check = true) {
+export function reflectMap(field, unsafeInput, 
+/**
+ * By default, field values are validated when setting them. For example,
+ * a value for an uint32 field must be a ECMAScript Number >= 0.
+ *
+ * When field values are trusted, performance can be improved by disabling
+ * checks.
+ */
+check = true) {
     return new ReflectMapImpl(field, unsafeInput, check);
 }
 class ReflectMapImpl {
@@ -244,11 +230,11 @@ class ReflectMapImpl {
         if (this.check) {
             const err = checkMapEntry(this._field, key, value);
             if (err) {
-                return err;
+                throw err;
             }
         }
         this.obj[mapKeyToLocal(key)] = mapValueToLocal(this._field, value);
-        return undefined;
+        return this;
     }
     delete(key) {
         const k = mapKeyToLocal(key);
@@ -303,27 +289,68 @@ class ReflectMapImpl {
         }
     }
 }
+function messageToLocal(field, value) {
+    if (!isReflectMessage(value)) {
+        return value;
+    }
+    if (isWrapper(value.message) &&
+        !field.oneof &&
+        field.fieldKind == "message") {
+        // Types from google/protobuf/wrappers.proto are unwrapped when used in
+        // a singular field that is not part of a oneof group.
+        return value.message.value;
+    }
+    if (value.desc.typeName == "google.protobuf.Struct" &&
+        field.parent.typeName != "google.protobuf.Value") {
+        // google.protobuf.Struct is represented with JsonObject when used in a
+        // field, except when used in google.protobuf.Value.
+        return wktStructToLocal(value.message);
+    }
+    return value.message;
+}
+function messageToReflect(field, value, check) {
+    if (value !== undefined) {
+        if (isWrapperDesc(field.message) &&
+            !field.oneof &&
+            field.fieldKind == "message") {
+            // Types from google/protobuf/wrappers.proto are unwrapped when used in
+            // a singular field that is not part of a oneof group.
+            value = {
+                $typeName: field.message.typeName,
+                value: longToReflect(field.message.fields[0], value),
+            };
+        }
+        else if (field.message.typeName == "google.protobuf.Struct" &&
+            field.parent.typeName != "google.protobuf.Value" &&
+            isObject(value)) {
+            // google.protobuf.Struct is represented with JsonObject when used in a
+            // field, except when used in google.protobuf.Value.
+            value = wktStructToReflect(value);
+        }
+    }
+    return new ReflectMessageImpl(field.message, value, check);
+}
 function listItemToLocal(field, value) {
-    if (isReflectMessage(value)) {
-        return value.message;
+    if (field.listKind == "message") {
+        return messageToLocal(field, value);
     }
     return longToLocal(field, value);
 }
 function listItemToReflect(field, value, check) {
     if (field.listKind == "message") {
-        return new ReflectMessageImpl(field.message, value, check);
+        return messageToReflect(field, value, check);
     }
     return longToReflect(field, value);
 }
 function mapValueToLocal(field, value) {
-    if (isReflectMessage(value)) {
-        return value.message;
+    if (field.mapKind == "message") {
+        return messageToLocal(field, value);
     }
     return longToLocal(field, value);
 }
 function mapValueToReflect(field, value, check) {
     if (field.mapKind == "message") {
-        return new ReflectMessageImpl(field.message, value, check);
+        return messageToReflect(field, value, check);
     }
     return value;
 }
@@ -427,3 +454,81 @@ function longToLocal(field, value) {
     }
     return value;
 }
+function wktStructToReflect(json) {
+    const struct = {
+        $typeName: "google.protobuf.Struct",
+        fields: {},
+    };
+    if (isObject(json)) {
+        for (const [k, v] of Object.entries(json)) {
+            struct.fields[k] = wktValueToReflect(v);
+        }
+    }
+    return struct;
+}
+function wktStructToLocal(val) {
+    const json = {};
+    for (const [k, v] of Object.entries(val.fields)) {
+        json[k] = wktValueToLocal(v);
+    }
+    return json;
+}
+function wktValueToLocal(val) {
+    switch (val.kind.case) {
+        case "structValue":
+            return wktStructToLocal(val.kind.value);
+        case "listValue":
+            return val.kind.value.values.map(wktValueToLocal);
+        case "nullValue":
+        case undefined:
+            return null;
+        default:
+            return val.kind.value;
+    }
+}
+function wktValueToReflect(json) {
+    const value = {
+        $typeName: "google.protobuf.Value",
+        kind: { case: undefined },
+    };
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- invalid input is unselected kind
+    switch (typeof json) {
+        case "number":
+            value.kind = { case: "numberValue", value: json };
+            break;
+        case "string":
+            value.kind = { case: "stringValue", value: json };
+            break;
+        case "boolean":
+            value.kind = { case: "boolValue", value: json };
+            break;
+        case "object":
+            if (json === null) {
+                const nullValue = 0;
+                value.kind = { case: "nullValue", value: nullValue };
+            }
+            else if (Array.isArray(json)) {
+                const listValue = {
+                    $typeName: "google.protobuf.ListValue",
+                    values: [],
+                };
+                if (Array.isArray(json)) {
+                    for (const e of json) {
+                        listValue.values.push(wktValueToReflect(e));
+                    }
+                }
+                value.kind = {
+                    case: "listValue",
+                    value: listValue,
+                };
+            }
+            else {
+                value.kind = {
+                    case: "structValue",
+                    value: wktStructToReflect(json),
+                };
+            }
+            break;
+    }
+    return value;
+}

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

@@ -6,7 +6,7 @@ export type ScalarValue<T = ScalarType, LongAsString extends boolean = false> =
 /**
  * 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;
+export declare function scalarEquals(type: ScalarType, a: ScalarValue | undefined, b: ScalarValue | undefined): boolean;
 /**
  * Returns the zero value for the given scalar type.
  */

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

@@ -40,19 +40,3 @@ export declare function unsafeSet(target: Record<string, unknown>, field: DescFi
  */
 export declare function unsafeClear(target: Record<string, any>, // eslint-disable-line @typescript-eslint/no-explicit-any -- `any` is the best choice for dynamic access
 field: DescField): void;
-/**
- * Add an item to a list field.
- *
- * @private
- */
-export declare function unsafeAddListItem(target: Record<string, unknown>, field: DescField & {
-    fieldKind: "list";
-}, value: unknown): void;
-/**
- * Set a map entry.
- *
- * @private
- */
-export declare function unsafeSetMapEntry(target: Record<string, unknown>, field: DescField & {
-    fieldKind: "map";
-}, key: string | number, value: unknown): void;