@bufbuild/protoc-gen-es 1.8.0 → 2.0.0-alpha.1

package/dist/cjs/src/util.js

@@ -13,31 +13,46 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFieldZeroValueExpression = exports.getFieldDefaultValueExpression = exports.getFieldTypeInfo = void 0;
-const protobuf_1 = require("@bufbuild/protobuf");
-const ecmascript_1 = require("@bufbuild/protoplugin/ecmascript");
+exports.arrayLiteral = exports.functionCall = exports.getFieldTypeInfo = exports.fieldUsesPrototype = void 0;
+const reflect_1 = require("@bufbuild/protobuf/reflect");
+const wkt_1 = require("@bufbuild/protobuf/wkt");
+/**
+ * Tells whether a field uses the prototype chain for field presence.
+ * Behavior must match with the counterpart in @bufbuild/protobuf.
+ */
+function fieldUsesPrototype(field) {
+    if (field.parent.file.edition != wkt_1.Edition.EDITION_PROTO2) {
+        return false;
+    }
+    if (field.fieldKind != "scalar" && field.fieldKind != "enum") {
+        return false;
+    }
+    if (field.oneof) {
+        return false;
+    }
+    // proto2 singular scalar and enum fields use an initial value on the prototype chain
+    return true;
+}
+exports.fieldUsesPrototype = fieldUsesPrototype;
 function getFieldTypeInfo(field) {
     const typing = [];
     let typingInferrableFromZeroValue;
     let optional = false;
     switch (field.fieldKind) {
         case "scalar":
-            typing.push(scalarTypeScriptType(field.scalar, field.longType));
-            optional =
-                field.optional ||
-                    field.proto.label === protobuf_1.FieldDescriptorProto_Label.REQUIRED;
+            typing.push((0, reflect_1.scalarTypeScriptType)(field.scalar, field.longType));
+            optional = field.optional;
             typingInferrableFromZeroValue = true;
             break;
         case "message": {
-            const baseType = protobuf_1.codegenInfo.getUnwrappedFieldType(field);
-            if (baseType !== undefined) {
-                typing.push(scalarTypeScriptType(baseType, protobuf_1.LongType.BIGINT));
+            if (!field.oneof && (0, wkt_1.isWrapperDesc)(field.message)) {
+                const baseType = field.message.fields[0].scalar;
+                typing.push((0, reflect_1.scalarTypeScriptType)(baseType, reflect_1.LongType.BIGINT));
             }
             else {
                 typing.push({
-                    kind: "es_ref_message",
-                    type: field.message,
-                    typeOnly: true,
+                    kind: "es_shape_ref",
+                    desc: field.message,
                 });
             }
             optional = true;
@@ -46,23 +61,42 @@ function getFieldTypeInfo(field) {
         }
         case "enum":
             typing.push({
-                kind: "es_ref_enum",
-                type: field.enum,
-                typeOnly: true,
+                kind: "es_shape_ref",
+                desc: field.enum,
             });
-            optional =
-                field.optional ||
-                    field.proto.label === protobuf_1.FieldDescriptorProto_Label.REQUIRED;
+            optional = field.optional;
             typingInferrableFromZeroValue = true;
             break;
+        case "list":
+            optional = false;
+            typingInferrableFromZeroValue = false;
+            switch (field.listKind) {
+                case "enum":
+                    typing.push({
+                        kind: "es_shape_ref",
+                        desc: field.enum,
+                    }, "[]");
+                    break;
+                case "scalar":
+                    typing.push((0, reflect_1.scalarTypeScriptType)(field.scalar, field.longType), "[]");
+                    break;
+                case "message": {
+                    typing.push({
+                        kind: "es_shape_ref",
+                        desc: field.message,
+                    }, "[]");
+                    break;
+                }
+            }
+            break;
         case "map": {
             let keyType;
             switch (field.mapKey) {
-                case protobuf_1.ScalarType.INT32:
-                case protobuf_1.ScalarType.FIXED32:
-                case protobuf_1.ScalarType.UINT32:
-                case protobuf_1.ScalarType.SFIXED32:
-                case protobuf_1.ScalarType.SINT32:
+                case reflect_1.ScalarType.INT32:
+                case reflect_1.ScalarType.FIXED32:
+                case reflect_1.ScalarType.UINT32:
+                case reflect_1.ScalarType.SFIXED32:
+                case reflect_1.ScalarType.SINT32:
                     keyType = "number";
                     break;
                 default:
@@ -70,22 +104,20 @@ function getFieldTypeInfo(field) {
                     break;
             }
             let valueType;
-            switch (field.mapValue.kind) {
+            switch (field.mapKind) {
                 case "scalar":
-                    valueType = scalarTypeScriptType(field.mapValue.scalar, protobuf_1.LongType.BIGINT);
+                    valueType = (0, reflect_1.scalarTypeScriptType)(field.scalar, reflect_1.LongType.BIGINT);
                     break;
                 case "message":
                     valueType = {
-                        kind: "es_ref_message",
-                        type: field.mapValue.message,
-                        typeOnly: true,
+                        kind: "es_shape_ref",
+                        desc: field.message,
                     };
                     break;
                 case "enum":
                     valueType = {
-                        kind: "es_ref_enum",
-                        type: field.mapValue.enum,
-                        typeOnly: true,
+                        kind: "es_shape_ref",
+                        desc: field.enum,
                     };
                     break;
             }
@@ -95,166 +127,28 @@ function getFieldTypeInfo(field) {
             break;
         }
     }
-    if (field.repeated) {
-        typing.push("[]");
-        optional = false;
-        typingInferrableFromZeroValue = false;
-    }
     return { typing, optional, typingInferrableFromZeroValue };
 }
 exports.getFieldTypeInfo = getFieldTypeInfo;
-/**
- * Return a printable expression for the default value of a field.
- * Only applicable for singular scalar and enum fields.
- */
-function getFieldDefaultValueExpression(field, enumAs = "enum_value_as_is") {
-    if (field.repeated) {
-        return undefined;
-    }
-    if (field.fieldKind !== "enum" && field.fieldKind !== "scalar") {
-        return undefined;
-    }
-    const defaultValue = field.getDefaultValue();
-    if (defaultValue === undefined) {
-        return undefined;
-    }
-    switch (field.fieldKind) {
-        case "enum": {
-            const enumValue = field.enum.values.find((value) => value.number === defaultValue);
-            if (enumValue === undefined) {
-                throw new Error(`invalid enum default value: ${String(defaultValue)} for ${enumValue}`);
-            }
-            return literalEnumValue(enumValue, enumAs);
-        }
-        case "scalar":
-            return literalScalarValue(defaultValue, field);
-    }
-}
-exports.getFieldDefaultValueExpression = getFieldDefaultValueExpression;
-/**
- * Return a printable expression for the zero value of a field.
- *
- * Returns either:
- * - empty array literal for repeated fields
- * - empty object literal for maps
- * - undefined for message fields
- * - an enums first value
- * - scalar zero value
- */
-function getFieldZeroValueExpression(field, enumAs = "enum_value_as_is") {
-    if (field.repeated) {
-        return "[]";
-    }
-    switch (field.fieldKind) {
-        case "message":
-            return undefined;
-        case "map":
-            return "{}";
-        case "enum": {
-            // In proto3, the first enum value must be zero.
-            // In proto2, protobuf-go returns the first value as the default.
-            if (field.enum.values.length < 1) {
-                throw new Error("invalid enum: missing at least one value");
-            }
-            const zeroValue = field.enum.values[0];
-            return literalEnumValue(zeroValue, enumAs);
-        }
-        case "scalar": {
-            const defaultValue = protobuf_1.codegenInfo.scalarZeroValue(field.scalar, field.longType);
-            return literalScalarValue(defaultValue, field);
-        }
+function functionCall(fn, args, typeParams) {
+    let tp = [];
+    if (typeParams !== undefined && typeParams.length > 0) {
+        tp = ["<", commaSeparate(typeParams), ">"];
     }
+    return [fn, ...tp, "(", commaSeparate(args), ")"];
 }
-exports.getFieldZeroValueExpression = getFieldZeroValueExpression;
-function literalScalarValue(value, field) {
-    switch (field.scalar) {
-        case protobuf_1.ScalarType.DOUBLE:
-        case protobuf_1.ScalarType.FLOAT:
-        case protobuf_1.ScalarType.INT32:
-        case protobuf_1.ScalarType.FIXED32:
-        case protobuf_1.ScalarType.UINT32:
-        case protobuf_1.ScalarType.SFIXED32:
-        case protobuf_1.ScalarType.SINT32:
-            if (typeof value != "number") {
-                throw new Error(`Unexpected value for ${protobuf_1.ScalarType[field.scalar]} ${field.toString()}: ${String(value)}`);
-            }
-            return value;
-        case protobuf_1.ScalarType.BOOL:
-            if (typeof value != "boolean") {
-                throw new Error(`Unexpected value for ${protobuf_1.ScalarType[field.scalar]} ${field.toString()}: ${String(value)}`);
-            }
-            return value;
-        case protobuf_1.ScalarType.STRING:
-            if (typeof value != "string") {
-                throw new Error(`Unexpected value for ${protobuf_1.ScalarType[field.scalar]} ${field.toString()}: ${String(value)}`);
-            }
-            return { kind: "es_string", value };
-        case protobuf_1.ScalarType.BYTES:
-            if (!(value instanceof Uint8Array)) {
-                throw new Error(`Unexpected value for ${protobuf_1.ScalarType[field.scalar]} ${field.toString()}: ${String(value)}`);
-            }
-            return value;
-        case protobuf_1.ScalarType.INT64:
-        case protobuf_1.ScalarType.SINT64:
-        case protobuf_1.ScalarType.SFIXED64:
-        case protobuf_1.ScalarType.UINT64:
-        case protobuf_1.ScalarType.FIXED64:
-            if (typeof value != "bigint" && typeof value != "string") {
-                throw new Error(`Unexpected value for ${protobuf_1.ScalarType[field.scalar]} ${field.toString()}: ${String(value)}`);
-            }
-            return {
-                kind: "es_proto_int64",
-                type: field.scalar,
-                longType: field.longType,
-                value,
-            };
-    }
-}
-function literalEnumValue(value, enumAs) {
-    switch (enumAs) {
-        case "enum_value_as_is":
-            return [
-                { kind: "es_ref_enum", type: value.parent, typeOnly: false },
-                ".",
-                (0, ecmascript_1.localName)(value),
-            ];
-        case "enum_value_as_integer":
-            return [
-                value.number,
-                " /* ",
-                value.parent.typeName,
-                ".",
-                value.name,
-                " */",
-            ];
-        case "enum_value_as_cast_integer":
-            return [
-                value.number,
-                " as ",
-                { kind: "es_ref_enum", type: value.parent, typeOnly: true },
-                ".",
-                (0, ecmascript_1.localName)(value),
-            ];
-    }
+exports.functionCall = functionCall;
+function arrayLiteral(elements) {
+    return ["[", commaSeparate(elements), "]"];
 }
-function scalarTypeScriptType(type, longType) {
-    switch (type) {
-        case protobuf_1.ScalarType.STRING:
-            return "string";
-        case protobuf_1.ScalarType.BOOL:
-            return "boolean";
-        case protobuf_1.ScalarType.UINT64:
-        case protobuf_1.ScalarType.SFIXED64:
-        case protobuf_1.ScalarType.FIXED64:
-        case protobuf_1.ScalarType.SINT64:
-        case protobuf_1.ScalarType.INT64:
-            if (longType === protobuf_1.LongType.STRING) {
-                return "string";
-            }
-            return "bigint";
-        case protobuf_1.ScalarType.BYTES:
-            return "Uint8Array";
-        default:
-            return "number";
+exports.arrayLiteral = arrayLiteral;
+function commaSeparate(elements) {
+    const r = [];
+    for (let i = 0; i < elements.length; i++) {
+        r.push(elements[i]);
+        if (i < elements.length - 1) {
+            r.push(", ");
+        }
     }
+    return r;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bufbuild/protoc-gen-es",
-  "version": "1.8.0",
+  "version": "2.0.0-alpha.1",
   "description": "Protocol Buffers code generator for ECMAScript",
   "license": "Apache-2.0",
   "repository": {
@@ -16,15 +16,15 @@
   },
   "scripts": {
     "clean": "rm -rf ./dist/cjs/*",
-    "build": "../../node_modules/typescript/bin/tsc --project tsconfig.json --module commonjs --outDir ./dist/cjs"
+    "build": "../../node_modules/typescript/bin/tsc --project tsconfig.json --outDir ./dist/cjs"
   },
   "preferUnplugged": true,
   "dependencies": {
-    "@bufbuild/protobuf": "^1.8.0",
-    "@bufbuild/protoplugin": "1.8.0"
+    "@bufbuild/protobuf": "^2.0.0-alpha.1",
+    "@bufbuild/protoplugin": "2.0.0-alpha.1"
   },
   "peerDependencies": {
-    "@bufbuild/protobuf": "1.8.0"
+    "@bufbuild/protobuf": "2.0.0-alpha.1"
   },
   "peerDependenciesMeta": {
     "@bufbuild/protobuf": {

package/src/protoc-gen-es-plugin.ts

@@ -12,10 +12,27 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+import type {
+  DescEnum,
+  DescFile,
+  DescMessage,
+  DescService,
+} from "@bufbuild/protobuf";
+import { localName } from "@bufbuild/protobuf/reflect";
+import { embedFileDesc, pathInFileDesc } from "@bufbuild/protobuf/codegenv1";
 import { createEcmaScriptPlugin } from "@bufbuild/protoplugin";
-import { generateTs } from "./typescript.js";
-import { generateJs } from "./javascript.js";
-import { generateDts } from "./declaration.js";
+import type {
+  Schema,
+  GeneratedFile,
+  Printable,
+  Target,
+} from "@bufbuild/protoplugin/ecmascript";
+import {
+  arrayLiteral,
+  fieldUsesPrototype,
+  functionCall,
+  getFieldTypeInfo,
+} from "./util";
 import { version } from "../package.json";
 
 export const protocGenEs = createEcmaScriptPlugin({
@@ -25,3 +42,295 @@ export const protocGenEs = createEcmaScriptPlugin({
   generateJs,
   generateDts,
 });
+
+// This annotation informs bundlers that the succeeding function call is free of
+// side effects. This means the symbol can be removed from the module during
+// tree-shaking if it is unused.
+// See https://github.com/bufbuild/protobuf-es/pull/470
+const pure = "/*@__PURE__*/";
+
+// prettier-ignore
+function generateTs(schema: Schema) {
+  for (const file of schema.files) {
+    const f = schema.generateFile(file.name + "_pb.ts");
+    f.preamble(file);
+    const { GenDescFile } = f.runtime.codegen;
+    const fileDesc = f.importDesc(file);
+    f.print(f.exportDecl("const", fileDesc.name), ": ", GenDescFile, " = ", pure);
+    f.print("  ", getFileDescCall(f, file), ";");
+    f.print();
+    for (const desc of schema.typesInFile(file)) {
+      switch (desc.kind) {
+        case "message": {
+          generateMessageShape(f, desc, "ts");
+          const {GenDescMessage, messageDesc} = f.runtime.codegen;
+          const MessageShape = f.importShape(desc);
+          const fileDesc = f.importDesc(file);
+          const name = f.importDesc(desc).name;
+          f.print("// Describes the ", desc.toString(), ".");
+          f.print("// Use `create(", name, ")` to create a new ", MessageShape.name, ".");
+          const call = functionCall(messageDesc, [fileDesc, ...pathInFileDesc(desc)]);
+          f.print(f.exportDecl("const", name), ": ", GenDescMessage, "<", MessageShape, ">", " = ", pure);
+          f.print("  ", call, ";");
+          f.print();
+          break;
+        }
+        case "enum": {
+          generateEnumShape(f, desc);
+          const {GenDescEnum, enumDesc} = f.runtime.codegen;
+          const EnumShape = f.importShape(desc);
+          const fileDesc = f.importDesc(file);
+          f.print("// Describes the ", desc.toString(), ".");
+          const name = f.importDesc(desc).name;
+          const call = functionCall(enumDesc, [fileDesc, ...pathInFileDesc(desc)]);
+          f.print(f.exportDecl("const", name), ": ", GenDescEnum, "<", EnumShape, ">", " = ", pure);
+          f.print("  ", call, ";");
+          f.print();
+          break;
+        }
+        case "extension": {
+          const { GenDescExtension, extDesc } = f.runtime.codegen;
+          const name = f.importDesc(desc).name;
+          const E = f.importShape(desc.extendee);
+          const V = getFieldTypeInfo(desc).typing;
+          const call = functionCall(extDesc, [f.importDesc(file), ...pathInFileDesc(desc)]);
+          f.print(f.jsDoc(desc));
+          f.print(f.exportDecl("const", name), ": ", GenDescExtension, "<", E, ", ", V, ">", " = ", pure);
+          f.print("  ", call, ";");
+          f.print();
+          break;
+        }
+        case "service": {
+          const { GenDescService, serviceDesc} = f.runtime.codegen;
+          const name = f.importDesc(desc).name;
+          const call = functionCall(serviceDesc, [f.importDesc(file), ...pathInFileDesc(desc)]);
+          f.print(f.jsDoc(desc));
+          f.print(f.exportDecl("const", name), ": ", GenDescService, "<", getServiceShapeExpr(f, desc), "> = ", pure);
+          f.print("  ", call, ";");
+          f.print();
+          break;
+        }
+      }
+    }
+  }
+}
+
+// prettier-ignore
+function generateJs(schema: Schema) {
+  for (const file of schema.files) {
+    const f = schema.generateFile(file.name + "_pb.js");
+    f.preamble(file);
+    const fileDesc = f.importDesc(file);
+    f.print(f.exportDecl("const", fileDesc.name), " = ", pure);
+    f.print("  ", getFileDescCall(f, file), ";");
+    f.print();
+    for (const desc of schema.typesInFile(file)) {
+      switch (desc.kind) {
+        case "message": {
+          const { messageDesc} = f.runtime.codegen;
+          const MessageShape = f.importShape(desc);
+          const name = f.importDesc(desc).name;
+          f.print("// Describes the ", desc.toString(), ". Use `create(", name, ")` to create a new ", MessageShape.name, ".");
+          const call = functionCall(messageDesc, [fileDesc, ...pathInFileDesc(desc)]);
+          f.print(f.exportDecl("const", name), " = ", pure);
+          f.print("  ", call, ";");
+          f.print();
+          break;
+        }
+        case "enum": {
+          // generate descriptor
+          {
+            const { enumDesc } = f.runtime.codegen;
+            f.print("// Describes the ", desc.toString(), ".");
+            const name = f.importDesc(desc).name;
+            const call = functionCall(enumDesc, [fileDesc, ...pathInFileDesc(desc)]);
+            f.print(f.exportDecl("const", name), " = ", pure);
+            f.print("  ", call, ";");
+            f.print();
+          }
+          // declare TypeScript enum
+          {
+            f.print(f.jsDoc(desc));
+            const { tsEnum } = f.runtime.codegen;
+            const call = functionCall(tsEnum, [f.importDesc(desc)]);
+            f.print(f.exportDecl("const", f.importShape(desc).name), " = ", pure);
+            f.print("  ", call, ";");
+            f.print();
+          }
+          break;
+        }
+        case "extension": {
+          const { extDesc } = f.runtime.codegen;
+          const name = f.importDesc(desc).name;
+          const call = functionCall(extDesc, [f.importDesc(desc.file), ...pathInFileDesc(desc)]);
+          f.print(f.jsDoc(desc));
+          f.print(f.exportDecl("const", name), " = ", pure);
+          f.print("  ", call, ";");
+          f.print();
+          break;
+        }
+        case "service": {
+          const { serviceDesc} = f.runtime.codegen;
+          const name = f.importDesc(desc).name;
+          f.print(f.jsDoc(desc));
+          const call = functionCall(serviceDesc, [f.importDesc(desc.file), ...pathInFileDesc(desc)]);
+          f.print(f.exportDecl("const", name), " = ", pure);
+          f.print("  ", call, ";");
+          f.print();
+          break;
+        }
+      }
+    }
+  }
+}
+
+// prettier-ignore
+function generateDts(schema: Schema) {
+  for (const file of schema.files) {
+    const f = schema.generateFile(file.name + "_pb.d.ts");
+    f.preamble(file);
+    const { GenDescFile } = f.runtime.codegen;
+    const fileDesc = f.importDesc(file);
+    f.print(f.exportDecl("declare const", fileDesc.name), ": ", GenDescFile, ";");
+    f.print();
+    for (const desc of schema.typesInFile(file)) {
+      switch (desc.kind) {
+        case "message": {
+          generateMessageShape(f, desc, "dts");
+          const { GenDescMessage } = f.runtime.codegen;
+          const MessageShape = f.importShape(desc);
+          const name = f.importDesc(desc).name;
+          f.print("// Describes the ", desc.toString(), ". Use `create(", name, ")` to create a new ", MessageShape.name, ".");
+          f.print(f.exportDecl("declare const", name), ": ", GenDescMessage, "<", MessageShape, ">", ";");
+          f.print();
+          break;
+        }
+        case "enum": {
+          generateEnumShape(f, desc);
+          const { GenDescEnum } = f.runtime.codegen;
+          const EnumShape = f.importShape(desc);
+          f.print("// Describes the ", desc.toString(), ".");
+          const name = f.importDesc(desc).name;
+          f.print(f.exportDecl("declare const", name), ": ", GenDescEnum, "<", EnumShape, ">;");
+          f.print();
+          break;
+        }
+        case "extension": {
+          const { GenDescExtension } = f.runtime.codegen;
+          const name = f.importDesc(desc).name;
+          const E = f.importShape(desc.extendee);
+          const V = getFieldTypeInfo(desc).typing;
+          f.print(f.jsDoc(desc));
+          f.print(f.exportDecl("declare const", name), ": ", GenDescExtension, "<", E, ", ", V, ">;");
+          f.print();
+          break;
+        }
+        case "service": {
+          const { GenDescService } = f.runtime.codegen;
+          const name = f.importDesc(desc).name;
+          f.print(f.jsDoc(desc));
+          f.print(f.exportDecl("declare const", name), ": ", GenDescService, "<", getServiceShapeExpr(f, desc), ">;");
+          f.print();
+          break;
+        }
+      }
+    }
+  }
+}
+
+// prettier-ignore
+function getFileDescCall(f: GeneratedFile, file: DescFile) {
+  const info = embedFileDesc(file);
+  if (info.bootable && !f.runtime.create.from.startsWith("@bufbuild/protobuf")) {
+    // google/protobuf/descriptor.proto is embedded as a plain object when
+    // bootstrapping to avoid recursion
+    return functionCall(f.runtime.codegen.boot, [JSON.stringify(info.boot())]);
+  }
+  const { fileDesc } = f.runtime.codegen;
+  if (file.dependencies.length > 0) {
+    const deps: Printable = file.dependencies.map((f) => ({
+      kind: "es_desc_ref",
+      desc: f,
+    }));
+    return functionCall(fileDesc, [
+      f.string(info.base64()),
+      arrayLiteral(deps),
+    ]);
+  }
+  return functionCall(fileDesc, [f.string(info.base64())]);
+}
+
+// prettier-ignore
+function getServiceShapeExpr(f: GeneratedFile, service: DescService): Printable {
+  const p: Printable[] = [];
+  function print(...printables: Printable[]) {
+    p.push(...printables, "\n");
+  }
+  print("{");
+  for (const method of service.methods) {
+    print(f.jsDoc(method, "  "));
+    print("  ", localName(method), ": {");
+    print("    kind: ", f.string(method.methodKind), ";");
+    print("    I: ", f.importShape(method.input), ";");
+    print("    O: ", f.importShape(method.output), ";");
+    print("  },");
+  }
+  print("}");
+  return p;
+}
+
+// prettier-ignore
+function generateEnumShape(f: GeneratedFile, enumeration: DescEnum) {
+  f.print(f.jsDoc(enumeration));
+  f.print(f.exportDecl("enum", f.importShape(enumeration).name), " {");
+  for (const value of enumeration.values) {
+    if (enumeration.values.indexOf(value) > 0) {
+      f.print();
+    }
+    f.print(f.jsDoc(value, "  "));
+    f.print("  ", localName(value), " = ", value.number, ",");
+  }
+  f.print("}");
+  f.print();
+}
+
+// prettier-ignore
+function generateMessageShape(f: GeneratedFile, message: DescMessage, target: Extract<Target, "ts" | "dts">) {
+  const { Message } = f.runtime;
+  const declaration = target == "ts" ? "type" : "declare type";
+  f.print(f.jsDoc(message));
+  f.print(f.exportDecl(declaration, f.importShape(message).name), " = ", Message, "<", f.string(message.typeName), "> & {");
+  for (const member of message.members) {
+    switch (member.kind) {
+      case "oneof":
+        f.print(f.jsDoc(member, "  "));
+        f.print("  ", localName(member), ": {");
+        for (const field of member.fields) {
+          if (member.fields.indexOf(field) > 0) {
+            f.print(`  } | {`);
+          }
+          f.print(f.jsDoc(field, "    "));
+          const { typing } = getFieldTypeInfo(field);
+          f.print(`    value: `, typing, `;`);
+          f.print(`    case: "`, localName(field), `";`);
+        }
+        f.print(`  } | { case: undefined; value?: undefined };`);
+        break;
+      default: {
+        f.print(f.jsDoc(member, "  "));
+        const {typing, optional} = getFieldTypeInfo(member);
+        if (fieldUsesPrototype(member) || !optional) {
+          f.print("  ", localName(member), ": ", typing, ";");
+        } else {
+          f.print("  ", localName(member), "?: ", typing, ";");
+        }
+        break;
+      }
+    }
+    if (message.members.indexOf(member) < message.members.length - 1) {
+      f.print();
+    }
+  }
+  f.print("};");
+  f.print();
+}