@aptre/protobuf-es-lite 0.2.6 → 0.2.8

package/dist/{typescript.js → protoc-gen-es-lite/typescript.js}

@@ -14,25 +14,20 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFieldInfoLiteral = exports.createTypeImport = exports.generateFieldInfo = exports.makeImportPath = exports.generateTs = void 0;
-const protobuf_1 = require("@bufbuild/protobuf");
-const ecmascript_1 = require("@bufbuild/protoplugin/ecmascript");
-const editions_js_1 = require("./editions.js");
-const util_js_1 = require("./util.js");
-const libPkg = "@aptre/protobuf-es-lite";
-const MessageImport = (0, ecmascript_1.createImportSymbol)("Message", libPkg);
-const MessageTypeImport = (0, ecmascript_1.createImportSymbol)("MessageType", libPkg);
-const CreateMessageTypeImport = (0, ecmascript_1.createImportSymbol)("createMessageType", libPkg);
-const PartialFieldInfo = (0, ecmascript_1.createImportSymbol)("PartialFieldInfo", libPkg);
-const CreateEnumTypeImport = (0, ecmascript_1.createImportSymbol)("createEnumType", libPkg);
+exports.getFieldInfoLiteral = exports.createTypeImport = exports.generateFieldInfo = exports.makeImportPath = exports.checkSupportedSyntax = exports.generateTs = void 0;
+const index_js_1 = require("../protoplugin/ecmascript/index.js");
+const util_js_1 = require("../util.js");
+const names_js_1 = require("../names.js");
+const scalar_js_1 = require("../scalar.js");
+const descriptor_pb_js_1 = require("../google/protobuf/descriptor.pb.js");
 function generateTs(schema) {
     for (const file of schema.files) {
-        const f = schema.generateFile(file.name + "_pb.ts");
+        const f = schema.generateFile(file.name + ".pb.ts");
         f.preamble(file);
         f.print(`export const protobufPackage = "${file.proto.package}";`);
         f.print();
         for (const enumeration of file.enums) {
-            generateEnum(f, enumeration);
+            generateEnum(schema, f, enumeration);
         }
         const messageTypes = [];
         const dependencies = new Map();
@@ -41,7 +36,7 @@ function generateTs(schema) {
                 return;
             }
             for (const nestedEnum of message.nestedEnums) {
-                generateEnum(f, nestedEnum);
+                generateEnum(schema, f, nestedEnum);
             }
             messageTypes.push(message);
             const deps = new Set();
@@ -90,7 +85,7 @@ function topologicalSort(messages, dependencies) {
     }
     return result;
 }
-function generateEnum(f, enumeration) {
+function generateEnum(schema, f, enumeration) {
     f.print(f.jsDoc(enumeration));
     f.print(f.exportDecl("enum", enumeration), " {");
     for (const value of enumeration.values) {
@@ -98,23 +93,40 @@ function generateEnum(f, enumeration) {
             f.print();
         }
         f.print(f.jsDoc(value, "  "));
-        f.print("  ", (0, ecmascript_1.localName)(value), " = ", value.number, ",");
+        f.print("  ", (0, names_js_1.localName)(value), " = ", value.number, ",");
     }
     f.print("}");
     f.print();
     f.print("// ", enumeration, "_Enum is the enum type for ", enumeration, ".");
-    f.print(f.exportDecl("const", enumeration.name + "_Enum"), " = ", CreateEnumTypeImport, "(", f.string(enumeration.typeName), ", [");
+    f.print(f.exportDecl("const", enumeration), "_Enum", " = ", schema.runtime.createEnumType, "(", f.string(enumeration.typeName), ", [");
     for (const value of enumeration.values) {
         f.print("  { no: ", value.number, ', name: "', value.name, '" },');
     }
     f.print("]);");
     f.print();
 }
+function checkSupportedSyntax(file) {
+    if (file.syntax === "editions") {
+        throw new Error(`${file.proto.name ?? ""}: syntax "editions" is not supported`);
+    }
+}
+exports.checkSupportedSyntax = checkSupportedSyntax;
 function generateMessage(schema, f, message) {
     // check if we support this runtime
-    (0, editions_js_1.getNonEditionRuntime)(schema, message.file);
+    checkSupportedSyntax(message.file);
     f.print(f.jsDoc(message));
-    f.print(f.exportDecl("interface", message), " extends ", MessageImport, "<", message, "> {");
+    /*
+    f.print(
+      f.exportDecl("interface", message),
+      " extends ",
+      schema.runtime.Message,
+      "<",
+      message,
+      ">",
+      " {",
+    );
+    */
+    f.print(f.exportDecl("type", message), " = ", schema.runtime.Message, "<{");
     for (const field of message.fields) {
         generateField(f, field);
     }
@@ -122,16 +134,16 @@ function generateMessage(schema, f, message) {
         generateOneof(f, oneof);
     }
     f.print();
-    f.print("}");
+    f.print("}>;");
     f.print();
-    f.print(f.exportDecl("const", message), ": ", MessageTypeImport, "<", message, "> = ", CreateMessageTypeImport, "(");
+    f.print(f.exportDecl("const", message), ": ", schema.runtime.MessageType, "<", message, "> = ", schema.runtime.createMessageType, "(");
     f.print("  {");
     f.print("    typeName: ", f.string(message.typeName), ",");
     f.print("    fields: [");
     for (const field of message.fields) {
         generateFieldInfo(f, field);
     }
-    f.print("    ] as readonly ", PartialFieldInfo, "[],");
+    f.print("    ] as readonly ", schema.runtime.PartialFieldInfo, "[],");
     f.print("    packedByDefault: ", message.file.proto.syntax === "proto3", ",");
     f.print("  },");
     f.print(");");
@@ -143,7 +155,7 @@ function generateField(f, field) {
     }
     f.print(f.jsDoc(field, "  "));
     const { typing } = (0, util_js_1.getFieldTypeInfo)(field);
-    f.print("  ", (0, ecmascript_1.localName)(field), "?: ", typing, ";");
+    f.print("  ", (0, names_js_1.localName)(field), "?: ", typing, ";");
 }
 function generateOneof(f, oneof) {
     f.print();
@@ -158,7 +170,7 @@ function generateOneof(f, oneof) {
             `\n    value: `,
             typing,
             `;\n    case: "`,
-            (0, ecmascript_1.localName)(field),
+            (0, names_js_1.localName)(field),
             `";\n  }`,
         ];
     })
@@ -166,7 +178,7 @@ function generateOneof(f, oneof) {
     f.print("  ", oneof.name, "?: {\n    value?: undefined,\n    case: undefined\n  }", oneOfCases, ";");
 }
 function makeImportPath(file) {
-    return "./" + file.name + "_pb.js";
+    return "./" + file.name + ".pb.js";
 }
 exports.makeImportPath = makeImportPath;
 function generateFieldInfo(f, field) {
@@ -174,12 +186,12 @@ function generateFieldInfo(f, field) {
 }
 exports.generateFieldInfo = generateFieldInfo;
 const createTypeImport = (desc) => {
-    var name = (0, ecmascript_1.localName)(desc);
+    var name = (0, names_js_1.localName)(desc);
     if (desc.kind === "enum") {
         name += "_Enum";
     }
     const from = makeImportPath(desc.file);
-    return (0, ecmascript_1.createImportSymbol)(name, from);
+    return (0, index_js_1.createImportSymbol)(name, from);
 };
 exports.createTypeImport = createTypeImport;
 function getFieldInfoLiteral(field) {
@@ -193,19 +205,19 @@ function getFieldInfoLiteral(field) {
     }
     switch (field.fieldKind) {
         case "scalar":
-            e.push(`kind: "scalar", T: `, field.scalar, ` /* ScalarType.`, protobuf_1.ScalarType[field.scalar], ` */, `);
-            if (field.longType != protobuf_1.LongType.BIGINT) {
-                e.push(`L: `, field.longType, ` /* LongType.`, protobuf_1.LongType[field.longType], ` */, `);
+            e.push(`kind: "scalar", T: `, field.scalar, ` /* ScalarType.`, scalar_js_1.ScalarType[field.scalar], ` */, `);
+            if (field.longType != scalar_js_1.LongType.BIGINT) {
+                e.push(`L: `, field.longType, ` /* LongType.`, scalar_js_1.LongType[field.longType], ` */, `);
             }
             break;
         case "map":
-            e.push(`kind: "map", K: `, field.mapKey, ` /* ScalarType.`, protobuf_1.ScalarType[field.mapKey], ` */, `);
+            e.push(`kind: "map", K: `, field.mapKey, ` /* ScalarType.`, scalar_js_1.ScalarType[field.mapKey], ` */, `);
             switch (field.mapValue.kind) {
                 case "scalar":
-                    e.push(`V: {kind: "scalar", T: `, field.mapValue.scalar, ` /* ScalarType.`, protobuf_1.ScalarType[field.mapValue.scalar], ` */}, `);
+                    e.push(`V: {kind: "scalar", T: `, field.mapValue.scalar, ` /* ScalarType.`, scalar_js_1.ScalarType[field.mapValue.scalar], ` */}, `);
                     break;
                 case "message":
-                    e.push(`V: {kind: "message", T: `, field.mapValue.message, `}, `);
+                    e.push(`V: {kind: "message", T: () => `, field.mapValue.message, `}, `);
                     break;
                 case "enum":
                     e.push(`V: {kind: "enum", T: `, field.mapValue.enum, `}, `);
@@ -213,8 +225,8 @@ function getFieldInfoLiteral(field) {
             }
             break;
         case "message":
-            e.push(`kind: "message", T: `, field.message, `, `);
-            if (field.proto.type === protobuf_1.FieldDescriptorProto_Type.GROUP) {
+            e.push(`kind: "message", T: () => `, field.message, `, `);
+            if (field.proto.type === descriptor_pb_js_1.FieldDescriptorProto_Type.GROUP) {
                 e.push(`delimited: true, `);
             }
             break;
@@ -231,7 +243,7 @@ function getFieldInfoLiteral(field) {
     if (field.optional) {
         e.push(`opt: true, `);
     }
-    else if (field.proto.label === protobuf_1.FieldDescriptorProto_Label.REQUIRED) {
+    else if (field.proto.label === descriptor_pb_js_1.FieldDescriptorProto_Label.REQUIRED) {
         e.push(`req: true, `);
     }
     const defaultValue = (0, util_js_1.getFieldDefaultValueExpression)(field);

package/dist/protoplugin/create-es-plugin.d.ts

@@ -0,0 +1,83 @@
+import type { Schema } from "./ecmascript/schema.js";
+import type { FileInfo } from "./ecmascript/generated-file.js";
+import type { Plugin } from "./plugin.js";
+import { FeatureSetDefaults } from "../google/protobuf/descriptor.pb.js";
+interface PluginInit {
+    /**
+     * Name of this code generator plugin.
+     */
+    name: string;
+    /**
+     * Version of this code generator plugin.
+     */
+    version: string;
+    /**
+     * An optional parsing function which can be used to parse your own plugin
+     * options.
+     */
+    parseOption?: (key: string, value: string) => void;
+    /**
+     * Whether the plugin supports editions.
+     */
+    supportsEditions?: boolean;
+    /**
+     * By default, plugins support all editions supported by createDescriptorSet()
+     * if supportsEditions is enabled.
+     *
+     * This option can be used to limit support for specific editions, by providing
+     * your own google.protobuf.FeatureSetDefaults generated by protoc with the
+     * flags --experimental_edition_defaults_out, --experimental_edition_defaults_minimum,
+     * and --experimental_edition_defaults_maximum.
+     */
+    featureSetDefaults?: FeatureSetDefaults;
+    /**
+     * A function which will generate TypeScript files based on proto input.
+     * This function will be invoked by the plugin framework when the plugin runs.
+     *
+     * Note that this is required to be provided for plugin initialization.
+     */
+    generateTs: (schema: Schema, target: "ts") => void;
+    /**
+     * A optional function which will generate JavaScript files based on proto
+     * input.  This function will be invoked by the  plugin framework when the
+     * plugin runs.
+     *
+     * If this function is not provided, the plugin framework will then check if
+     * a transpile function is provided.  If so, it will be invoked to transpile
+     * JavaScript files.  If not, the plugin framework will transpile the files
+     * itself.
+     */
+    generateJs?: (schema: Schema, target: "js") => void;
+    /**
+     * A optional function which will generate TypeScript declaration files
+     * based on proto input.  This function will be invoked by the plugin
+     * framework when the plugin runs.
+     *
+     * If this function is not provided, the plugin framework will then check if
+     * a transpile function is provided.  If so, it will be invoked to transpile
+     * declaration files.  If not, the plugin framework will transpile the files
+     * itself.
+     */
+    generateDts?: (schema: Schema, target: "dts") => void;
+    /**
+     * An optional function which will transpile a given set of files.
+     *
+     * This function is meant to be used in place of either generateJs,
+     * generateDts, or both.  However, those functions will take precedence.
+     * This means that if generateJs, generateDts, and this transpile function
+     * are all provided, this transpile function will be ignored.
+     *
+     * If jsImportStyle is "module" (the standard behavior), the function is
+     * expected to use ECMAScript module import and export statements when
+     * transpiling to JS. If jsImportStyle is "legacy_commonjs", the function is
+     * expected to use CommonJs require() and exports when transpiling to JS.
+     */
+    transpile?: (files: FileInfo[], transpileJs: boolean, transpileDts: boolean, jsImportStyle: "module" | "legacy_commonjs") => FileInfo[];
+}
+/**
+ * Create a new code generator plugin for ECMAScript.
+ * The plugin can generate JavaScript, TypeScript, or TypeScript declaration
+ * files.
+ */
+export declare function createEcmaScriptPlugin(init: PluginInit): Plugin;
+export {};

package/dist/protoplugin/create-es-plugin.js

@@ -0,0 +1,119 @@
+"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 = void 0;
+const schema_js_1 = require("./ecmascript/schema.js");
+const transpile_js_1 = require("./ecmascript/transpile.js");
+const parameter_js_1 = require("./ecmascript/parameter.js");
+const plugin_pb_js_1 = require("../google/protobuf/compiler/plugin.pb.js");
+const proto_int64_js_1 = require("../proto-int64.js");
+/**
+ * Create a new code generator plugin for ECMAScript.
+ * The plugin can generate JavaScript, TypeScript, or TypeScript declaration
+ * files.
+ */
+function createEcmaScriptPlugin(init) {
+    let transpileJs = false;
+    let transpileDts = false;
+    return {
+        name: init.name,
+        version: init.version,
+        run(req) {
+            const parameter = (0, parameter_js_1.parseParameter)(req.parameter, init.parseOption);
+            const schema = (0, schema_js_1.createSchema)(req, parameter, init.name, init.version, init.featureSetDefaults);
+            const targetTs = schema.targets.includes("ts");
+            const targetJs = schema.targets.includes("js");
+            const targetDts = schema.targets.includes("dts");
+            // Generate TS files under the following conditions:
+            // - if they are explicitly specified as a target.
+            // - if js is specified as a target but no js generator is provided.
+            // - if dts is specified as a target, but no dts generator is provided.
+            // In the latter two cases, it is because we need the generated TS files
+            // to use for transpiling js and/or dts.
+            let tsFiles = [];
+            if (targetTs ||
+                (targetJs && !init.generateJs) ||
+                (targetDts && !init.generateDts)) {
+                schema.prepareGenerate("ts");
+                init.generateTs(schema, "ts");
+                // Save off the generated TypeScript files so that we can pass these
+                // to the transpilation process if necessary.  We do not want to pass
+                // JavaScript files for a few reasons:
+                // 1.  Our usage of allowJs in the compiler options will cause issues
+                // with attempting to transpile .ts and .js files to the same location.
+                // 2.  There should be no reason to transpile JS because generateTs
+                // functions are required, so users would never be able to only specify
+                // a generateJs function and expect to transpile declarations.
+                // 3.  Transpiling is somewhat expensive and situations with an
+                // extremely large amount of files could have performance impacts.
+                tsFiles = schema.getFileInfo();
+            }
+            if (targetJs) {
+                if (init.generateJs) {
+                    schema.prepareGenerate("js");
+                    init.generateJs(schema, "js");
+                }
+                else {
+                    transpileJs = true;
+                }
+            }
+            if (targetDts) {
+                if (init.generateDts) {
+                    schema.prepareGenerate("dts");
+                    init.generateDts(schema, "dts");
+                }
+                else {
+                    transpileDts = true;
+                }
+            }
+            // Get generated files.  If ts was specified as a target, then we want
+            // all generated files.  If ts was not specified, we still may have
+            // generated TypeScript files to assist in transpilation.  If they were
+            // generated but not specified in the target out, we shouldn't produce
+            // these files in the CodeGeneratorResponse.
+            let files = schema.getFileInfo();
+            if (!targetTs && tsFiles.length > 0) {
+                files = files.filter((file) => !tsFiles.some((tsFile) => tsFile.name === file.name));
+            }
+            // If either boolean is true, it means it was specified in the target out
+            // but no generate function was provided.  This also means that we will
+            // have generated .ts files above.
+            if (transpileJs || transpileDts) {
+                const transpileFn = init.transpile ?? transpile_js_1.transpile;
+                // Transpile the TypeScript files and add to the master list of files
+                const transpiledFiles = transpileFn(tsFiles, transpileJs, transpileDts, parameter.jsImportStyle);
+                files.push(...transpiledFiles);
+            }
+            return toResponse(files, init.supportsEditions ?? false);
+        },
+    };
+}
+exports.createEcmaScriptPlugin = createEcmaScriptPlugin;
+function toResponse(files, supportsEditions) {
+    let supportedFeatures = plugin_pb_js_1.CodeGeneratorResponse_Feature.PROTO3_OPTIONAL;
+    if (supportsEditions) {
+        supportedFeatures =
+            supportedFeatures | plugin_pb_js_1.CodeGeneratorResponse_Feature.SUPPORTS_EDITIONS;
+    }
+    return plugin_pb_js_1.CodeGeneratorResponse.create({
+        supportedFeatures: proto_int64_js_1.protoInt64.parse(supportedFeatures),
+        file: files.map((f) => {
+            if (f.preamble !== undefined) {
+                f.content = f.preamble + "\n" + f.content;
+            }
+            return f;
+        }),
+    });
+}

package/dist/protoplugin/ecmascript/file-preamble.d.ts

@@ -0,0 +1,2 @@
+import { DescFile } from "../../descriptor-set.js";
+export declare function makeFilePreamble(file: DescFile, pluginName: string, pluginVersion: string, parameter: string, tsNoCheck: boolean): string;

package/dist/protoplugin/ecmascript/file-preamble.js

@@ -0,0 +1,74 @@
+"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.makeFilePreamble = void 0;
+const descriptor_pb_js_1 = require("../../google/protobuf/descriptor.pb.js");
+function makeFilePreamble(file, pluginName, pluginVersion, parameter, tsNoCheck) {
+    const builder = [];
+    const trimSuffix = (str, suffix) => str.endsWith(suffix) ? str.substring(0, str.length - suffix.length) : str;
+    const writeLeadingComments = (comments) => {
+        for (let comment of comments.leadingDetached) {
+            comment = trimSuffix(comment, "\n");
+            for (const line of comment.split("\n")) {
+                builder.push(`//${line}\n`);
+            }
+            builder.push("\n");
+        }
+        if (comments.leading !== undefined) {
+            const comment = trimSuffix(comments.leading, "\n");
+            for (const line of comment.split("\n")) {
+                builder.push(`//${line}\n`);
+            }
+            builder.push("\n");
+        }
+    };
+    writeLeadingComments(file.getSyntaxComments());
+    builder.push(`// @generated by ${pluginName} ${pluginVersion}`);
+    if (parameter !== "") {
+        builder.push(` with parameter "${parameter}"`);
+    }
+    builder.push("\n");
+    builder.push(`// @generated from file ${file.name}.proto (`);
+    if (file.proto.package !== undefined) {
+        builder.push(`package ${file.proto.package}, `);
+    }
+    switch (file.edition) {
+        case descriptor_pb_js_1.Edition.EDITION_PROTO2:
+            builder.push(`syntax proto2)\n`);
+            break;
+        case descriptor_pb_js_1.Edition.EDITION_PROTO3:
+            builder.push(`syntax proto3)\n`);
+            break;
+        default: {
+            const editionString = descriptor_pb_js_1.Edition[file.edition];
+            if (typeof editionString == "string") {
+                const e = editionString.replace("EDITION_", "").toLowerCase();
+                builder.push(`edition ${e})\n`);
+            }
+            else {
+                builder.push(`unknown edition\n`);
+            }
+            break;
+        }
+    }
+    builder.push("/* eslint-disable */\n");
+    if (tsNoCheck) {
+        builder.push("// @ts-nocheck\n");
+    }
+    builder.push("\n");
+    writeLeadingComments(file.getPackageComments());
+    return trimSuffix(builder.join(""), "\n");
+}
+exports.makeFilePreamble = makeFilePreamble;

package/dist/protoplugin/ecmascript/generated-file.d.ts

@@ -0,0 +1,116 @@
+import type { ImportSymbol } from "./import-symbol.js";
+import type { RuntimeImports } from "./runtime-imports.js";
+import type { JSDocBlock } from "./jsdoc.js";
+import type { ExportDeclaration, LiteralProtoInt64, LiteralString, RefDescEnum, RefDescMessage } from "./opaque-printables.js";
+import { AnyDesc, DescEnum, DescExtension, DescFile, DescMessage } from "../../descriptor-set.js";
+/**
+ * All types that can be passed to GeneratedFile.print()
+ */
+export type Printable = string | number | boolean | bigint | Uint8Array | ImportSymbol | ExportDeclaration | JSDocBlock | LiteralString | LiteralProtoInt64 | RefDescMessage | RefDescEnum | DescMessage | DescEnum | DescExtension | Printable[];
+/**
+ * FileInfo represents an intermediate type using for transpiling TypeScript internally.
+ */
+export interface FileInfo {
+    name: string;
+    content: string;
+    preamble?: string | undefined;
+}
+/**
+ * Represents a JavaScript, TypeScript, or TypeScript declaration file.
+ */
+export interface GeneratedFile {
+    /**
+     * Create a standard preamble the includes comments at the top of the
+     * protobuf source file (like a license header), as well as information
+     * about the code generator and its version.
+     *
+     * The preamble is always placed at the very top of the generated file,
+     * above import statements.
+     *
+     * A file with a preamble but no other content is still considered empty,
+     * and will not be generated unless the plugin option keep_empty_files=true
+     * is set.
+     */
+    preamble(file: DescFile): void;
+    /**
+     * Add a line of code to the file.
+     *
+     * - string: Prints the string verbatim.
+     * - number or boolean: Prints a literal.
+     * - bigint: Prints an expression using protoInt64.parse().
+     * - Uint8Array: Prints an expression that re-created the array.
+     * - ImportSymbol: Adds an import statement and prints the name of the symbol.
+     * - DescMessage or DescEnum: Imports the type if necessary, and prints the name.
+     */
+    print(...printables: Printable[]): void;
+    /**
+     * Add a line of code to the file with tagged template literal and
+     * an optional array of Printables.
+     * See print(Printable[]) for behavior when printing Printable items.
+     */
+    print(fragments: TemplateStringsArray, ...printables: Printable[]): void;
+    /**
+     * @deprecated Please use createImportSymbol() from @bufbuild/protoplugin/ecmascript instead
+     */
+    export(name: string): ImportSymbol;
+    /**
+     * Create a string literal.
+     */
+    string(string: string): Printable;
+    /**
+     * Create a JSDoc comment block with the given text. Line breaks and white-space
+     * stay intact.
+     */
+    jsDoc(text: string, indentation?: string): JSDocBlock;
+    /**
+     * Create a JSDoc comment block for the given message, enumeration, or other
+     * descriptor. The comment block will contain the original comments from the
+     * protobuf source, and annotations such as `@generated from message MyMessage`.
+     */
+    jsDoc(desc: Exclude<AnyDesc, DescFile>, indentation?: string): JSDocBlock;
+    /**
+     * Create a printable export statement. For example:
+     *
+     * ```ts
+     * f.print(f.exportDecl("abstract class", "MyClass"), " {}")
+     * ```
+     *
+     * Will generate as:
+     * ```ts
+     * export abstract class MyClass {}
+     * ```
+     *
+     * Using this method is preferred over a calling print() with a literal export
+     * statement. If the plugin option `js_import_style=legacy_commonjs` is set,
+     * exports will automatically be generated for CommonJS.
+     */
+    exportDecl(declaration: string, name: string | DescMessage | DescEnum | DescExtension): Printable;
+    /**
+     * Import a message or enumeration generated by protoc-gen-es.
+     */
+    import(type: DescMessage | DescEnum | DescExtension): ImportSymbol;
+    /**
+     * Import any symbol from a file or package.
+     *
+     * The import path can point to a package, for example `@foo/bar/baz.js`, or
+     * to a file, for example `./bar/baz.js`.
+     *
+     * Note that while paths to a file begin with a `./`, they must be
+     * relative to the project root. The import path is automatically made
+     * relative to the current file.
+     */
+    import(name: string, from: string): ImportSymbol;
+    /**
+     * In case you need full control over exports and imports, use print() and
+     * formulate your own imports and exports based on this property.
+     */
+    readonly jsImportStyle: "module" | "legacy_commonjs";
+}
+export interface GeneratedFileController extends GeneratedFile {
+    getFileInfo(): FileInfo;
+}
+type CreateTypeImportFn = (desc: DescMessage | DescEnum | DescExtension) => ImportSymbol;
+type RewriteImportPathFn = (path: string) => string;
+type CreatePreambleFn = (descFile: DescFile) => string;
+export declare function createGeneratedFile(name: string, importPath: string, jsImportStyle: "module" | "legacy_commonjs", rewriteImportPath: RewriteImportPathFn, createTypeImport: CreateTypeImportFn, runtimeImports: RuntimeImports, createPreamble: CreatePreambleFn): GeneratedFileController;
+export {};