@bufbuild/protobuf 0.0.6 → 0.0.9

package/dist/esm/{descriptor-registry.js → legacy-descriptor-registry.js}

@@ -11,13 +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 { FileDescriptorSet } from "./google/protobuf/descriptor_pb.js";
 import { assert } from "./private/assert.js";
 import { proto3 } from "./proto3.js";
 import { proto2 } from "./proto2.js";
 import { ScalarType } from "./field.js";
-import { DescriptorSet } from "./descriptor-set.js";
+import { LegacyDescriptorSet } from "./legacy-descriptor-set.js";
 import { protoInt64 } from "./proto-int64.js";
-import { makeMethodName } from "./private/names.js";
 import { Timestamp } from "./google/protobuf/timestamp_pb.js";
 import { Duration } from "./google/protobuf/duration_pb.js";
 import { Any } from "./google/protobuf/any_pb.js";
@@ -26,7 +26,6 @@ import { FieldMask } from "./google/protobuf/field_mask_pb.js";
 import { ListValue, NullValue, Struct, Value, } from "./google/protobuf/struct_pb.js";
 import { getEnumType } from "./private/enum.js";
 import { BoolValue, BytesValue, DoubleValue, FloatValue, Int32Value, Int64Value, StringValue, UInt32Value, UInt64Value, } from "./google/protobuf/wrappers_pb.js";
