@aptre/protobuf-es-lite 0.2.7 → 0.2.9

package/dist/protoplugin/ecmascript/runtime-imports.js

@@ -0,0 +1,28 @@
+"use strict";
+// Copyright 2021-2024 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRuntimeImports = void 0;
+const import_symbol_js_1 = require("./import-symbol.js");
+const codegen_info_js_1 = require("../../codegen-info.js");
+function createRuntimeImports(bootstrapWkt) {
+    const imports = {};
+    for (const [name, info] of Object.entries(codegen_info_js_1.codegenInfo.symbols)) {
+        const symbol = (0, import_symbol_js_1.createImportSymbol)(name, bootstrapWkt ? info.privateImportPath : info.publicImportPath);
+        imports[name] =
+            info.typeOnly ? symbol.toTypeOnly() : symbol;
+    }
+    return imports;
+}
+exports.createRuntimeImports = createRuntimeImports;

package/dist/protoplugin/ecmascript/schema.d.ts

@@ -0,0 +1,43 @@
+import type { FileInfo, GeneratedFile } from "./generated-file.js";
+import type { RuntimeImports } from "./runtime-imports.js";
+import type { Target } from "./target.js";
+import type { ParsedParameter } from "./parameter.js";
+import { DescFile } from "../../descriptor-set.js";
+import { CodeGeneratorRequest } from "../../google/protobuf/compiler/plugin.pb.js";
+import { FeatureSetDefaults } from "../../google/protobuf/descriptor.pb.js";
+/**
+ * Schema describes the files and types that the plugin is requested to
+ * generate.
+ */
+export interface Schema {
+    /**
+     * The files we are asked to generate.
+     */
+    readonly files: readonly DescFile[];
+    /**
+     * All files contained in the code generator request.
+     */
+    readonly allFiles: readonly DescFile[];
+    /**
+     * The plugin option `target`. A code generator should support all targets.
+     */
+    readonly targets: readonly Target[];
+    /**
+     * Provides some symbols from the runtime library.
+     */
+    readonly runtime: RuntimeImports;
+    /**
+     * Generate a new file with the given name.
+     */
+    generateFile(name: string): GeneratedFile;
+    /**
+     * The original google.protobuf.compiler.CodeGeneratorRequest.
+     */
+    readonly proto: CodeGeneratorRequest;
+}
+interface SchemaController extends Schema {
+    getFileInfo: () => FileInfo[];
+    prepareGenerate(target: Target): void;
+}
+export declare function createSchema(request: CodeGeneratorRequest, parameter: ParsedParameter, pluginName: string, pluginVersion: string, featureSetDefaults: FeatureSetDefaults | undefined): SchemaController;
+export {};

package/dist/protoplugin/ecmascript/schema.js

