@bufbuild/protobuf 0.0.8 → 0.1.0

package/dist/esm/private/enum.js

@@ -27,35 +27,30 @@ export function getEnumType(enumObject) {
 /**
  * Sets reflection information on a generated enum.
  */
-export function setEnumType(enumObject, typeName, values
-// We do not surface options at this time
-// opt?: {
-// options?: { readonly [extensionName: string]: JsonValue };
-// },
-) {
+export function setEnumType(enumObject, typeName, values, opt) {
     // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
-    enumObject[enumTypeSymbol] = makeEnumType(typeName, values);
+    enumObject[enumTypeSymbol] = makeEnumType(typeName, values.map((v) => ({
+        no: v.no,
+        name: v.name,
+        localName: enumObject[v.no],
+    })), opt);
 }
-// We do not surface options at this time
-// export type PartialEnumValue = Omit<EnumValueInfo, 'options'> & Partial<Pick<EnumValueInfo, "options">>;
 /**
  * Create a new EnumType with the given values.
  */
-export function makeEnumType(typeName, values
-// We do not surface options at this time
-// opt?: {
-// options?: { readonly [extensionName: string]: JsonValue };
-// },
-) {
+export function makeEnumType(typeName, values, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+_opt) {
     const names = Object.create(null);
     const numbers = Object.create(null);
     const normalValues = [];
     for (const value of values) {
         // We do not surface options at this time
         // const value: EnumValueInfo = {...v, options: v.options ?? emptyReadonlyObject};
-        normalValues.push(value);
-        names[value.name] = value;
-        numbers[value.no] = value;
+        const n = normalizeEnumValue(value);
+        normalValues.push(n);
+        names[value.name] = n;
+        numbers[value.no] = n;
     }
     return {
         typeName,
@@ -72,25 +67,21 @@ export function makeEnumType(typeName, values
 }
 /**
  * Create a new enum object with the given values.
+ * Sets reflection information.
  */
 export function makeEnum(typeName, values, opt) {
     const enumObject = {};
     for (const value of values) {
-        const name = makeEnumValueName(value, opt === null || opt === void 0 ? void 0 : opt.sharedPrefix);
-        enumObject[name] = value.no;
-        enumObject[value.no] = name;
+        const n = normalizeEnumValue(value);
+        enumObject[n.localName] = n.no;
+        enumObject[n.no] = n.localName;
     }
-    setEnumType(enumObject, typeName, values);
+    setEnumType(enumObject, typeName, values, opt);
     return enumObject;
 }
-// Construct a local name for an enum value.
-// This logic matches the Go function with the same name in private/protoplugin/names.go
-function makeEnumValueName(value, sharedPrefix) {
-    if (sharedPrefix === undefined) {
-        return value.name;
+function normalizeEnumValue(value) {
+    if ("localName" in value) {
+        return value;
     }
-    if (!value.name.startsWith(sharedPrefix)) {
-        return value.name;
-    }
-    return value.name.substring(sharedPrefix.length);
+    return Object.assign(Object.assign({}, value), { localName: value.name });
 }

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

@@ -11,6 +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 { ScalarType } from "../field.js";
 /**
  * Wrap field values whose message type has a wrapper.
  */
@@ -29,3 +30,30 @@ export function wrapField(type, value) {
 export function unwrapField(type, value) {
     return type.fieldWrapper ? type.fieldWrapper.unwrapField(value) : value;
 }
+/**
+ * If the given field uses one of the well-known wrapper types, return
+ * the base type it wraps.
+ */
+export function getUnwrappedFieldType(field) {
+    if (field.kind !== "message_field") {
+        return undefined;
+    }
+    if (field.repeated) {
+        return undefined;
+    }
+    if (field.oneof != undefined) {
+        return undefined;
+    }
+    return wktWrapperToScalarType[field.message.typeName];
+}
+const wktWrapperToScalarType = {
+    "google.protobuf.DoubleValue": ScalarType.DOUBLE,
+    "google.protobuf.FloatValue": ScalarType.FLOAT,
+    "google.protobuf.Int64Value": ScalarType.INT64,
+    "google.protobuf.UInt64Value": ScalarType.UINT64,
+    "google.protobuf.Int32Value": ScalarType.INT32,
+    "google.protobuf.UInt32Value": ScalarType.UINT32,
+    "google.protobuf.BoolValue": ScalarType.BOOL,
+    "google.protobuf.StringValue": ScalarType.STRING,
+    "google.protobuf.BytesValue": ScalarType.BYTES,
+};

package/dist/esm/private/field.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 { makeOneofName } from "./names.js";
+import { localOneofName } from "./names.js";
 import { assert } from "./assert.js";
 export class InternalOneofInfo {
     constructor(name) {
@@ -22,7 +22,7 @@ export class InternalOneofInfo {
         this.default = undefined;
         this.fields = [];
         this.name = name;
-        this.localName = makeOneofName(name);
+        this.localName = localOneofName(name);
     }
     addField(field) {
         assert(field.oneof === this, `field ${field.name} not one of ${this.name}`);

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

@@ -73,12 +73,12 @@ export function makeJsonFormatCommon(makeWriteField) {
                         continue;
                     }
                     if (!Array.isArray(jsonValue)) {
-                        throw new Error(`cannot decode field ${type.typeName}.${field.name} from JSON: "${this.debug(jsonValue)}"`);
+                        throw new Error(`cannot decode field ${type.typeName}.${field.name} from JSON: ${this.debug(jsonValue)}`);
                     }
                     const targetArray = target[localName];
                     for (const jsonItem of jsonValue) {
                         if (jsonItem === null) {
-                            throw new Error(`cannot decode field ${type.typeName}.${field.name} from JSON: "${this.debug(jsonItem)}"`);
+                            throw new Error(`cannot decode field ${type.typeName}.${field.name} from JSON: ${this.debug(jsonItem)}`);
                         }
                         let val;
                         // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- "map" is invalid for repeated fields
@@ -96,7 +96,7 @@ export function makeJsonFormatCommon(makeWriteField) {
                                     val = readScalar(field.T, jsonItem);
                                 }
                                 catch (e) {
-                                    let m = `cannot decode field ${type.typeName}.${field.name} from JSON: "${this.debug(jsonItem)}"`;
+                                    let m = `cannot decode field ${type.typeName}.${field.name} from JSON: ${this.debug(jsonItem)}`;
                                     if (e instanceof Error && e.message.length > 0) {
                                         m += `: ${e.message}`;
                                     }
@@ -134,7 +134,7 @@ export function makeJsonFormatCommon(makeWriteField) {
                                     val = readScalar(field.V.T, jsonMapValue);
                                 }
                                 catch (e) {
-                                    let m = `cannot decode map value for field ${type.typeName}.${field.name} from JSON: "${this.debug(jsonValue)}"`;
+                                    let m = `cannot decode map value for field ${type.typeName}.${field.name} from JSON: ${this.debug(jsonValue)}`;
                                     if (e instanceof Error && e.message.length > 0) {
                                         m += `: ${e.message}`;
                                     }
@@ -152,7 +152,7 @@ export function makeJsonFormatCommon(makeWriteField) {
                                 : jsonMapKey).toString()] = val;
                         }
                         catch (e) {
-                            let m = `cannot decode map key for field ${type.typeName}.${field.name} from JSON: "${this.debug(jsonValue)}"`;
+                            let m = `cannot decode map key for field ${type.typeName}.${field.name} from JSON: ${this.debug(jsonValue)}`;
                             if (e instanceof Error && e.message.length > 0) {
                                 m += `: ${e.message}`;
                             }
@@ -187,7 +187,7 @@ export function makeJsonFormatCommon(makeWriteField) {
                                 target[localName] = readScalar(field.T, jsonValue);
                             }
                             catch (e) {
-                                let m = `cannot decode field ${type.typeName}.${field.name} from JSON: "${this.debug(jsonValue)}"`;
+                                let m = `cannot decode field ${type.typeName}.${field.name} from JSON: ${this.debug(jsonValue)}`;
                                 if (e instanceof Error && e.message.length > 0) {
                                     m += `: ${e.message}`;
                                 }

package/dist/esm/private/names.js

@@ -12,38 +12,113 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 /**
- * Returns the JSON name for a protobuf field, exactly like protoc does.
+ * Returns the name of a protobuf element in generated code.
+ *
+ * Field names - including oneofs - are converted to lowerCamelCase. For
+ * messages, enumerations and services, the package name is stripped from
+ * the type name. For nested messages and enumerations, the names are joined
+ * with an underscore. For methods, the first character is made lowercase.
  */
-export function makeJsonName(protoName) {
-    return protoCamelCase(protoName);
+export function localName(desc) {
+    switch (desc.kind) {
+        case "enum_field":
+        case "message_field":
+        case "map_field":
+        case "scalar_field":
+            return localFieldName(desc.name, desc.oneof !== undefined);
+        case "oneof":
+            return localOneofName(desc.name);
+        case "enum":
+        case "message":
+        case "service": {
+            const pkg = desc.file.proto.package;
+            const offset = pkg === undefined ? 0 : pkg.length + 1;
+            const name = desc.typeName.substring(offset).replace(/\./g, "_");
+            if (reservedIdent[name]) {
+                return name + "$";
+            }
+            return name;
+        }
+        case "enum_value": {
+            const sharedPrefix = desc.parent.sharedPrefix;
+            if (sharedPrefix === undefined) {
+                return desc.name;
+            }
+            const name = desc.name.substring(sharedPrefix.length);
+            if (reservedObjectProperties[name]) {
+                return name + "$";
+            }
+            return name;
+        }
+        case "rpc": {
+            let name = desc.name;
+            if (name.length == 0) {
+                return name;
+            }
+            name = name[0].toLowerCase() + name.substring(1);
+            if (reservedObjectProperties[name]) {
+                return name + "$";
+            }
+            return name;
+        }
+    }
 }
 /**
- * Returns the local name of a field, exactly like protoc-gen-es does.
+ * Returns the name of a field in generated code.
  */
-export function makeFieldName(protoName, inOneof) {
-    const n = protoCamelCase(protoName);
+export function localFieldName(protoName, inOneof) {
+    let name = protoCamelCase(protoName);
     if (inOneof) {
-        return n;
+        // oneof member names are not properties, but values of the `case` property.
+        return name;
     }
-    return rProp[n] ? n + escapeChar : n;
+    if (reservedObjectProperties[name] || reservedMessageProperties[name]) {
+        name = name + "$";
+    }
+    return name;
 }
 /**
- * Returns the local name of a oneof group, exactly like protoc-gen-es does.
+ * Returns the name of a oneof group in generated code.
  */
-export function makeOneofName(protoName) {
-    return makeFieldName(protoName, false);
+export function localOneofName(protoName) {
+    return localFieldName(protoName, false);
 }
 /**
- * Returns the local name of a rpc, exactly like protoc-gen-es does.
+ * Returns the JSON name for a protobuf field, exactly like protoc does.
  */
-export function makeMethodName(protoName) {
-    if (protoName.length == 0) {
-        return protoName;
+export const fieldJsonName = protoCamelCase;
+/**
+ * Finds a prefix shared by enum values, for example `MY_ENUM_` for
+ * `enum MyEnum {MY_ENUM_A=0; MY_ENUM_B=1;}`.
+ */
+export function findEnumSharedPrefix(enumName, valueNames) {
+    const prefix = camelToSnakeCase(enumName) + "_";
+    for (const name of valueNames) {
+        if (!name.toLowerCase().startsWith(prefix)) {
+            return undefined;
+        }
+        const shortName = name.substring(prefix.length);
+        if (shortName.length == 0) {
+            return undefined;
+        }
+        if (/^\d/.test(shortName)) {
+            // identifiers must not start with numbers
+            return undefined;
+        }
     }
-    return protoName[0].toLowerCase() + protoName.substring(1);
+    return prefix;
+}
+/**
+ * Converts lowerCamelCase or UpperCamelCase into lower_snake_case.
+ * This is used to find shared prefixes in an enum.
+ */
+function camelToSnakeCase(camel) {
+    return (camel.substring(0, 1) + camel.substring(1).replace(/[A-Z]/g, (c) => "_" + c)).toLowerCase();
 }
-// Converts snake_case to protoCamelCase according to the convention
-// used by protoc to convert a field name to a JSON name.
+/**
+ * Converts snake_case to protoCamelCase according to the convention
+ * used by protoc to convert a field name to a JSON name.
+ */
 function protoCamelCase(snakeCase) {
     let capNext = false;
     const b = [];
@@ -77,17 +152,81 @@ function protoCamelCase(snakeCase) {
     }
     return b.join("");
 }
-// escapeChar must be appended to a reserved name.
-// We choose '$' because it is invalid in proto identifiers.
-const escapeChar = "$";
-// Names that cannot be used for object properties.
-// See buf_es/protoc-gen-es/internal/protoplugin/names.go
-const rProp = {
+// Names that cannot be used for identifiers, such as class names,
+// but _can_ be used for object properties.
+const reservedIdent = {
+    // ECMAScript 2015 keywords
+    break: true,
+    case: true,
+    catch: true,
+    class: true,
+    const: true,
+    continue: true,
+    debugger: true,
+    default: true,
+    delete: true,
+    do: true,
+    else: true,
+    export: true,
+    extends: true,
+    false: true,
+    finally: true,
+    for: true,
+    function: true,
+    if: true,
+    import: true,
+    in: true,
+    instanceof: true,
+    new: true,
+    null: true,
+    return: true,
+    super: true,
+    switch: true,
+    this: true,
+    throw: true,
+    true: true,
+    try: true,
+    typeof: true,
+    var: true,
+    void: true,
+    while: true,
+    with: true,
+    yield: true,
+    // ECMAScript 2015 future reserved keywords
+    enum: true,
+    implements: true,
+    interface: true,
+    let: true,
+    package: true,
+    private: true,
+    protected: true,
+    public: true,
+    static: true,
+    // Class name cannot be 'Object' when targeting ES5 with module CommonJS
+    Object: true,
+    // TypeScript keywords that cannot be used for types (as opposed to variables)
+    bigint: true,
+    number: true,
+    boolean: true,
+    string: true,
+    object: true,
+    // Identifiers reserved for the runtime, so we can generate legible code
+    globalThis: true,
+    Uint8Array: true,
+    Partial: true,
+};
+// Names that cannot be used for object properties because they are reserved
+// by built-in JavaScript properties.
+const reservedObjectProperties = {
     // names reserved by JavaScript
     constructor: true,
     toString: true,
     toJSON: true,
     valueOf: true,
+};
+// Names that cannot be used for object properties because they are reserved
+// by the runtime.
+const reservedMessageProperties = {
     // names reserved by the runtime
     getType: true,
     clone: true,

package/dist/esm/proto-int64.js

@@ -11,7 +11,8 @@
 // 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 { int64fromString, int64toString } from "./google/varint.js";
+import { assert } from "./private/assert.js";
+import { int64FromString, int64ToString, uInt64ToString, } from "./google/varint.js";
 function makeInt64Support() {
     const dv = new DataView(new ArrayBuffer(8));
     // note that Safari 14 implements BigInt, but not the DataView methods
@@ -19,7 +20,10 @@ function makeInt64Support() {
         typeof dv.getBigInt64 === "function" &&
         typeof dv.getBigUint64 === "function" &&
         typeof dv.setBigInt64 === "function" &&
-        typeof dv.setBigUint64 === "function";
+        typeof dv.setBigUint64 === "function" &&
+        (typeof process != "object" ||
+            typeof process.env != "object" ||
+            process.env.BUF_BIGINT_DISABLE !== "1");
     if (ok) {
         const MIN = BigInt("-9223372036854775808"), MAX = BigInt("9223372036854775807"), UMIN = BigInt("0"), UMAX = BigInt("18446744073709551615");
         return {
@@ -65,65 +69,44 @@ function makeInt64Support() {
             },
         };
     }
+    const assertInt64String = (value) => assert(/^-?[0-9]+$/.test(value), `int64 invalid: ${value}`);
+    const assertUInt64String = (value) => assert(/^[0-9]+$/.test(value), `uint64 invalid: ${value}`);
     return {
         zero: "0",
         supported: false,
         parse(value) {
-            if (!/^-?[0-9]+$/.test(value)) {
-                throw new Error(`int64 invalid: ${value}`);
+            if (typeof value != "string") {
+                value = value.toString();
             }
+            assertInt64String(value);
             return value;
         },
         uParse(value) {
-            if (!/^-?[0-9]+$/.test(value)) {
-                throw new Error(`uint64 invalid: ${value}`);
+            if (typeof value != "string") {
+                value = value.toString();
             }
+            assertUInt64String(value);
             return value;
         },
         enc(value) {
-            if (typeof value == "string") {
-                if (!/^-?[0-9]+$/.test(value)) {
-                    throw new Error(`int64 invalid: ${value}`);
-                }
-            }
-            else {
-                value = value.toString(10);
+            if (typeof value != "string") {
+                value = value.toString();
             }
-            const [, lo, hi] = int64fromString(value);
-            return { lo, hi };
+            assertInt64String(value);
+            return int64FromString(value);
         },
         uEnc(value) {
-            if (typeof value == "string") {
-                if (!/^-?[0-9]+$/.test(value)) {
-                    throw new Error(`uint64 invalid: ${value}`);
-                }
+            if (typeof value != "string") {
+                value = value.toString();
             }
-            else {
-                value = value.toString(10);
-            }
-            const [minus, lo, hi] = int64fromString(value);
-            if (minus) {
-                throw new Error(`uint64 invalid: ${value}`);
-            }
-            return { lo, hi };
+            assertUInt64String(value);
+            return int64FromString(value);
         },
         dec(lo, hi) {
-            const minus = (hi & 0x80000000) !== 0;
-            if (minus) {
-                // negate
-                hi = ~hi;
-                if (lo) {
-                    lo = ~lo + 1;
-                }
-                else {
-                    hi += 1;
-                }
-                return ("-" + int64toString(lo, hi));
-            }
-            return int64toString(lo, hi);
+            return int64ToString(lo, hi);
         },
         uDec(lo, hi) {
-            return int64toString(lo, hi);
+            return uInt64ToString(lo, hi);
         },
     };
 }

package/dist/esm/proto2.js

@@ -16,7 +16,7 @@ import { makeBinaryFormatProto2 } from "./private/binary-format-proto2.js";
 import { makeUtilCommon } from "./private/util-common.js";
 import { InternalFieldList } from "./private/field-list.js";
 import { InternalOneofInfo } from "./private/field.js";
-import { makeFieldName, makeJsonName } from "./private/names.js";
+import { localFieldName, fieldJsonName } from "./private/names.js";
 import { makeJsonFormatProto2 } from "./private/json-format-proto2.js";
 /**
  * Provides functionality for messages defined with the proto2 syntax.
@@ -60,8 +60,8 @@ function normalizeFieldInfosProto2(fieldInfos) {
         ? fieldInfos()
         : fieldInfos) {
         const f = field;
-        f.localName = makeFieldName(field.name, field.oneof !== undefined);
-        f.jsonName = (_a = field.jsonName) !== null && _a !== void 0 ? _a : makeJsonName(field.name);
+        f.localName = localFieldName(field.name, field.oneof !== undefined);
+        f.jsonName = (_a = field.jsonName) !== null && _a !== void 0 ? _a : fieldJsonName(field.name);
         f.repeated = (_b = field.repeated) !== null && _b !== void 0 ? _b : false;
         // In contrast to proto3, repeated fields are unpacked except when explicitly specified.
         f.packed = (_c = field.packed) !== null && _c !== void 0 ? _c : false;

package/dist/esm/proto3.js

@@ -19,7 +19,7 @@ import { InternalFieldList } from "./private/field-list.js";
 import { scalarDefaultValue } from "./private/scalars.js";
 import { ScalarType } from "./field.js";
 import { InternalOneofInfo } from "./private/field.js";
-import { makeFieldName, makeJsonName } from "./private/names.js";
+import { localFieldName, fieldJsonName } from "./private/names.js";
 /**
  * Provides functionality for messages defined with the proto3 syntax.
  */
@@ -64,8 +64,8 @@ function normalizeFieldInfosProto3(fieldInfos) {
         ? fieldInfos()
         : fieldInfos) {
         const f = field;
-        f.localName = makeFieldName(field.name, field.oneof !== undefined);
-        f.jsonName = (_a = field.jsonName) !== null && _a !== void 0 ? _a : makeJsonName(field.name);
+        f.localName = localFieldName(field.name, field.oneof !== undefined);
+        f.jsonName = (_a = field.jsonName) !== null && _a !== void 0 ? _a : fieldJsonName(field.name);
         f.repeated = (_b = field.repeated) !== null && _b !== void 0 ? _b : false;
         // From the proto3 language guide:
         // > In proto3, repeated fields of scalar numeric types are packed by default.

package/dist/esm/type-registry.js

@@ -11,88 +11,4 @@
 // 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.
-/**
- * TypeRegistry is a simple registry for all message, enum, or service types.
- */
-export class TypeRegistry {
-    constructor() {
-        this.messages = {};
-        this.enums = {};
-        this.services = {};
-    }
-    /**
-     * Find a message type by its protobuf type name.
-     */
-    findMessage(typeName) {
-        return this.messages[typeName];
-    }
-    /**
-     * Find an enum type by its protobuf type name.
-     */
-    findEnum(typeName) {
-        return this.enums[typeName];
-    }
-    /**
-     * Find a service type by its protobuf type name.
-     */
-    findService(typeName) {
-        return this.services[typeName];
-    }
-    /**
-     * Create a new TypeRegistry from the given types.
-     */
-    static from(...types) {
-        const registry = new TypeRegistry();
-        for (const type of types) {
-            registry.add(type);
-        }
-        return registry;
-    }
-    /**
-     * @deprecated use TypeRegistry.from()
-     */
-    static fromIterable(types) {
-        return TypeRegistry.from(...types);
-    }
-    /**
-     * @deprecated use TypeRegistry.from()
-     */
-    static fromTypes(...types) {
-        return TypeRegistry.from(...types);
-    }
-    /**
-     * Add a type to the registry. For messages, the types used in message
-     * fields are added recursively. For services, the message types used
-     * for requests and responses are added recursively.
-     */
-    add(type) {
-        if ("fields" in type) {
-            if (!this.findMessage(type.typeName)) {
-                this.messages[type.typeName] = type;
-                for (const field of type.fields.list()) {
-                    if (field.kind == "message") {
-                        this.add(field.T);
-                    }
-                    else if (field.kind == "map" && field.V.kind == "message") {
-                        this.add(field.V.T);
-                    }
-                    else if (field.kind == "enum") {
-                        this.add(field.T);
-                    }
-                }
-            }
-        }
-        else if ("methods" in type) {
-            if (!this.findService(type.typeName)) {
-                this.services[type.typeName] = type;
-                for (const method of Object.values(type.methods)) {
-                    this.add(method.I);
-                    this.add(method.O);
-                }
-            }
-        }
-        else {
-            this.enums[type.typeName] = type;
-        }
-    }
-}
+export {};

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

@@ -0,0 +1,19 @@
+import { localName } from "./private/names.js";
+import { getUnwrappedFieldType } from "./private/field-wrapper.js";
+import { scalarDefaultValue } from "./private/scalars.js";
+interface CodegenInfo {
+    readonly packageName: string;
+    readonly localName: typeof localName;
+    readonly symbols: Record<RuntimeSymbolName, RuntimeSymbolInfo>;
+    readonly getUnwrappedFieldType: typeof getUnwrappedFieldType;
+    readonly wktSourceFiles: readonly string[];
+    readonly scalarDefaultValue: typeof scalarDefaultValue;
+}
+declare type RuntimeSymbolName = "proto2" | "proto3" | "Message" | "PartialMessage" | "PlainMessage" | "FieldList" | "MessageType" | "BinaryReadOptions" | "BinaryWriteOptions" | "JsonReadOptions" | "JsonWriteOptions" | "JsonValue" | "JsonObject" | "protoInt64" | "ScalarType" | "MethodKind" | "MethodIdempotency";
+declare type RuntimeSymbolInfo = {
+    typeOnly: boolean;
+    publicImportPath: string;
+    privateImportPath: string;
+};
+export declare const codegenInfo: CodegenInfo;
+export {};