@bufbuild/protobuf 0.2.0 → 0.3.0

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

@@ -69,7 +69,7 @@ DoubleValue.fields = proto3.util.newFieldList(() => [
 ]);
 DoubleValue.fieldWrapper = {
     wrapField(value) {
-        return value instanceof DoubleValue ? value : new DoubleValue({ value });
+        return new DoubleValue({ value });
     },
     unwrapField(value) {
         return value.value;
@@ -129,7 +129,7 @@ FloatValue.fields = proto3.util.newFieldList(() => [
 ]);
 FloatValue.fieldWrapper = {
     wrapField(value) {
-        return value instanceof FloatValue ? value : new FloatValue({ value });
+        return new FloatValue({ value });
     },
     unwrapField(value) {
         return value.value;
@@ -189,7 +189,7 @@ Int64Value.fields = proto3.util.newFieldList(() => [
 ]);
 Int64Value.fieldWrapper = {
     wrapField(value) {
-        return value instanceof Int64Value ? value : new Int64Value({ value });
+        return new Int64Value({ value });
     },
     unwrapField(value) {
         return value.value;
@@ -249,7 +249,7 @@ UInt64Value.fields = proto3.util.newFieldList(() => [
 ]);
 UInt64Value.fieldWrapper = {
     wrapField(value) {
-        return value instanceof UInt64Value ? value : new UInt64Value({ value });
+        return new UInt64Value({ value });
     },
     unwrapField(value) {
         return value.value;
@@ -309,7 +309,7 @@ Int32Value.fields = proto3.util.newFieldList(() => [
 ]);
 Int32Value.fieldWrapper = {
     wrapField(value) {
-        return value instanceof Int32Value ? value : new Int32Value({ value });
+        return new Int32Value({ value });
     },
     unwrapField(value) {
         return value.value;
@@ -369,7 +369,7 @@ UInt32Value.fields = proto3.util.newFieldList(() => [
 ]);
 UInt32Value.fieldWrapper = {
     wrapField(value) {
-        return value instanceof UInt32Value ? value : new UInt32Value({ value });
+        return new UInt32Value({ value });
     },
     unwrapField(value) {
         return value.value;
@@ -429,7 +429,7 @@ BoolValue.fields = proto3.util.newFieldList(() => [
 ]);
 BoolValue.fieldWrapper = {
     wrapField(value) {
-        return value instanceof BoolValue ? value : new BoolValue({ value });
+        return new BoolValue({ value });
     },
     unwrapField(value) {
         return value.value;
@@ -489,7 +489,7 @@ StringValue.fields = proto3.util.newFieldList(() => [
 ]);
 StringValue.fieldWrapper = {
     wrapField(value) {
-        return value instanceof StringValue ? value : new StringValue({ value });
+        return new StringValue({ value });
     },
     unwrapField(value) {
         return value.value;
@@ -549,7 +549,7 @@ BytesValue.fields = proto3.util.newFieldList(() => [
 ]);
 BytesValue.fieldWrapper = {
     wrapField(value) {
-        return value instanceof BytesValue ? value : new BytesValue({ value });
+        return new BytesValue({ value });
     },
     unwrapField(value) {
         return value.value;

package/dist/esm/message.js

@@ -29,7 +29,6 @@ export class Message {
      * Create a deep copy.
      */
     clone() {
-        // return this.getType().runtime.util.clone(this);
         return this.getType().runtime.util.clone(this);
     }
     /**
@@ -85,6 +84,21 @@ export class Message {
         const value = this.toJson(options);
         return JSON.stringify(value, null, (_a = options === null || options === void 0 ? void 0 : options.prettySpaces) !== null && _a !== void 0 ? _a : 0);
     }
+    /**
+     * Override for serializaton behavior.  This will be invoked when calling
+     * JSON.stringify on this message (i.e. JSON.stringify(msg)).
+     *
+     * Note that this will not serialize google.protobuf.Any with a packed
+     * message because the protobuf JSON format specifies that it needs to be
+     * unpacked, and this is only possible with a type registry to look up the
+     * message type.  As a result, attempting to serialize a message with this
+     * type will throw an Error.
+     */
+    toJSON() {
+        return this.toJson({
+            emitDefaultValues: true,
+        });
+    }
     /**
      * Retrieve the MessageType of this message - a singleton that represents
      * the protobuf message declaration and provides metadata for reflection-

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

@@ -12,8 +12,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 import { BinaryReader, BinaryWriter, WireType, } from "../binary-encoding.js";
+import { Message } from "../message.js";
 import { ScalarType } from "../field.js";
-import { unwrapField, wrapField } from "./field-wrapper.js";
+import { wrapField } from "./field-wrapper.js";
 import { scalarDefaultValue, scalarTypeInfo } from "./scalars.js";
 import { assert } from "./assert.js";
 /* eslint-disable @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unnecessary-condition, no-case-declarations, prefer-const */
@@ -111,11 +112,16 @@ export function makeBinaryFormatCommon() {
                             target[localName].push(messageType.fromBinary(reader.bytes(), options));
                         }
                         else {
-                            if (target[localName] instanceof messageType) {
+                            if (target[localName] instanceof Message) {
                                 target[localName].fromBinary(reader.bytes(), options);
                             }
                             else {
-                                target[localName] = unwrapField(messageType, messageType.fromBinary(reader.bytes(), options));
+                                target[localName] = messageType.fromBinary(reader.bytes(), options);
+                                if (messageType.fieldWrapper &&
+                                    !field.oneof &&
+                                    !field.repeated) {
+                                    target[localName] = messageType.fieldWrapper.unwrapField(target[localName]);
+                                }
                             }
                         }
                         break;

package/dist/esm/private/field-wrapper.js

@@ -11,28 +11,21 @@
 // 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 { Message } from "../message.js";
 import { ScalarType } from "../field.js";
 /**
- * Wrap field values whose message type has a wrapper.
+ * Wrap a primitive message field value in its corresponding wrapper
+ * message. This function is idempotent.
  */
 export function wrapField(type, value) {
-    if (value instanceof type) {
+    if (value instanceof Message || !type.fieldWrapper) {
         return value;
     }
-    if (type.fieldWrapper) {
-        return type.fieldWrapper.wrapField(value);
-    }
-    throw new Error(`cannot unwrap field value, ${type.typeName} does not define a field wrapper`);
-}
-/**
- * Unwrap field values whose message type has a wrapper.
- */
-export function unwrapField(type, value) {
-    return type.fieldWrapper ? type.fieldWrapper.unwrapField(value) : value;
+    return type.fieldWrapper.wrapField(value);
 }
 /**
  * If the given field uses one of the well-known wrapper types, return
- * the base type it wraps.
+ * the primitive type it wraps.
  */
 export function getUnwrappedFieldType(field) {
     if (field.fieldKind !== "message") {

package/dist/esm/private/json-format-common.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 { unwrapField, wrapField } from "./field-wrapper.js";
+import { Message } from "../message.js";
 import { ScalarType } from "../field.js";
 import { assert, assertFloat32, assertInt32, assertUInt32 } from "./assert.js";
 import { protoInt64 } from "../proto-int64.js";
@@ -171,10 +171,15 @@ export function makeJsonFormatCommon(makeWriteField) {
                                 }
                                 continue;
                             }
-                            const targetMessage = target[localName] === undefined
-                                ? new messageType()
-                                : wrapField(messageType, target[localName]);
-                            target[localName] = unwrapField(messageType, targetMessage.fromJson(jsonValue, options));
+                            if (target[localName] instanceof Message) {
+                                target[localName].fromJson(jsonValue, options);
+                            }
+                            else {
+                                target[localName] = messageType.fromJson(jsonValue, options);
+                                if (messageType.fieldWrapper && !field.oneof) {
+                                    target[localName] = messageType.fieldWrapper.unwrapField(target[localName]);
+                                }
+                            }
                             break;
                         case "enum":
                             const enumValue = readEnum(field.T, jsonValue, options.ignoreUnknownFields);

package/dist/esm/private/reify-wkt.js

@@ -0,0 +1,166 @@
+// Copyright 2021-2022 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 { ScalarType } from "../field.js";
+/**
+ * Reifies a given DescMessage into a more concrete object representing its
+ * respective well-known type.  The returned object will contain properties
+ * representing the WKT's defined fields.
+ *
+ * Useful during code generation when immediate access to a particular field
+ * is needed without having to search the object's typename and DescField list.
+ *
+ * Returns undefined if the WKT cannot be completely constructed via the
+ * DescMessage.
+ */
+export function reifyWkt(message) {
+    switch (message.typeName) {
+        case "google.protobuf.Any": {
+            const typeUrl = message.fields.find((f) => f.number == 1 &&
+                f.fieldKind == "scalar" &&
+                f.scalar === ScalarType.STRING);
+            const value = message.fields.find((f) => f.number == 2 &&
+                f.fieldKind == "scalar" &&
+                f.scalar === ScalarType.BYTES);
+            if (typeUrl && value) {
+                return {
+                    typeName: message.typeName,
+                    typeUrl,
+                    value,
+                };
+            }
+            break;
+        }
+        case "google.protobuf.Timestamp": {
+            const seconds = message.fields.find((f) => f.number == 1 &&
+                f.fieldKind == "scalar" &&
+                f.scalar === ScalarType.INT64);
+            const nanos = message.fields.find((f) => f.number == 2 &&
+                f.fieldKind == "scalar" &&
+                f.scalar === ScalarType.INT32);
+            if (seconds && nanos) {
+                return {
+                    typeName: message.typeName,
+                    seconds,
+                    nanos,
+                };
+            }
+            break;
+        }
+        case "google.protobuf.Duration": {
+            const seconds = message.fields.find((f) => f.number == 1 &&
+                f.fieldKind == "scalar" &&
+                f.scalar === ScalarType.INT64);
+            const nanos = message.fields.find((f) => f.number == 2 &&
+                f.fieldKind == "scalar" &&
+                f.scalar === ScalarType.INT32);
+            if (seconds && nanos) {
+                return {
+                    typeName: message.typeName,
+                    seconds,
+                    nanos,
+                };
+            }
+            break;
+        }
+        case "google.protobuf.Struct": {
+            const fields = message.fields.find((f) => f.number == 1 && !f.repeated);
+            if ((fields === null || fields === void 0 ? void 0 : fields.fieldKind) !== "map" ||
+                fields.mapValue.kind !== "message" ||
+                fields.mapValue.message.typeName !== "google.protobuf.Value") {
+                break;
+            }
+            return { typeName: message.typeName, fields };
+        }
+        case "google.protobuf.Value": {
+            const kind = message.oneofs.find((o) => o.name === "kind");
+            const nullValue = message.fields.find((f) => f.number == 1 && f.oneof === kind);
+            if ((nullValue === null || nullValue === void 0 ? void 0 : nullValue.fieldKind) !== "enum" ||
+                nullValue.enum.typeName !== "google.protobuf.NullValue") {
+                return undefined;
+            }
+            const numberValue = message.fields.find((f) => f.number == 2 &&
+                f.fieldKind == "scalar" &&
+                f.scalar === ScalarType.DOUBLE &&
+                f.oneof === kind);
+            const stringValue = message.fields.find((f) => f.number == 3 &&
+                f.fieldKind == "scalar" &&
+                f.scalar === ScalarType.STRING &&
+                f.oneof === kind);
+            const boolValue = message.fields.find((f) => f.number == 4 &&
+                f.fieldKind == "scalar" &&
+                f.scalar === ScalarType.BOOL &&
+                f.oneof === kind);
+            const structValue = message.fields.find((f) => f.number == 5 && f.oneof === kind);
+            if ((structValue === null || structValue === void 0 ? void 0 : structValue.fieldKind) !== "message" ||
+                structValue.message.typeName !== "google.protobuf.Struct") {
+                return undefined;
+            }
+            const listValue = message.fields.find((f) => f.number == 6 && f.oneof === kind);
+            if ((listValue === null || listValue === void 0 ? void 0 : listValue.fieldKind) !== "message" ||
+                listValue.message.typeName !== "google.protobuf.ListValue") {
+                return undefined;
+            }
+            if (kind && numberValue && stringValue && boolValue) {
+                return {
+                    typeName: message.typeName,
+                    kind,
+                    nullValue,
+                    numberValue,
+                    stringValue,
+                    boolValue,
+                    structValue,
+                    listValue,
+                };
+            }
+            break;
+        }
+        case "google.protobuf.ListValue": {
+            const values = message.fields.find((f) => f.number == 1 && f.repeated);
+            if ((values === null || values === void 0 ? void 0 : values.fieldKind) != "message" ||
+                values.message.typeName !== "google.protobuf.Value") {
+                break;
+            }
+            return { typeName: message.typeName, values };
+        }
+        case "google.protobuf.FieldMask": {
+            const paths = message.fields.find((f) => f.number == 1 &&
+                f.fieldKind == "scalar" &&
+                f.scalar === ScalarType.STRING &&
+                f.repeated);
+            if (paths) {
+                return { typeName: message.typeName, paths };
+            }
+            break;
+        }
+        case "google.protobuf.DoubleValue":
+        case "google.protobuf.FloatValue":
+        case "google.protobuf.Int64Value":
+        case "google.protobuf.UInt64Value":
+        case "google.protobuf.Int32Value":
+        case "google.protobuf.UInt32Value":
+        case "google.protobuf.BoolValue":
+        case "google.protobuf.StringValue":
+        case "google.protobuf.BytesValue": {
+            const value = message.fields.find((f) => f.number == 1 && f.name == "value");
+            if (!value) {
+                break;
+            }
+            if (value.fieldKind !== "scalar") {
+                break;
+            }
+            return { typeName: message.typeName, value };
+        }
+    }
+    return undefined;
+}

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

@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 import { setEnumType } from "./enum.js";
+import { Message, } from "../message.js";
 import { ScalarType } from "../field.js";
 import { scalarEquals } from "./scalars.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 */
@@ -136,10 +137,7 @@ export function makeUtilCommon() {
                         }
                         throw new Error(`oneof cannot contain ${s.kind}`);
                     case "map":
-                        const keys = Object.keys(va);
-                        if (keys.some((k) => vb[k] === undefined)) {
-                            return false;
-                        }
+                        const keys = Object.keys(va).concat(Object.keys(vb));
                         switch (m.V.kind) {
                             case "message":
                                 const messageType = m.V.T;
@@ -188,21 +186,13 @@ function cloneSingularField(field, value) {
     if (value === undefined) {
         return value;
     }
-    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- unmatched "map" is unsupported
-    switch (field.kind) {
-        case "enum":
-            return value;
-        case "scalar":
-            if (field.T === ScalarType.BYTES) {
-                const c = new Uint8Array(value.byteLength);
-                c.set(value);
-                return c;
-            }
-            return value;
-        case "message":
-            if (field.T.fieldWrapper) {
-                return field.T.fieldWrapper.unwrapField(field.T.fieldWrapper.wrapField(value).clone());
-            }
-            return value.clone();
+    if (value instanceof Message) {
+        return value.clone();
+    }
+    if (value instanceof Uint8Array) {
+        const c = new Uint8Array(value.byteLength);
+        c.set(value);
+        return c;
     }
+    return value;
 }

package/dist/types/binary-format.d.ts

@@ -17,7 +17,7 @@ export interface BinaryFormat {
     /**
      * Parse a message from binary data, merging fields.
      */
-    readMessage<T extends Message>(message: T, reader: IBinaryReader, length: number, options: BinaryReadOptions): void;
+    readMessage(message: Message, reader: IBinaryReader, length: number, options: BinaryReadOptions): void;
     /**
      * Serialize a message to binary data.
      */

package/dist/types/codegen-info.d.ts

@@ -1,6 +1,7 @@
 import { localName } from "./private/names.js";
 import { getUnwrappedFieldType } from "./private/field-wrapper.js";
 import { scalarDefaultValue } from "./private/scalars.js";
+import { reifyWkt } from "./private/reify-wkt.js";
 interface CodegenInfo {
     readonly packageName: string;
     readonly localName: typeof localName;
@@ -8,8 +9,9 @@ interface CodegenInfo {
     readonly getUnwrappedFieldType: typeof getUnwrappedFieldType;
     readonly wktSourceFiles: readonly string[];
     readonly scalarDefaultValue: typeof scalarDefaultValue;
+    readonly reifyWkt: typeof reifyWkt;
 }
-declare type RuntimeSymbolName = "proto2" | "proto3" | "Message" | "PartialMessage" | "PlainMessage" | "FieldList" | "MessageType" | "BinaryReadOptions" | "BinaryWriteOptions" | "JsonReadOptions" | "JsonWriteOptions" | "JsonValue" | "JsonObject" | "protoInt64" | "ScalarType" | "MethodKind" | "MethodIdempotency";
+declare type RuntimeSymbolName = "proto2" | "proto3" | "Message" | "PartialMessage" | "PlainMessage" | "FieldList" | "MessageType" | "BinaryReadOptions" | "BinaryWriteOptions" | "JsonReadOptions" | "JsonWriteOptions" | "JsonValue" | "JsonObject" | "protoInt64" | "ScalarType" | "MethodKind" | "MethodIdempotency" | "IMessageTypeRegistry";
 declare type RuntimeSymbolInfo = {
     typeOnly: boolean;
     publicImportPath: string;

package/dist/types/google/protobuf/any_pb.d.ts

@@ -1,6 +1,7 @@
 import type { PartialMessage, PlainMessage } from "../../message.js";
 import { Message } from "../../message.js";
 import type { JsonReadOptions, JsonValue, JsonWriteOptions } from "../../json-format.js";
+import type { IMessageTypeRegistry } from "../../type-registry.js";
 import type { MessageType } from "../../message-type.js";
 import type { FieldList } from "../../field-list.js";
 import type { BinaryReadOptions } from "../../binary-format.js";
@@ -136,7 +137,8 @@ export declare class Any extends Message<Any> {
     fromJson(json: JsonValue, options?: Partial<JsonReadOptions>): this;
     packFrom(message: Message): void;
     unpackTo(target: Message): boolean;
-    is(type: MessageType): boolean;
+    unpack(registry: IMessageTypeRegistry): Message | undefined;
+    is(type: MessageType | string): boolean;
     private typeNameToUrl;
     private typeUrlToName;
     static readonly runtime: import("../../private/proto-runtime.js").ProtoRuntime;

package/dist/types/google/protobuf/wrappers_pb.d.ts

@@ -24,7 +24,7 @@ export declare class DoubleValue extends Message<DoubleValue> {
     static readonly typeName = "google.protobuf.DoubleValue";
     static readonly fields: FieldList;
     static readonly fieldWrapper: {
-        wrapField(value: number | DoubleValue): DoubleValue;
+        wrapField(value: number): DoubleValue;
         unwrapField(value: DoubleValue): number;
     };
     static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DoubleValue;
@@ -53,7 +53,7 @@ export declare class FloatValue extends Message<FloatValue> {
     static readonly typeName = "google.protobuf.FloatValue";
     static readonly fields: FieldList;
     static readonly fieldWrapper: {
-        wrapField(value: number | FloatValue): FloatValue;
+        wrapField(value: number): FloatValue;
         unwrapField(value: FloatValue): number;
     };
     static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FloatValue;
@@ -82,7 +82,7 @@ export declare class Int64Value extends Message<Int64Value> {
     static readonly typeName = "google.protobuf.Int64Value";
     static readonly fields: FieldList;
     static readonly fieldWrapper: {
-        wrapField(value: bigint | Int64Value): Int64Value;
+        wrapField(value: bigint): Int64Value;
         unwrapField(value: Int64Value): bigint;
     };
     static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Int64Value;
@@ -111,7 +111,7 @@ export declare class UInt64Value extends Message<UInt64Value> {
     static readonly typeName = "google.protobuf.UInt64Value";
     static readonly fields: FieldList;
     static readonly fieldWrapper: {
-        wrapField(value: bigint | UInt64Value): UInt64Value;
+        wrapField(value: bigint): UInt64Value;
         unwrapField(value: UInt64Value): bigint;
     };
     static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UInt64Value;
@@ -140,7 +140,7 @@ export declare class Int32Value extends Message<Int32Value> {
     static readonly typeName = "google.protobuf.Int32Value";
     static readonly fields: FieldList;
     static readonly fieldWrapper: {
-        wrapField(value: number | Int32Value): Int32Value;
+        wrapField(value: number): Int32Value;
         unwrapField(value: Int32Value): number;
     };
     static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Int32Value;
@@ -169,7 +169,7 @@ export declare class UInt32Value extends Message<UInt32Value> {
     static readonly typeName = "google.protobuf.UInt32Value";
     static readonly fields: FieldList;
     static readonly fieldWrapper: {
-        wrapField(value: number | UInt32Value): UInt32Value;
+        wrapField(value: number): UInt32Value;
         unwrapField(value: UInt32Value): number;
     };
     static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UInt32Value;
@@ -198,7 +198,7 @@ export declare class BoolValue extends Message<BoolValue> {
     static readonly typeName = "google.protobuf.BoolValue";
     static readonly fields: FieldList;
     static readonly fieldWrapper: {
-        wrapField(value: boolean | BoolValue): BoolValue;
+        wrapField(value: boolean): BoolValue;
         unwrapField(value: BoolValue): boolean;
     };
     static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): BoolValue;
@@ -227,7 +227,7 @@ export declare class StringValue extends Message<StringValue> {
     static readonly typeName = "google.protobuf.StringValue";
     static readonly fields: FieldList;
     static readonly fieldWrapper: {
-        wrapField(value: string | StringValue): StringValue;
+        wrapField(value: string): StringValue;
         unwrapField(value: StringValue): string;
     };
     static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StringValue;
@@ -256,7 +256,7 @@ export declare class BytesValue extends Message<BytesValue> {
     static readonly typeName = "google.protobuf.BytesValue";
     static readonly fields: FieldList;
     static readonly fieldWrapper: {
-        wrapField(value: Uint8Array | BytesValue): BytesValue;
+        wrapField(value: Uint8Array): BytesValue;
         unwrapField(value: BytesValue): Uint8Array;
     };
     static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): BytesValue;

package/dist/types/message.d.ts

@@ -56,6 +56,17 @@ export declare class Message<T extends Message<T> = AnyMessage> {
      * Serialize the message to a JSON string.
      */
     toJsonString(options?: Partial<JsonWriteStringOptions>): string;
+    /**
+     * Override for serializaton behavior.  This will be invoked when calling
+     * JSON.stringify on this message (i.e. JSON.stringify(msg)).
+     *
+     * Note that this will not serialize google.protobuf.Any with a packed
+     * message because the protobuf JSON format specifies that it needs to be
+     * unpacked, and this is only possible with a type registry to look up the
+     * message type.  As a result, attempting to serialize a message with this
+     * type will throw an Error.
+     */
+    toJSON(): JsonValue;
     /**
      * Retrieve the MessageType of this message - a singleton that represents
      * the protobuf message declaration and provides metadata for reflection-
@@ -67,7 +78,7 @@ export declare class Message<T extends Message<T> = AnyMessage> {
  * PlainMessage<T> strips all methods from a message, leaving only fields
  * and oneof groups.
  */
-export declare type PlainMessage<T extends Message> = {
+export declare type PlainMessage<T extends Message<T>> = {
     [P in keyof T as T[P] extends Function ? never : P]: T[P];
 };
 /**
@@ -78,10 +89,10 @@ export declare type PlainMessage<T extends Message> = {
  * PartialMessage is similar to the built-in type Partial<T>, but recursive,
  * and respects `oneof` groups.
  */
-export declare type PartialMessage<T extends Message> = {
+export declare type PartialMessage<T extends Message<T>> = {
     [P in keyof T as T[P] extends Function ? never : P]?: PartialField<T[P]>;
 };
-declare type PartialField<F> = F extends (Date | Uint8Array | bigint | boolean | string | number) ? F : F extends Array<infer U> ? Array<PartialField<U>> : F extends ReadonlyArray<infer U> ? ReadonlyArray<PartialField<U>> : F extends Message ? PartialMessage<F> : F extends OneofSelectedMessage<infer C, infer V> ? {
+declare type PartialField<F> = F extends (Date | Uint8Array | bigint | boolean | string | number) ? F : F extends Array<infer U> ? Array<PartialField<U>> : F extends ReadonlyArray<infer U> ? ReadonlyArray<PartialField<U>> : F extends Message<infer U> ? PartialMessage<U> : F extends OneofSelectedMessage<infer C, infer V> ? {
     case: C;
     value: PartialMessage<V>;
 } : F extends {
@@ -92,7 +103,7 @@ declare type PartialField<F> = F extends (Date | Uint8Array | bigint | boolean |
 } ? {
     [key: string | number]: PartialMessage<U>;
 } : F;
-declare type OneofSelectedMessage<K extends string, M extends Message> = {
+declare type OneofSelectedMessage<K extends string, M extends Message<M>> = {
     case: K;
     value: M;
 };

package/dist/types/private/field-wrapper.d.ts

@@ -1,4 +1,4 @@
-import type { Message } from "../message.js";
+import { Message } from "../message.js";
 import type { MessageType } from "../message-type.js";
 import type { DescField } from "../descriptor-set.js";
 import { ScalarType } from "../field.js";
@@ -6,7 +6,7 @@ import { ScalarType } from "../field.js";
  * A field wrapper unwraps a message to a primitive value that is more
  * ergonomic for use as a message field.
  *
- * Note that this feature exists for google/protobuf/{wrappers,struct}.proto
+ * Note that this feature exists for google/protobuf/wrappers.proto
  * and cannot be used to arbitrarily modify types in generated code.
  */
 export interface FieldWrapper<T extends Message<T> = any, U = any> {
@@ -14,15 +14,12 @@ export interface FieldWrapper<T extends Message<T> = any, U = any> {
     unwrapField(value: T): U;
 }
 /**
- * Wrap field values whose message type has a wrapper.
+ * Wrap a primitive message field value in its corresponding wrapper
+ * message. This function is idempotent.
  */
 export declare function wrapField<T extends Message<T>>(type: MessageType<T>, value: any): T;
-/**
- * Unwrap field values whose message type has a wrapper.
- */
-export declare function unwrapField<T extends Message<T>>(type: MessageType<T>, value: T): any;
 /**
  * If the given field uses one of the well-known wrapper types, return
- * the base type it wraps.
+ * the primitive type it wraps.
  */
 export declare function getUnwrappedFieldType(field: DescField): ScalarType | undefined;