@@ -0,0 +1,73 @@
+"use strict";
+// Copyright 2021-2024 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSchema = void 0;
+const generated_file_js_1 = require("./generated-file.js");
+const runtime_imports_js_1 = require("./runtime-imports.js");
+const import_symbol_js_1 = require("./import-symbol.js");
+const import_path_js_1 = require("./import-path.js");
+const file_preamble_js_1 = require("./file-preamble.js");
+const create_descriptor_set_js_1 = require("../../create-descriptor-set.js");
+const codegen_info_js_1 = require("../../codegen-info.js");
+function createSchema(request, parameter, pluginName, pluginVersion, featureSetDefaults) {
+    if (!request.protoFile) {
+        throw new Error("no protoFile passed to createSchema");
+    }
+    const descriptorSet = (0, create_descriptor_set_js_1.createDescriptorSet)(request.protoFile, {
+        featureSetDefaults,
+    });
+    const filesToGenerate = findFilesToGenerate(descriptorSet, request);
+    const runtime = (0, runtime_imports_js_1.createRuntimeImports)(parameter.bootstrapWkt);
+    const createTypeImport = (desc) => {
+        const name = codegen_info_js_1.codegenInfo.localName(desc);
+        const from = (0, import_path_js_1.makeImportPath)(desc.file, parameter.bootstrapWkt, filesToGenerate);
+        return (0, import_symbol_js_1.createImportSymbol)(name, from);
+    };
+    const createPreamble = (descFile) => (0, file_preamble_js_1.makeFilePreamble)(descFile, pluginName, pluginVersion, parameter.sanitizedParameter, parameter.tsNocheck);
+    let target;
+    const generatedFiles = [];
+    return {
+        targets: parameter.targets,
+        runtime,
+        proto: request,
+        files: filesToGenerate,
+        allFiles: descriptorSet.files,
+        generateFile(name) {
+            if (target === undefined) {
+                throw new Error("prepareGenerate() must be called before generateFile()");
+            }
+            const genFile = (0, generated_file_js_1.createGeneratedFile)(name, (0, import_path_js_1.deriveImportPath)(name), target === "js" ? parameter.jsImportStyle : "module", // ts and dts always use import/export, only js may use commonjs
+            (importPath) => (0, import_path_js_1.rewriteImportPath)(importPath, parameter.rewriteImports, parameter.importExtension), createTypeImport, runtime, createPreamble);
+            generatedFiles.push(genFile);
+            return genFile;
+        },
+        getFileInfo() {
+            return generatedFiles
+                .map((f) => f.getFileInfo())
+                .filter((fi) => parameter.keepEmptyFiles || fi.content.length > 0);
+        },
+        prepareGenerate(newTarget) {
+            target = newTarget;
+        },
+    };
+}
+exports.createSchema = createSchema;
+function findFilesToGenerate(descriptorSet, request) {
+    const missing = request.fileToGenerate?.filter((fileToGenerate) => descriptorSet.files.every((file) => fileToGenerate !== file.name + ".proto")) ?? [];
+    if (missing.length) {
+        throw `files_to_generate missing in the request: ${missing.join(", ")}`;
+    }
+    return descriptorSet.files.filter((file) => request.fileToGenerate?.includes(file.name + ".proto") ?? false);
+}

package/dist/protoplugin/ecmascript/target.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Represents possible values of the plugin option `target`.
+ */
+export type Target = "js" | "ts" | "dts";

package/dist/protoplugin/ecmascript/target.js

@@ -0,0 +1,15 @@
+"use strict";
+// Copyright 2021-2024 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.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/protoplugin/ecmascript/transpile.d.ts

@@ -0,0 +1,2 @@
+import type { FileInfo } from "./generated-file.js";
+export declare function transpile(files: FileInfo[], transpileJs: boolean, transpileDts: boolean, jsImportStyle: "module" | "legacy_commonjs"): FileInfo[];

package/dist/protoplugin/ecmascript/transpile.js