-import { FileDescriptorSet } from "./google/protobuf/descriptor_pb.js";
 // well-known message types with specialized JSON representation
 const wkMessages = [
     Any,
@@ -51,18 +50,20 @@ const wkMessages = [
 // well-known enum types with specialized JSON representation
 const wkEnums = [getEnumType(NullValue)];
 /**
- * DescriptorRegistry is a type registry that dynamically creates types
+ * LegacyDescriptorRegistry is a type registry that dynamically creates types
  * from a set of google.protobuf.FileDescriptorProto.
  *
  * By default, all well-known types with a specialized JSON representation
  * are replaced with their generated counterpart in this package.
+ *
+ * @deprecated
  */
-export class DescriptorRegistry {
+export class LegacyDescriptorRegistry {
     constructor(descriptorSet, replaceWkt = true) {
         this.enums = {};
         this.messages = {};
         this.services = {};
-        this.ds = descriptorSet ?? new DescriptorSet();
+        this.ds = descriptorSet !== null && descriptorSet !== void 0 ? descriptorSet : new LegacyDescriptorSet();
         if (replaceWkt) {
             for (const mt of wkMessages) {
                 this.messages["." + mt.typeName] = mt;
@@ -80,7 +81,7 @@ export class DescriptorRegistry {
         const set = bytesOrSet instanceof Uint8Array
             ? FileDescriptorSet.fromBinary(bytesOrSet)
             : new FileDescriptorSet(bytesOrSet);
-        const dr = new DescriptorRegistry();
+        const dr = new LegacyDescriptorRegistry();
         dr.add(...set.file);
         return dr;
     }
@@ -107,6 +108,7 @@ export class DescriptorRegistry {
         const type = runtime.makeEnumType(typeName, raw.values.map((u) => ({
             no: u.number,
             name: u.name,
+            localName: u.name,
         })), {});
         this.enums[protoTypeName] = type;
         return type;
@@ -157,7 +159,7 @@ export class DescriptorRegistry {
             assert(ot, `output message "${u.outputTypeName}" for ${u.toString()} not found`);
             const m = {
                 name: u.name,
-                localName: makeMethodName(u.name),
+                localName: localMethodName(u.name),
                 I: it,
                 O: ot,
                 kind: u.kind,
@@ -172,9 +174,16 @@ export class DescriptorRegistry {
         });
     }
 }
+function localMethodName(protoName) {
+    if (protoName.length == 0) {
+        return protoName;
+    }
+    return protoName[0].toLowerCase() + protoName.substring(1);
+}
 function makeTypeLocalName(type) {
+    var _a;
     const typeName = type.typeName;
-    const packagePrefix = (type.file.proto.package ?? "") + ".";
+    const packagePrefix = ((_a = type.file.proto.package) !== null && _a !== void 0 ? _a : "") + ".";
     if (!typeName.startsWith(packagePrefix)) {
         return type.name;
     }
@@ -203,32 +212,23 @@ function makeMapFieldInfo(field, resolver) {
     if (field.map.value.message) {
         const messageType = resolver.findMessage(field.map.value.message.typeName);
         assert(messageType, `message "${field.map.value.message.typeName}" for ${field.toString()} not found`);
-        return {
-            ...base,
-            V: {
+        return Object.assign(Object.assign({}, base), { V: {
                 kind: "message",
                 T: messageType,
-            },
-        };
+            } });
     }
     if (field.map.value.enum) {
         const enumType = resolver.findEnum(field.map.value.enum.typeName);
         assert(enumType, `enum "${field.map.value.enum.typeName}" for ${field.toString()} not found`);
-        return {
-            ...base,
-            V: {
+        return Object.assign(Object.assign({}, base), { V: {
                 kind: "enum",
                 T: enumType,
-            },
-        };
+            } });
     }
-    return {
-        ...base,
-        V: {
+    return Object.assign(Object.assign({}, base), { V: {
             kind: "scalar",
             T: field.map.value.scalarType,
-        },
-    };
+        } });
 }
 function makeScalarFieldInfo(field) {
     const base = {
@@ -238,25 +238,13 @@ function makeScalarFieldInfo(field) {
         T: field.scalarType,
     };
     if (field.repeated) {
-        return {
-            ...base,
-            repeated: true,
-            packed: field.packed,
-            oneof: undefined,
-            T: field.scalarType,
-        };
+        return Object.assign(Object.assign({}, base), { repeated: true, packed: field.packed, oneof: undefined, T: field.scalarType });
     }
     if (field.oneof) {
-        return {
-            ...base,
-            oneof: field.oneof.name,
-        };
+        return Object.assign(Object.assign({}, base), { oneof: field.oneof.name });
     }
     if (field.optional) {
-        return {
-            ...base,
-            opt: true,
-        };
+        return Object.assign(Object.assign({}, base), { opt: true });
     }
     return base;
 }
@@ -270,24 +258,13 @@ function makeMessageFieldInfo(field, resolver) {
         T: messageType,
     };
     if (field.repeated) {
-        return {
-            ...base,
-            repeated: true,
-            packed: field.packed,
-            oneof: undefined,
-        };
+        return Object.assign(Object.assign({}, base), { repeated: true, packed: field.packed, oneof: undefined });
     }
     if (field.oneof) {
-        return {
-            ...base,
-            oneof: field.oneof.name,
-        };
+        return Object.assign(Object.assign({}, base), { oneof: field.oneof.name });
     }
     if (field.optional) {
-        return {
-            ...base,
-            opt: true,
-        };
+        return Object.assign(Object.assign({}, base), { opt: true });
     }
     return base;
 }
@@ -301,24 +278,13 @@ function makeEnumFieldInfo(field, resolver) {
         T: enumType,
     };
     if (field.repeated) {
-        return {
-            ...base,
-            repeated: true,
-            packed: field.packed,
-            oneof: undefined,
-        };
+        return Object.assign(Object.assign({}, base), { repeated: true, packed: field.packed, oneof: undefined });
     }
     if (field.oneof) {
-        return {
-            ...base,
-            oneof: field.oneof.name,
-        };
+        return Object.assign(Object.assign({}, base), { oneof: field.oneof.name });
     }
     if (field.optional) {
-        return {
-            ...base,
-            opt: true,
-        };
+        return Object.assign(Object.assign({}, base), { opt: true });
     }
     return base;
 }

package/dist/esm/legacy-descriptor-set.js

@@ -0,0 +1,449 @@
+// 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 { FieldDescriptorProto_Label, FieldDescriptorProto_Type, MethodOptions_IdempotencyLevel, } from "./google/protobuf/descriptor_pb.js";
+import { assert } from "./private/assert.js";
+import { ScalarType } from "./field.js";
+import { MethodIdempotency, MethodKind } from "./service-type.js";
+/**
+ * LegacyDescriptorSet wraps a set of google.protobuf.FileDescriptorProto,
+ * asserting basic expectations and providing hierarchical information.
+ *
+ * Note that all types are kept by their fully qualified type name
+ * with a leading dot.
+ *
+ * @deprecated
+ */
+export class LegacyDescriptorSet {
+    constructor() {
+        this.enums = {};
+        this.messages = {};
+        this.services = {};
+    }
+    /**
+     * May raise an error on invalid descriptors.
+     */
+    add(...files) {
+        for (const file of files) {
+            newFile(file, this);
+        }
+    }
+    listEnums() {
+        return Object.values(this.enums).filter(isDefined);
+    }
+    listMessages() {
+        return Object.values(this.messages).filter(isDefined);
+    }
+    listServices() {
+        return Object.values(this.services).filter(isDefined);
+    }
+}
+function isDefined(v) {
+    return v !== undefined;
+}
+const fieldTypeToScalarType = {
+    [FieldDescriptorProto_Type.DOUBLE]: ScalarType.DOUBLE,
+    [FieldDescriptorProto_Type.FLOAT]: ScalarType.FLOAT,
+    [FieldDescriptorProto_Type.INT64]: ScalarType.INT64,
+    [FieldDescriptorProto_Type.UINT64]: ScalarType.UINT64,
+    [FieldDescriptorProto_Type.INT32]: ScalarType.INT32,
+    [FieldDescriptorProto_Type.FIXED64]: ScalarType.FIXED64,
+    [FieldDescriptorProto_Type.FIXED32]: ScalarType.FIXED32,
+    [FieldDescriptorProto_Type.BOOL]: ScalarType.BOOL,
+    [FieldDescriptorProto_Type.STRING]: ScalarType.STRING,
+    [FieldDescriptorProto_Type.GROUP]: undefined,
+    [FieldDescriptorProto_Type.MESSAGE]: undefined,
+    [FieldDescriptorProto_Type.BYTES]: ScalarType.BYTES,
+    [FieldDescriptorProto_Type.UINT32]: ScalarType.UINT32,
+    [FieldDescriptorProto_Type.ENUM]: undefined,
+    [FieldDescriptorProto_Type.SFIXED32]: ScalarType.SFIXED32,
+    [FieldDescriptorProto_Type.SFIXED64]: ScalarType.SFIXED64,
+    [FieldDescriptorProto_Type.SINT32]: ScalarType.SINT32,
+    [FieldDescriptorProto_Type.SINT64]: ScalarType.SINT64,
+};
+function newFile(proto, ds) {
+    assert(proto.name, `missing file descriptor name`);
+    if (proto.syntax !== undefined && proto.syntax !== "proto3") {
+        throw new Error(`invalid descriptor: unsupported syntax: ${proto.syntax}`);
+    }
+    const file = {
+        proto,
+        syntax: proto.syntax === "proto3" ? "proto3" : "proto2",
+        name: proto.name.endsWith(".proto")
+            ? proto.name.substring(-".proto".length)
+            : proto.name,
+        toString() {
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions -- we asserted above
+            return `file ${this.proto.name}`;
+        },
+    };
+    for (const messageType of proto.messageType) {
+        newMessage(messageType, undefined, file, ds);
+    }
+    for (const enumType of proto.enumType) {
+        newEnum(enumType, undefined, file, ds);
+    }
+    for (const extension of proto.extension) {
+        newExtension(extension, undefined, file, ds);
+    }
+    for (const service of proto.service) {
+        newService(service, file, ds);
+    }
+    return file;
+}
+function newEnum(proto, parent, file, us) {
+    assert(proto.name, `invalid descriptor: missing enum descriptor name`);
+    let protoTypeName;
+    if (parent) {
+        protoTypeName = `${parent.protoTypeName}.${proto.name}`;
+    }
+    else if (file.proto.package !== undefined) {
+        protoTypeName = `.${file.proto.package}.${proto.name}`;
+    }
+    else {
+        protoTypeName = `.${proto.name}`;
+    }
+    const values = [];
+    const enumT = {
+        proto,
+        file,
+        parent,
+        name: proto.name,
+        protoTypeName,
+        typeName: protoTypeName.startsWith(".")
+            ? protoTypeName.substring(1)
+            : protoTypeName,
+        values,
+        toString() {
+            return `enum ${this.typeName}`;
+        },
+    };
+    us.enums[enumT.protoTypeName] = enumT;
+    for (const value of proto.value) {
+        values.push(newEnumValue(value, enumT));
+    }
+    return enumT;
+}
+function newEnumValue(proto, parent) {
+    assert(proto.name, `invalid descriptor: missing enum value descriptor name`);
+    assert(proto.number !== undefined, `invalid descriptor: missing enum value descriptor number`);
+    return {
+        proto,
+        name: proto.name,
+        number: proto.number,
+        parent,
+        toString() {
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions -- we asserted above
+            return `enum value ${this.parent.typeName}.${this.proto.name}`;
+        },
+    };
+}
+function newMessage(proto, parent, file, us) {
+    var _a;
+    assert(proto.name, `invalid descriptor: missing name`);
+    const nestedMessages = [];
+    const fields = [];
+    const oneofs = [];
+    const nestedEnums = [];
+    const nestedExtensions = [];
+    let protoTypeName;
+    if (parent) {
+        protoTypeName = `${parent.protoTypeName}.${proto.name}`;
+    }
+    else if (file.proto.package !== undefined) {
+        protoTypeName = `.${file.proto.package}.${proto.name}`;
+    }
+    else {
+        protoTypeName = `.${proto.name}`;
+    }
+    const message = {
+        proto,
+        file,
+        parent,
+        name: proto.name,
+        typeName: protoTypeName.startsWith(".")
+            ? protoTypeName.substring(1)
+            : protoTypeName,
+        protoTypeName,
+        fields,
+        oneofs,
+        nestedEnums,
+        nestedMessages,
+        nestedExtensions,
+        toString() {
+            return `message ${this.typeName}`;
+        },
+    };
+    us.messages[message.protoTypeName] = message;
+    for (const nestedType of proto.nestedType) {
+        nestedMessages.push(newMessage(nestedType, message, file, us));
+    }
+    for (const oneofDecl of proto.oneofDecl) {
+        oneofs.push(newOneof(oneofDecl, message, file));
+    }
+    for (const field of proto.field) {
+        let oneof = undefined;
+        if (field.oneofIndex !== undefined) {
+            oneof = oneofs[field.oneofIndex];
+            assert(oneof, `invalid descriptor: oneof declaration index ${field.oneofIndex} specified by field #${(_a = field.number) !== null && _a !== void 0 ? _a : -1} not found`);
+        }
+        fields.push(newField(field, message, oneof));
+    }
+    for (const enumType of proto.enumType) {
+        nestedEnums.push(newEnum(enumType, message, file, us));
+    }
+    for (const extension of proto.extension) {
+        nestedExtensions.push(newExtension(extension, message, file, us));
+    }
+    return message;
+}
+function newField(proto, parent, oneof) {
+    var _a;
+    assert(proto.name, `invalid descriptor: missing name`);
+    assert(proto.number, `invalid descriptor: missing number`);
+    assert(proto.type, `invalid descriptor: missing type`);
+    let optional = false;
+    let packed = ((_a = proto.options) === null || _a === void 0 ? void 0 : _a.packed) === true;
+    switch (parent.file.syntax) {
+        case "proto2":
+            optional =
+                oneof === undefined &&
+                    proto.label === FieldDescriptorProto_Label.OPTIONAL;
+            break;
+        case "proto3":
+            optional = proto.proto3Optional === true;
+            switch (proto.type) {
+                case FieldDescriptorProto_Type.DOUBLE:
+                case FieldDescriptorProto_Type.FLOAT:
+                case FieldDescriptorProto_Type.INT64:
+                case FieldDescriptorProto_Type.UINT64:
+                case FieldDescriptorProto_Type.INT32:
+                case FieldDescriptorProto_Type.FIXED64:
+                case FieldDescriptorProto_Type.FIXED32:
+                case FieldDescriptorProto_Type.UINT32:
+                case FieldDescriptorProto_Type.SFIXED32:
+                case FieldDescriptorProto_Type.SFIXED64:
+                case FieldDescriptorProto_Type.SINT32:
+                case FieldDescriptorProto_Type.SINT64:
+                case FieldDescriptorProto_Type.BOOL:
+                case FieldDescriptorProto_Type.ENUM:
+                    // From the proto3 language guide:
+                    // > In proto3, repeated fields of scalar numeric types are packed by default.
+                    // This information is incomplete - according to the conformance tests, BOOL
+                    // and ENUM are packed by default as well. This means only STRING and BYTES
+                    // are not packed by default, which makes sense because they are length-delimited.
+                    packed = true;
+                    break;
+                case FieldDescriptorProto_Type.STRING:
+                case FieldDescriptorProto_Type.GROUP:
+                case FieldDescriptorProto_Type.MESSAGE:
+                case FieldDescriptorProto_Type.BYTES:
+                    assert(!packed, `invalid descriptor: ${FieldDescriptorProto_Type[proto.type]} cannot be packed`);
+                    break;
+            }
+            break;
+    }
+    const field = {
+        proto,
+        name: proto.name,
+        number: proto.number,
+        type: proto.type,
+        parent,
+        oneof: proto.proto3Optional === true ? undefined : oneof,
+        optional,
+        packed,
+        toString() {
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions -- we asserted above
+            return `field ${parent.typeName}.${proto.name}`;
+        },
+        resolve(us) {
+            return resolveField(this, us);
+        },
+    };
+    if (oneof) {
+        oneof.fields.push(field);
+    }
+    return field;
+}
+function resolveField(u, us) {
+    var _a;
+    const repeated = u.proto.label === FieldDescriptorProto_Label.REPEATED;
+    switch (u.type) {
+        case FieldDescriptorProto_Type.MESSAGE:
+        case FieldDescriptorProto_Type.GROUP: {
+            assert(u.proto.typeName, `invalid descriptor: ${u.toString()} has type ${FieldDescriptorProto_Type[u.type]}, but type_name is unset`);
+            const refMessage = us.messages[u.proto.typeName];
+            assert(refMessage, `invalid descriptor: cannot find type_name "${u.proto.typeName}" specified by ${u.toString()}`);
+            if (((_a = refMessage.proto.options) === null || _a === void 0 ? void 0 : _a.mapEntry) !== undefined) {
+                return Object.assign(Object.assign({}, u), { repeated: false, scalarType: undefined, message: undefined, enum: undefined, map: resolveMap(refMessage, us) });
+            }
+            return Object.assign(Object.assign({}, u), { repeated, scalarType: undefined, message: refMessage, enum: undefined, map: undefined });
+        }
+        case FieldDescriptorProto_Type.ENUM: {
+            assert(u.proto.typeName, `invalid descriptor: ${u.toString()} has type ${FieldDescriptorProto_Type[u.type]}, but type_name is unset`);
+            const refEnum = us.enums[u.proto.typeName];
+            assert(refEnum, `invalid descriptor: cannot find type_name "${u.proto.typeName}" specified by ${u.toString()}`);
+            return Object.assign(Object.assign({}, u), { repeated, scalarType: undefined, message: undefined, enum: refEnum, map: undefined });
+        }
+        default: {
+            const scalarType = fieldTypeToScalarType[u.type];
+            assert(scalarType, `invalid descriptor: unable to convert google.protobuf.FieldDescriptorProto.Type ${FieldDescriptorProto_Type[u.type]} to ScalarType`);
+            return Object.assign(Object.assign({}, u), { repeated,
+                scalarType, message: undefined, enum: undefined, map: undefined });
+        }
+    }
+}
+function resolveMap(mapEntry, us) {
+    var _a;
+    assert((_a = mapEntry.proto.options) === null || _a === void 0 ? void 0 : _a.mapEntry, `invalid descriptor: expected ${mapEntry.toString()} to be a map entry`);
+    assert(mapEntry.fields.length === 2, `invalid descriptor: map entry ${mapEntry.toString()} has ${mapEntry.fields.length} fields`);
+    const uKeyField = mapEntry.fields.find((f) => f.proto.number === 1);
+    assert(uKeyField, `invalid descriptor: map entry ${mapEntry.toString()} is missing key field`);
+    const keyField = resolveField(uKeyField, us);
+    assert(keyField.scalarType !== undefined &&
+        keyField.scalarType !== ScalarType.BYTES &&
+        keyField.scalarType !== ScalarType.FLOAT &&
+        keyField.scalarType !== ScalarType.DOUBLE, `invalid descriptor: map entry ${mapEntry.toString()} has unexpected key type ${FieldDescriptorProto_Type[keyField.type]}`);
+    const uValueField = mapEntry.fields.find((f) => f.proto.number === 2);
+    assert(uValueField, `invalid descriptor: map entry ${mapEntry.toString()} is missing value field`);
+    const valueField = resolveField(uValueField, us);
+    if (valueField.scalarType !== undefined) {
+        return {
+            key: keyField.scalarType,
+            value: {
+                scalarType: valueField.scalarType,
+                enum: undefined,
+                message: undefined,
+            },
+        };
+    }
+    if (valueField.enum !== undefined) {
+        return {
+            key: keyField.scalarType,
+            value: { scalar: undefined, enum: valueField.enum, message: undefined },
+        };
+    }
+    if (valueField.message !== undefined) {
+        return {
+            key: keyField.scalarType,
+            value: {
+                scalar: undefined,
+                enum: undefined,
+                message: valueField.message,
+            },
+        };
+    }
+    throw new Error(`invalid descriptor: map entry ${mapEntry.toString()} has unexpected value type ${FieldDescriptorProto_Type[keyField.type]}`);
+}
+function newOneof(proto, parent, file) {
+    assert(proto.name, `invalid descriptor: missing oneof descriptor name`);
+    return {
+        proto,
+        parent,
+        file,
+        fields: [],
+        name: proto.name,
+        toString() {
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions -- we asserted above
+            return `oneof ${parent.typeName}.${proto.name}`;
+        },
+    };
+}
+function newExtension(proto, parent, file, us // eslint-disable-line @typescript-eslint/no-unused-vars
+) {
+    assert(proto.name, `invalid descriptor: missing field descriptor name`);
+    return {
+        proto,
+        file,
+        parent,
+    };
+}
+function newService(proto, file, us) {
+    assert(proto.name, `invalid descriptor: missing service descriptor name`);
+    let protoTypeName;
+    if (file.proto.package !== undefined) {
+        protoTypeName = `.${file.proto.package}.${proto.name}`;
+    }
+    else {
+        protoTypeName = `.${proto.name}`;
+    }
+    const methods = [];
+    const service = {
+        proto,
+        file,
+        typeName: protoTypeName.startsWith(".")
+            ? protoTypeName.substring(1)
+            : protoTypeName,
+        protoTypeName,
+        methods,
+        toString() {
+            return `service ${this.typeName}`;
+        },
+    };
+    for (const method of proto.method) {
+        methods.push(newMethod(method, service));
+    }
+    us.services[service.protoTypeName] = service;
+    return service;
+}
+function newMethod(proto, parent) {
+    var _a;
+    assert(proto.name, `invalid descriptor: missing method descriptor name`);
+    assert(proto.inputType, `invalid descriptor: missing method input type`);
+    assert(proto.outputType, `invalid descriptor: missing method output type`);
+    let kind;
+    if (proto.clientStreaming === true && proto.serverStreaming === true) {
+        kind = MethodKind.BiDiStreaming;
+    }
+    else if (proto.clientStreaming === true) {
+        kind = MethodKind.ClientStreaming;
+    }
+    else if (proto.serverStreaming === true) {
+        kind = MethodKind.ServerStreaming;
+    }
+    else {
+        kind = MethodKind.Unary;
+    }
+    let idempotency;
+    switch ((_a = proto.options) === null || _a === void 0 ? void 0 : _a.idempotencyLevel) {
+        case MethodOptions_IdempotencyLevel.IDEMPOTENT:
+            idempotency = MethodIdempotency.Idempotent;
+            break;
+        case MethodOptions_IdempotencyLevel.NO_SIDE_EFFECTS:
+            idempotency = MethodIdempotency.NoSideEffects;
+            break;
+        case MethodOptions_IdempotencyLevel.IDEMPOTENCY_UNKNOWN:
+        case undefined:
+            idempotency = undefined;
+            break;
+    }
+    const inputTypeName = proto.inputType.startsWith(".")
+        ? proto.inputType.substring(1)
+        : proto.inputType;
+    const outputTypeName = proto.outputType.startsWith(".")
+        ? proto.outputType.substring(1)
+        : proto.outputType;
+    return {
+        proto,
+        parent,
+        name: proto.name,
+        kind,
+        idempotency,
+        inputTypeName,
+        outputTypeName,
+        toString() {
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions -- we asserted above
+            return `rpc ${this.parent.typeName}.${proto.name}`;
+        },
+    };
+}