ts-proto 1.181.2 → 2.0.1

package/build/protos/google/protobuf/compiler/plugin.d.ts

@@ -0,0 +1,185 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { FileDescriptorProto, GeneratedCodeInfo } from "../descriptor";
+/** The version number of protocol compiler. */
+export interface Version {
+    major: number;
+    minor: number;
+    patch: number;
+    /**
+     * A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
+     * be empty for mainline stable releases.
+     */
+    suffix: string;
+    _unknownFields?: {
+        [key: number]: Uint8Array[];
+    } | undefined;
+}
+/** An encoded CodeGeneratorRequest is written to the plugin's stdin. */
+export interface CodeGeneratorRequest {
+    /**
+     * The .proto files that were explicitly listed on the command-line.  The
+     * code generator should generate code only for these files.  Each file's
+     * descriptor will be included in proto_file, below.
+     */
+    fileToGenerate: string[];
+    /** The generator parameter passed on the command-line. */
+    parameter: string;
+    /**
+     * FileDescriptorProtos for all files in files_to_generate and everything
+     * they import.  The files will appear in topological order, so each file
+     * appears before any file that imports it.
+     *
+     * protoc guarantees that all proto_files will be written after
+     * the fields above, even though this is not technically guaranteed by the
+     * protobuf wire format.  This theoretically could allow a plugin to stream
+     * in the FileDescriptorProtos and handle them one by one rather than read
+     * the entire set into memory at once.  However, as of this writing, this
+     * is not similarly optimized on protoc's end -- it will store all fields in
+     * memory at once before sending them to the plugin.
+     *
+     * Type names of fields and extensions in the FileDescriptorProto are always
+     * fully qualified.
+     */
+    protoFile: FileDescriptorProto[];
+    /** The version number of protocol compiler. */
+    compilerVersion: Version | undefined;
+    _unknownFields?: {
+        [key: number]: Uint8Array[];
+    } | undefined;
+}
+/** The plugin writes an encoded CodeGeneratorResponse to stdout. */
+export interface CodeGeneratorResponse {
+    /**
+     * Error message.  If non-empty, code generation failed.  The plugin process
+     * should exit with status code zero even if it reports an error in this way.
+     *
+     * This should be used to indicate errors in .proto files which prevent the
+     * code generator from generating correct code.  Errors which indicate a
+     * problem in protoc itself -- such as the input CodeGeneratorRequest being
+     * unparseable -- should be reported by writing a message to stderr and
+     * exiting with a non-zero status code.
+     */
+    error: string;
+    /**
+     * A bitmask of supported features that the code generator supports.
+     * This is a bitwise "or" of values from the Feature enum.
+     */
+    supportedFeatures: number;
+    file: CodeGeneratorResponse_File[];
+    _unknownFields?: {
+        [key: number]: Uint8Array[];
+    } | undefined;
+}
+/** Sync with code_generator.h. */
+export declare enum CodeGeneratorResponse_Feature {
+    FEATURE_NONE = 0,
+    FEATURE_PROTO3_OPTIONAL = 1,
+    UNRECOGNIZED = -1
+}
+export declare function codeGeneratorResponse_FeatureFromJSON(object: any): CodeGeneratorResponse_Feature;
+export declare function codeGeneratorResponse_FeatureToJSON(object: CodeGeneratorResponse_Feature): string;
+/** Represents a single generated file. */
+export interface CodeGeneratorResponse_File {
+    /**
+     * The file name, relative to the output directory.  The name must not
+     * contain "." or ".." components and must be relative, not be absolute (so,
+     * the file cannot lie outside the output directory).  "/" must be used as
+     * the path separator, not "\".
+     *
+     * If the name is omitted, the content will be appended to the previous
+     * file.  This allows the generator to break large files into small chunks,
+     * and allows the generated text to be streamed back to protoc so that large
+     * files need not reside completely in memory at one time.  Note that as of
+     * this writing protoc does not optimize for this -- it will read the entire
+     * CodeGeneratorResponse before writing files to disk.
+     */
+    name: string;
+    /**
+     * If non-empty, indicates that the named file should already exist, and the
+     * content here is to be inserted into that file at a defined insertion
+     * point.  This feature allows a code generator to extend the output
+     * produced by another code generator.  The original generator may provide
+     * insertion points by placing special annotations in the file that look
+     * like:
+     *   @@protoc_insertion_point(NAME)
+     * The annotation can have arbitrary text before and after it on the line,
+     * which allows it to be placed in a comment.  NAME should be replaced with
+     * an identifier naming the point -- this is what other generators will use
+     * as the insertion_point.  Code inserted at this point will be placed
+     * immediately above the line containing the insertion point (thus multiple
+     * insertions to the same point will come out in the order they were added).
+     * The double-@ is intended to make it unlikely that the generated code
+     * could contain things that look like insertion points by accident.
+     *
+     * For example, the C++ code generator places the following line in the
+     * .pb.h files that it generates:
+     *   // @@protoc_insertion_point(namespace_scope)
+     * This line appears within the scope of the file's package namespace, but
+     * outside of any particular class.  Another plugin can then specify the
+     * insertion_point "namespace_scope" to generate additional classes or
+     * other declarations that should be placed in this scope.
+     *
+     * Note that if the line containing the insertion point begins with
+     * whitespace, the same whitespace will be added to every line of the
+     * inserted text.  This is useful for languages like Python, where
+     * indentation matters.  In these languages, the insertion point comment
+     * should be indented the same amount as any inserted code will need to be
+     * in order to work correctly in that context.
+     *
+     * The code generator that generates the initial file and the one which
+     * inserts into it must both run as part of a single invocation of protoc.
+     * Code generators are executed in the order in which they appear on the
+     * command line.
+     *
+     * If |insertion_point| is present, |name| must also be present.
+     */
+    insertionPoint: string;
+    /** The file contents. */
+    content: string;
+    /**
+     * Information describing the file content being inserted. If an insertion
+     * point is used, this information will be appropriately offset and inserted
+     * into the code generation metadata for the generated files.
+     */
+    generatedCodeInfo: GeneratedCodeInfo | undefined;
+    _unknownFields?: {
+        [key: number]: Uint8Array[];
+    } | undefined;
+}
+export declare const Version: {
+    encode(message: Version, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Version;
+    fromJSON(object: any): Version;
+    toJSON(message: Version): unknown;
+    create(base?: DeepPartial<Version>): Version;
+    fromPartial(object: DeepPartial<Version>): Version;
+};
+export declare const CodeGeneratorRequest: {
+    encode(message: CodeGeneratorRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): CodeGeneratorRequest;
+    fromJSON(object: any): CodeGeneratorRequest;
+    toJSON(message: CodeGeneratorRequest): unknown;
+    create(base?: DeepPartial<CodeGeneratorRequest>): CodeGeneratorRequest;
+    fromPartial(object: DeepPartial<CodeGeneratorRequest>): CodeGeneratorRequest;
+};
+export declare const CodeGeneratorResponse: {
+    encode(message: CodeGeneratorResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): CodeGeneratorResponse;
+    fromJSON(object: any): CodeGeneratorResponse;
+    toJSON(message: CodeGeneratorResponse): unknown;
+    create(base?: DeepPartial<CodeGeneratorResponse>): CodeGeneratorResponse;
+    fromPartial(object: DeepPartial<CodeGeneratorResponse>): CodeGeneratorResponse;
+};
+export declare const CodeGeneratorResponse_File: {
+    encode(message: CodeGeneratorResponse_File, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): CodeGeneratorResponse_File;
+    fromJSON(object: any): CodeGeneratorResponse_File;
+    toJSON(message: CodeGeneratorResponse_File): unknown;
+    create(base?: DeepPartial<CodeGeneratorResponse_File>): CodeGeneratorResponse_File;
+    fromPartial(object: DeepPartial<CodeGeneratorResponse_File>): CodeGeneratorResponse_File;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export {};

package/build/protos/google/protobuf/compiler/plugin.js

@@ -0,0 +1,501 @@
+"use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// source: google/protobuf/compiler/plugin.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeGeneratorResponse_File = exports.CodeGeneratorResponse = exports.CodeGeneratorRequest = exports.Version = exports.CodeGeneratorResponse_Feature = void 0;
+exports.codeGeneratorResponse_FeatureFromJSON = codeGeneratorResponse_FeatureFromJSON;
+exports.codeGeneratorResponse_FeatureToJSON = codeGeneratorResponse_FeatureToJSON;
+/* eslint-disable */
+const wire_1 = require("@bufbuild/protobuf/wire");
+const descriptor_1 = require("../descriptor");
+/** Sync with code_generator.h. */
+var CodeGeneratorResponse_Feature;
+(function (CodeGeneratorResponse_Feature) {
+    CodeGeneratorResponse_Feature[CodeGeneratorResponse_Feature["FEATURE_NONE"] = 0] = "FEATURE_NONE";
+    CodeGeneratorResponse_Feature[CodeGeneratorResponse_Feature["FEATURE_PROTO3_OPTIONAL"] = 1] = "FEATURE_PROTO3_OPTIONAL";
+    CodeGeneratorResponse_Feature[CodeGeneratorResponse_Feature["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(CodeGeneratorResponse_Feature || (exports.CodeGeneratorResponse_Feature = CodeGeneratorResponse_Feature = {}));
+function codeGeneratorResponse_FeatureFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "FEATURE_NONE":
+            return CodeGeneratorResponse_Feature.FEATURE_NONE;
+        case 1:
+        case "FEATURE_PROTO3_OPTIONAL":
+            return CodeGeneratorResponse_Feature.FEATURE_PROTO3_OPTIONAL;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return CodeGeneratorResponse_Feature.UNRECOGNIZED;
+    }
+}
+function codeGeneratorResponse_FeatureToJSON(object) {
+    switch (object) {
+        case CodeGeneratorResponse_Feature.FEATURE_NONE:
+            return "FEATURE_NONE";
+        case CodeGeneratorResponse_Feature.FEATURE_PROTO3_OPTIONAL:
+            return "FEATURE_PROTO3_OPTIONAL";
+        case CodeGeneratorResponse_Feature.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+function createBaseVersion() {
+    return { major: 0, minor: 0, patch: 0, suffix: "" };
+}
+exports.Version = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.major !== 0) {
+            writer.uint32(8).int32(message.major);
+        }
+        if (message.minor !== 0) {
+            writer.uint32(16).int32(message.minor);
+        }
+        if (message.patch !== 0) {
+            writer.uint32(24).int32(message.patch);
+        }
+        if (message.suffix !== "") {
+            writer.uint32(34).string(message.suffix);
+        }
+        if (message._unknownFields !== undefined) {
+            for (const [key, values] of Object.entries(message._unknownFields)) {
+                const tag = parseInt(key, 10);
+                for (const value of values) {
+                    writer.uint32(tag).raw(value);
+                }
+            }
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = Object.create(createBaseVersion());
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.major = reader.int32();
+                    continue;
+                case 2:
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.minor = reader.int32();
+                    continue;
+                case 3:
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.patch = reader.int32();
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.suffix = reader.string();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            const buf = reader.skip(tag & 7);
+            if (message._unknownFields === undefined) {
+                message._unknownFields = {};
+            }
+            const list = message._unknownFields[tag];
+            if (list === undefined) {
+                message._unknownFields[tag] = [buf];
+            }
+            else {
+                list.push(buf);
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            major: isSet(object.major) ? globalThis.Number(object.major) : 0,
+            minor: isSet(object.minor) ? globalThis.Number(object.minor) : 0,
+            patch: isSet(object.patch) ? globalThis.Number(object.patch) : 0,
+            suffix: isSet(object.suffix) ? globalThis.String(object.suffix) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.major !== 0) {
+            obj.major = Math.round(message.major);
+        }
+        if (message.minor !== 0) {
+            obj.minor = Math.round(message.minor);
+        }
+        if (message.patch !== 0) {
+            obj.patch = Math.round(message.patch);
+        }
+        if (message.suffix !== "") {
+            obj.suffix = message.suffix;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.Version.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = Object.create(createBaseVersion());
+        message.major = object.major ?? 0;
+        message.minor = object.minor ?? 0;
+        message.patch = object.patch ?? 0;
+        message.suffix = object.suffix ?? "";
+        return message;
+    },
+};
+function createBaseCodeGeneratorRequest() {
+    return { fileToGenerate: [], parameter: "", protoFile: [], compilerVersion: undefined };
+}
+exports.CodeGeneratorRequest = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        for (const v of message.fileToGenerate) {
+            writer.uint32(10).string(v);
+        }
+        if (message.parameter !== "") {
+            writer.uint32(18).string(message.parameter);
+        }
+        for (const v of message.protoFile) {
+            descriptor_1.FileDescriptorProto.encode(v, writer.uint32(122).fork()).join();
+        }
+        if (message.compilerVersion !== undefined) {
+            exports.Version.encode(message.compilerVersion, writer.uint32(26).fork()).join();
+        }
+        if (message._unknownFields !== undefined) {
+            for (const [key, values] of Object.entries(message._unknownFields)) {
+                const tag = parseInt(key, 10);
+                for (const value of values) {
+                    writer.uint32(tag).raw(value);
+                }
+            }
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = Object.create(createBaseCodeGeneratorRequest());
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.fileToGenerate.push(reader.string());
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.parameter = reader.string();
+                    continue;
+                case 15:
+                    if (tag !== 122) {
+                        break;
+                    }
+                    message.protoFile.push(descriptor_1.FileDescriptorProto.decode(reader, reader.uint32()));
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.compilerVersion = exports.Version.decode(reader, reader.uint32());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            const buf = reader.skip(tag & 7);
+            if (message._unknownFields === undefined) {
+                message._unknownFields = {};
+            }
+            const list = message._unknownFields[tag];
+            if (list === undefined) {
+                message._unknownFields[tag] = [buf];
+            }
+            else {
+                list.push(buf);
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            fileToGenerate: globalThis.Array.isArray(object?.fileToGenerate)
+                ? object.fileToGenerate.map((e) => globalThis.String(e))
+                : [],
+            parameter: isSet(object.parameter) ? globalThis.String(object.parameter) : "",
+            protoFile: globalThis.Array.isArray(object?.protoFile)
+                ? object.protoFile.map((e) => descriptor_1.FileDescriptorProto.fromJSON(e))
+                : [],
+            compilerVersion: isSet(object.compilerVersion) ? exports.Version.fromJSON(object.compilerVersion) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.fileToGenerate?.length) {
+            obj.fileToGenerate = message.fileToGenerate;
+        }
+        if (message.parameter !== "") {
+            obj.parameter = message.parameter;
+        }
+        if (message.protoFile?.length) {
+            obj.protoFile = message.protoFile.map((e) => descriptor_1.FileDescriptorProto.toJSON(e));
+        }
+        if (message.compilerVersion !== undefined) {
+            obj.compilerVersion = exports.Version.toJSON(message.compilerVersion);
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.CodeGeneratorRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = Object.create(createBaseCodeGeneratorRequest());
+        message.fileToGenerate = object.fileToGenerate?.map((e) => e) || [];
+        message.parameter = object.parameter ?? "";
+        message.protoFile = object.protoFile?.map((e) => descriptor_1.FileDescriptorProto.fromPartial(e)) || [];
+        message.compilerVersion = (object.compilerVersion !== undefined && object.compilerVersion !== null)
+            ? exports.Version.fromPartial(object.compilerVersion)
+            : undefined;
+        return message;
+    },
+};
+function createBaseCodeGeneratorResponse() {
+    return { error: "", supportedFeatures: 0, file: [] };
+}
+exports.CodeGeneratorResponse = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.error !== "") {
+            writer.uint32(10).string(message.error);
+        }
+        if (message.supportedFeatures !== 0) {
+            writer.uint32(16).uint64(message.supportedFeatures);
+        }
+        for (const v of message.file) {
+            exports.CodeGeneratorResponse_File.encode(v, writer.uint32(122).fork()).join();
+        }
+        if (message._unknownFields !== undefined) {
+            for (const [key, values] of Object.entries(message._unknownFields)) {
+                const tag = parseInt(key, 10);
+                for (const value of values) {
+                    writer.uint32(tag).raw(value);
+                }
+            }
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = Object.create(createBaseCodeGeneratorResponse());
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.error = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.supportedFeatures = longToNumber(reader.uint64());
+                    continue;
+                case 15:
+                    if (tag !== 122) {
+                        break;
+                    }
+                    message.file.push(exports.CodeGeneratorResponse_File.decode(reader, reader.uint32()));
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            const buf = reader.skip(tag & 7);
+            if (message._unknownFields === undefined) {
+                message._unknownFields = {};
+            }
+            const list = message._unknownFields[tag];
+            if (list === undefined) {
+                message._unknownFields[tag] = [buf];
+            }
+            else {
+                list.push(buf);
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            error: isSet(object.error) ? globalThis.String(object.error) : "",
+            supportedFeatures: isSet(object.supportedFeatures) ? globalThis.Number(object.supportedFeatures) : 0,
+            file: globalThis.Array.isArray(object?.file)
+                ? object.file.map((e) => exports.CodeGeneratorResponse_File.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.error !== "") {
+            obj.error = message.error;
+        }
+        if (message.supportedFeatures !== 0) {
+            obj.supportedFeatures = Math.round(message.supportedFeatures);
+        }
+        if (message.file?.length) {
+            obj.file = message.file.map((e) => exports.CodeGeneratorResponse_File.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.CodeGeneratorResponse.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = Object.create(createBaseCodeGeneratorResponse());
+        message.error = object.error ?? "";
+        message.supportedFeatures = object.supportedFeatures ?? 0;
+        message.file = object.file?.map((e) => exports.CodeGeneratorResponse_File.fromPartial(e)) || [];
+        return message;
+    },
+};
+function createBaseCodeGeneratorResponse_File() {
+    return { name: "", insertionPoint: "", content: "", generatedCodeInfo: undefined };
+}
+exports.CodeGeneratorResponse_File = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.name !== "") {
+            writer.uint32(10).string(message.name);
+        }
+        if (message.insertionPoint !== "") {
+            writer.uint32(18).string(message.insertionPoint);
+        }
+        if (message.content !== "") {
+            writer.uint32(122).string(message.content);
+        }
+        if (message.generatedCodeInfo !== undefined) {
+            descriptor_1.GeneratedCodeInfo.encode(message.generatedCodeInfo, writer.uint32(130).fork()).join();
+        }
+        if (message._unknownFields !== undefined) {
+            for (const [key, values] of Object.entries(message._unknownFields)) {
+                const tag = parseInt(key, 10);
+                for (const value of values) {
+                    writer.uint32(tag).raw(value);
+                }
+            }
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = Object.create(createBaseCodeGeneratorResponse_File());
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.name = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.insertionPoint = reader.string();
+                    continue;
+                case 15:
+                    if (tag !== 122) {
+                        break;
+                    }
+                    message.content = reader.string();
+                    continue;
+                case 16:
+                    if (tag !== 130) {
+                        break;
+                    }
+                    message.generatedCodeInfo = descriptor_1.GeneratedCodeInfo.decode(reader, reader.uint32());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            const buf = reader.skip(tag & 7);
+            if (message._unknownFields === undefined) {
+                message._unknownFields = {};
+            }
+            const list = message._unknownFields[tag];
+            if (list === undefined) {
+                message._unknownFields[tag] = [buf];
+            }
+            else {
+                list.push(buf);
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            name: isSet(object.name) ? globalThis.String(object.name) : "",
+            insertionPoint: isSet(object.insertionPoint) ? globalThis.String(object.insertionPoint) : "",
+            content: isSet(object.content) ? globalThis.String(object.content) : "",
+            generatedCodeInfo: isSet(object.generatedCodeInfo)
+                ? descriptor_1.GeneratedCodeInfo.fromJSON(object.generatedCodeInfo)
+                : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.name !== "") {
+            obj.name = message.name;
+        }
+        if (message.insertionPoint !== "") {
+            obj.insertionPoint = message.insertionPoint;
+        }
+        if (message.content !== "") {
+            obj.content = message.content;
+        }
+        if (message.generatedCodeInfo !== undefined) {
+            obj.generatedCodeInfo = descriptor_1.GeneratedCodeInfo.toJSON(message.generatedCodeInfo);
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.CodeGeneratorResponse_File.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = Object.create(createBaseCodeGeneratorResponse_File());
+        message.name = object.name ?? "";
+        message.insertionPoint = object.insertionPoint ?? "";
+        message.content = object.content ?? "";
+        message.generatedCodeInfo = (object.generatedCodeInfo !== undefined && object.generatedCodeInfo !== null)
+            ? descriptor_1.GeneratedCodeInfo.fromPartial(object.generatedCodeInfo)
+            : undefined;
+        return message;
+    },
+};
+function longToNumber(int64) {
+    const num = globalThis.Number(int64.toString());
+    if (num > globalThis.Number.MAX_SAFE_INTEGER) {
+        throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+    }
+    if (num < globalThis.Number.MIN_SAFE_INTEGER) {
+        throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
+    }
+    return num;
+}
+function isSet(value) {
+    return value !== null && value !== undefined;
+}