@@ -0,0 +1,149 @@
+"use strict";
+// Copyright 2021-2024 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.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transpile = void 0;
+const typescript_1 = __importStar(require("typescript"));
+const vfs_1 = require("@typescript/vfs");
+/* eslint-disable import/no-named-as-default-member */
+// The default options used to auto-transpile if needed.
+const defaultOptions = {
+    // Type checking
+    strict: false,
+    // modules
+    module: typescript_1.default.ModuleKind.ES2020,
+    moduleResolution: typescript_1.default.ModuleResolutionKind.Node16,
+    noResolve: true,
+    resolveJsonModule: false,
+    // emit
+    emitBOM: false,
+    importsNotUsedAsValues: typescript_1.default.ImportsNotUsedAsValues.Preserve,
+    newLine: typescript_1.default.NewLineKind.LineFeed,
+    preserveValueImports: false,
+    // JavaScript Support
+    allowJs: true,
+    checkJs: false,
+    // Language and Environment
+    lib: [],
+    moduleDetection: typescript_1.ModuleDetectionKind.Force,
+    target: typescript_1.default.ScriptTarget.ES2020,
+    // Completeness
+    skipLibCheck: true,
+    skipDefaultLibCheck: false,
+};
+/**
+ * Create a transpiler using the given compiler options, which will compile the
+ * content provided in the files array.
+ *
+ * Note:  this library intentionally transpiles with a pinned older version of
+ * TypeScript for stability.  This version is denoted in this workspace's
+ * package.json.  For the default set of compiler options, we use a lenient
+ * set of options because the general goal is to emit code as best as we can.
+ * For a list of the options used, see `defaultOptions` above.
+ *
+ * If this is not desirable for plugin authors, they are free to provide their
+ * own transpile function as part of the plugin initialization.  If one is
+ * provided, it will be invoked instead and the framework's auto-transpilation
+ * will be bypassed.
+ *
+ * In addition, note that there is a dependency on @typescript/vfs in the
+ * top-level package as well as this package.  This is to avoid npm hoisting
+ * @typescript/vfs to the top-level node_modules directory, which then causes
+ * type mismatches when trying to use it with this package's version of
+ * TypeScript.  Ideally we would use something like Yarn's nohoist here, but
+ * npm does not support that yet.
+ */
+function createTranspiler(options, files) {
+    const fsMap = (0, vfs_1.createDefaultMapFromNodeModules)({
+        target: options.target,
+    });
+    files.forEach((file) => {
+        fsMap.set(file.name, file.content);
+    });
+    const system = (0, vfs_1.createSystem)(fsMap);
+    const host = (0, vfs_1.createVirtualCompilerHost)(system, options, typescript_1.default);
+    return typescript_1.default.createProgram({
+        rootNames: [...fsMap.keys()],
+        options,
+        host: host.compilerHost,
+    });
+}
+function transpile(files, transpileJs, transpileDts, jsImportStyle) {
+    const options = {
+        ...defaultOptions,
+        declaration: transpileDts,
+        emitDeclarationOnly: transpileDts && !transpileJs,
+    };
+    if (jsImportStyle == "legacy_commonjs") {
+        options.module = typescript_1.default.ModuleKind.CommonJS;
+    }
+    // Create the transpiler (a ts.Program object)
+    const program = createTranspiler(options, files);
+    const results = [];
+    let err;
+    const result = program.emit(undefined, (fileName, data, writeByteOrderMark, onError, sourceFiles) => {
+        // We have to go through some hoops here because the header we add to each
+        // file is not part of the AST. So we find the TypeScript file we
+        // generated for each emitted file and add the header to each output ourselves.
+        if (!sourceFiles) {
+            err = new Error(`unable to map emitted file "${fileName}" to a source file: missing source files`);
+            return;
+        }
+        if (sourceFiles.length !== 1) {
+            err = new Error(`unable to map emitted file "${fileName}" to a source file: expected 1 source file, got ${sourceFiles.length}`);
+            return;
+        }
+        const file = files.find((x) => sourceFiles[0].fileName === x.name);
+        if (!file) {
+            err = new Error(`unable to map emitted file "${fileName}" to a source file: not found`);
+            return;
+        }
+        results.push({
+            name: fileName,
+            preamble: file.preamble,
+            content: data,
+        });
+    });
+    if (err) {
+        throw err;
+    }
+    if (result.emitSkipped) {
+        throw Error("A problem occurred during transpilation and files were not generated.  Contact the plugin author for support.");
+    }
+    return results;
+}
+exports.transpile = transpile;

package/dist/protoplugin/error.d.ts

@@ -0,0 +1,6 @@
+export declare class PluginOptionError extends Error {
+    name: string;
+    constructor(option: string, reason?: unknown);
+}
+export declare function reasonToString(reason: unknown): string;
+export declare function isPluginOptionError(arg: unknown): arg is PluginOptionError;

package/dist/protoplugin/error.js

@@ -0,0 +1,43 @@
+"use strict";
+// Copyright 2021-2024 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPluginOptionError = exports.reasonToString = exports.PluginOptionError = void 0;
+class PluginOptionError extends Error {
+    constructor(option, reason) {
+        const detail = reason !== undefined ? reasonToString(reason) : "";
+        super(detail.length > 0 ?
+            `invalid option "${option}": ${detail}`
+            : `invalid option "${option}"`);
+        this.name = "PluginOptionError";
+    }
+}
+exports.PluginOptionError = PluginOptionError;
+function reasonToString(reason) {
+    if (reason instanceof Error) {
+        return reason.message;
+    }
+    if (typeof reason === "string") {
+        return reason;
+    }
+    return String(reason);
+}
+exports.reasonToString = reasonToString;
+function isPluginOptionError(arg) {
+    if (!(arg instanceof Error)) {
+        return false;
+    }
+    return arg.name === "PluginOptionError";
+}
+exports.isPluginOptionError = isPluginOptionError;

package/dist/protoplugin/index.d.ts

@@ -0,0 +1,8 @@
+import type { Schema as SchemaInternal } from "./ecmascript/schema.js";
+export type { Plugin } from "./plugin.js";
+export { runNodeJs } from "./run-node.js";
+export { createEcmaScriptPlugin } from "./create-es-plugin.js";
+/**
+ * @deprecated Please use Schema from @bufbuild/protoplugin/ecmascript instead
+ */
+export type Schema = SchemaInternal;

package/dist/protoplugin/index.js

@@ -0,0 +1,20 @@
+"use strict";
+// Copyright 2021-2024 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEcmaScriptPlugin = exports.runNodeJs = void 0;
+var run_node_js_1 = require("./run-node.js");
+Object.defineProperty(exports, "runNodeJs", { enumerable: true, get: function () { return run_node_js_1.runNodeJs; } });
+var create_es_plugin_js_1 = require("./create-es-plugin.js");
+Object.defineProperty(exports, "createEcmaScriptPlugin", { enumerable: true, get: function () { return create_es_plugin_js_1.createEcmaScriptPlugin; } });

package/dist/protoplugin/plugin.d.ts

@@ -0,0 +1,18 @@
+import { CodeGeneratorRequest, CodeGeneratorResponse } from "../google/protobuf/compiler/plugin.pb.js";
+/**
+ * Represents any code generator plugin.
+ */
+export interface Plugin {
+    /**
+     * Name of this code generator plugin.
+     */
+    name: string;
+    /**
+     * Version of this code generator plugin.
+     */
+    version: string;
+    /**
+     * Run this plugin for the given request.
+     */
+    run(request: CodeGeneratorRequest): CodeGeneratorResponse;
+}

package/dist/protoplugin/plugin.js

@@ -0,0 +1,15 @@
+"use strict";
+// Copyright 2021-2024 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.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/protoplugin/run-node.d.ts

@@ -0,0 +1,12 @@
+import type { Plugin } from "./plugin.js";
+/**
+ * Run a plugin with Node.js.
+ *
+ * ```
+ * #!/usr/bin/env node
+ * const {runNodeJs} = require("@bufbuild/protoplugin");
+ * const {myPlugin} = require("./protoc-gen-x-plugin.js");
+ * runNodeJs(myPlugin);
+ * ```
+ */
+export declare function runNodeJs(plugin: Plugin): void;

package/dist/protoplugin/run-node.js

@@ -0,0 +1,83 @@
+"use strict";
+// Copyright 2021-2024 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runNodeJs = void 0;
+const error_js_1 = require("./error.js");
+const plugin_pb_js_1 = require("../google/protobuf/compiler/plugin.pb.js");
+/**
+ * Run a plugin with Node.js.
+ *
+ * ```
+ * #!/usr/bin/env node
+ * const {runNodeJs} = require("@bufbuild/protoplugin");
+ * const {myPlugin} = require("./protoc-gen-x-plugin.js");
+ * runNodeJs(myPlugin);
+ * ```
+ */
+function runNodeJs(plugin) {
+    const args = process.argv.slice(2);
+    if ((args.length === 1 && args[0] === "-v") || args[0] === "--version") {
+        process.stdout.write(`${plugin.name} ${plugin.version}\n`);
+        process.exit(0);
+    }
+    if (args.length !== 0) {
+        process.stderr.write(`${plugin.name} accepts a google.protobuf.compiler.CodeGeneratorRequest on stdin and writes a CodeGeneratorResponse to stdout\n`);
+        process.exit(1);
+    }
+    readBytes(process.stdin)
+        .then((data) => {
+        const req = plugin_pb_js_1.CodeGeneratorRequest.fromBinary(data);
+        const res = plugin.run(req);
+        return writeBytes(process.stdout, plugin_pb_js_1.CodeGeneratorResponse.toBinary(res));
+    })
+        .then(() => process.exit(0))
+        .catch((reason) => {
+        const message = (0, error_js_1.isPluginOptionError)(reason) ? reason.message : (0, error_js_1.reasonToString)(reason);
+        process.stderr.write(`${plugin.name}: ${message}\n`);
+        process.exit(1);
+        return;
+    });
+}
+exports.runNodeJs = runNodeJs;
+/**
+ * Read a stream to the end.
+ */
+function readBytes(stream) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        stream.on("data", (chunk) => chunks.push(chunk));
+        stream.on("end", () => {
+            resolve(Buffer.concat(chunks));
+        });
+        stream.on("error", (err) => {
+            reject(err);
+        });
+    });
+}
+/**
+ * Write a chunk of bytes to a stream.
+ */
+function writeBytes(stream, data) {
+    return new Promise((resolve, reject) => {
+        stream.write(data, (err) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve();
+            }
+        });
+    });
+}

package/dist/scalar.d.ts

@@ -1,4 +1,56 @@
-import { LongType, ScalarType, ScalarValue } from "@bufbuild/protobuf";
+/**
+ * Scalar value types. This is a subset of field types declared by protobuf
+ * enum google.protobuf.FieldDescriptorProto.Type The types GROUP and MESSAGE
+ * are omitted, but the numerical values are identical.
+ */
+export declare enum ScalarType {
+    DOUBLE = 1,
+    FLOAT = 2,
+    INT64 = 3,
+    UINT64 = 4,
+    INT32 = 5,
+    FIXED64 = 6,
+    FIXED32 = 7,
+    BOOL = 8,
+    STRING = 9,
+    BYTES = 12,
+    UINT32 = 13,
+    SFIXED32 = 15,
+    SFIXED64 = 16,
+    SINT32 = 17,// Uses ZigZag encoding.
+    SINT64 = 18
+}
+/**
+ * JavaScript representation of fields with 64 bit integral types (int64, uint64,
+ * sint64, fixed64, sfixed64).
+ *
+ * This is a subset of google.protobuf.FieldOptions.JSType, which defines JS_NORMAL,
+ * JS_STRING, and JS_NUMBER. Protobuf-ES uses BigInt by default, but will use
+ * String if `[jstype = JS_STRING]` is specified.
+ *
+ * ```protobuf
+ * uint64 field_a = 1; // BigInt
+ * uint64 field_b = 2 [jstype = JS_NORMAL]; // BigInt
+ * uint64 field_b = 2 [jstype = JS_NUMBER]; // BigInt
+ * uint64 field_b = 2 [jstype = JS_STRING]; // String
+ * ```
+ */
+export declare enum LongType {
+    /**
+     * Use JavaScript BigInt.
+     */
+    BIGINT = 0,
+    /**
+     * Use JavaScript String.
+     *
+     * Field option `[jstype = JS_STRING]`.
+     */
+    STRING = 1
+}
+/**
+ * ScalarValue maps from a scalar field type to a TypeScript value type.
+ */
+export type ScalarValue<T = ScalarType, L extends LongType = LongType.STRING | LongType.BIGINT> = T extends ScalarType.STRING ? string : T extends ScalarType.INT32 ? number : T extends ScalarType.UINT32 ? number : T extends ScalarType.UINT32 ? number : T extends ScalarType.SINT32 ? number : T extends ScalarType.FIXED32 ? number : T extends ScalarType.SFIXED32 ? number : T extends ScalarType.FLOAT ? number : T extends ScalarType.DOUBLE ? number : T extends ScalarType.INT64 ? (L extends LongType.STRING ? string : bigint) : T extends ScalarType.SINT64 ? (L extends LongType.STRING ? string : bigint) : T extends ScalarType.SFIXED64 ? (L extends LongType.STRING ? string : bigint) : T extends ScalarType.UINT64 ? (L extends LongType.STRING ? string : bigint) : T extends ScalarType.FIXED64 ? (L extends LongType.STRING ? string : bigint) : T extends ScalarType.BOOL ? boolean : T extends ScalarType.BYTES ? Uint8Array : never;
 /**
  * Returns true if both scalar values are equal.
  */