@czlab/zod-to-proto 0.1.0-beta.0

package/.dist/index.cjs

@@ -0,0 +1,2563 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  $FileContentMatter: () => $FileContentMatter,
+  AnyProto3Type: () => AnyProto3Type,
+  AnyZodMessage: () => AnyZodMessage,
+  AnyZodMessageFieldType: () => AnyZodMessageFieldType,
+  AnyZodMessageFieldTypeTuple: () => AnyZodMessageFieldTypeTuple,
+  AnyZodMessageTypeTuple: () => AnyZodMessageTypeTuple,
+  CompatibleZodTypeTuple: () => CompatibleZodTypeTuple,
+  FileBuilder: () => FileBuilder,
+  Proto3BoolType: () => Proto3BoolType,
+  Proto3BytesType: () => Proto3BytesType,
+  Proto3CommentProcessor: () => Proto3CommentProcessor,
+  Proto3Deprecated: () => Proto3Deprecated,
+  Proto3DoubleType: () => Proto3DoubleType,
+  Proto3Empty: () => Proto3Empty,
+  Proto3Enum: () => Proto3Enum,
+  Proto3EnumField: () => Proto3EnumField,
+  Proto3Extension: () => Proto3Extension,
+  Proto3ExtensionValueProcessor: () => Proto3ExtensionValueProcessor,
+  Proto3FieldExtensionProcessor: () => Proto3FieldExtensionProcessor,
+  Proto3FieldProcessor: () => Proto3FieldProcessor,
+  Proto3File: () => Proto3File,
+  Proto3FileProcessor: () => Proto3FileProcessor,
+  Proto3Fixed32Type: () => Proto3Fixed32Type,
+  Proto3Fixed64Type: () => Proto3Fixed64Type,
+  Proto3FloatType: () => Proto3FloatType,
+  Proto3FunctionProcessor: () => Proto3FunctionProcessor,
+  Proto3GlobalType: () => Proto3GlobalType,
+  Proto3HttpAnnotation: () => Proto3HttpAnnotation,
+  Proto3ImportProcessor: () => Proto3ImportProcessor,
+  Proto3ImportedType: () => Proto3ImportedType,
+  Proto3Int32Type: () => Proto3Int32Type,
+  Proto3Int64Type: () => Proto3Int64Type,
+  Proto3MapType: () => Proto3MapType,
+  Proto3Message: () => Proto3Message,
+  Proto3MessageField: () => Proto3MessageField,
+  Proto3MessageOneOfField: () => Proto3MessageOneOfField,
+  Proto3MessageOneOfFieldSubField: () => Proto3MessageOneOfFieldSubField,
+  Proto3MessageProcessor: () => Proto3MessageProcessor,
+  Proto3OptionalState: () => Proto3OptionalState,
+  Proto3RawFile: () => Proto3RawFile,
+  Proto3RecordExtensionProcessor: () => Proto3RecordExtensionProcessor,
+  Proto3RepeatedType: () => Proto3RepeatedType,
+  Proto3RpcFunction: () => Proto3RpcFunction,
+  Proto3RpcRawFunction: () => Proto3RpcRawFunction,
+  Proto3RpcRawMessage: () => Proto3RpcRawMessage,
+  Proto3RpcRawService: () => Proto3RpcRawService,
+  Proto3RpcService: () => Proto3RpcService,
+  Proto3SFixed32Type: () => Proto3SFixed32Type,
+  Proto3SFixed64Type: () => Proto3SFixed64Type,
+  Proto3SInt32Type: () => Proto3SInt32Type,
+  Proto3SInt64Type: () => Proto3SInt64Type,
+  Proto3ServiceProcessor: () => Proto3ServiceProcessor,
+  Proto3StringType: () => Proto3StringType,
+  Proto3UInt32Type: () => Proto3UInt32Type,
+  Proto3UInt64Type: () => Proto3UInt64Type,
+  Proto3ValidateFieldAnnotation: () => Proto3ValidateFieldAnnotation,
+  Proto3ValidateOneOfAnnotation: () => Proto3ValidateOneOfAnnotation,
+  SchemaError: () => SchemaError,
+  ZodCompatibleType: () => ZodCompatibleType,
+  ZodDeprecatedEnumConversionTransformer: () => ZodDeprecatedEnumConversionTransformer,
+  ZodDeprecatedFieldConversionTransformer: () => ZodDeprecatedFieldConversionTransformer,
+  ZodDeprecatedMessageConversionTransformer: () => ZodDeprecatedMessageConversionTransformer,
+  ZodDeprecatedOneOfFieldConversionTransformer: () => ZodDeprecatedOneOfFieldConversionTransformer,
+  ZodDynamicSizeConverter: () => ZodDynamicSizeConverter,
+  ZodDynamicSizeType: () => ZodDynamicSizeType,
+  ZodDynamicSizeTypeTuple: () => ZodDynamicSizeTypeTuple,
+  ZodMapValueType: () => ZodMapValueType,
+  ZodMapValueTypeTuple: () => ZodMapValueTypeTuple,
+  ZodMessageConverter: () => ZodMessageConverter,
+  ZodMessageFieldConverter: () => ZodMessageFieldConverter,
+  ZodMessageFieldType: () => ZodMessageFieldType,
+  ZodMessageFieldTypeConverter: () => ZodMessageFieldTypeConverter,
+  ZodMessageFieldTypeTuple: () => ZodMessageFieldTypeTuple,
+  ZodMessageOneOfFieldConverter: () => ZodMessageOneOfFieldConverter,
+  ZodMessageOneOfFieldType: () => ZodMessageOneOfFieldType,
+  ZodMessageOneOfFieldTypeTuple: () => ZodMessageOneOfFieldTypeTuple,
+  ZodPassthroughType: () => ZodPassthroughType,
+  ZodPassthroughTypeTuple: () => ZodPassthroughTypeTuple,
+  ZodRepeatedInnerType: () => ZodRepeatedInnerType,
+  ZodRepeatedInnerTypeTuple: () => ZodRepeatedInnerTypeTuple,
+  ZodRequiredFieldConversionTransformer: () => ZodRequiredFieldConversionTransformer,
+  ZodRequiredOneOfFieldConversionTransformer: () => ZodRequiredOneOfFieldConversionTransformer,
+  ZodScalarConverter: () => ZodScalarConverter,
+  ZodScalarType: () => ZodScalarType,
+  ZodScalarTypeTuple: () => ZodScalarTypeTuple,
+  assertsAnyZodMessageFieldType: () => assertsAnyZodMessageFieldType,
+  assertsNotEmptyArray: () => assertsNotEmptyArray,
+  assertsOneElementArray: () => assertsOneElementArray,
+  assertsZodCompatibleType: () => assertsZodCompatibleType,
+  assertsZodFormat: () => assertsZodFormat,
+  assertsZodMapValueType: () => assertsZodMapValueType,
+  assertsZodMessageFieldType: () => assertsZodMessageFieldType,
+  assertsZodObject: () => assertsZodObject,
+  assertsZodRepeatedInnerType: () => assertsZodRepeatedInnerType,
+  assertsZodScalarType: () => assertsZodScalarType,
+  fileContentMatter: () => fileContentMatter,
+  getEmptyTranformers: () => getEmptyTranformers,
+  getFullTransformers: () => getFullTransformers,
+  getZodSchemaComments: () => getZodSchemaComments,
+  isFormatCompatible: () => isFormatCompatible,
+  isZodLiteral: () => isZodLiteral,
+  isZodLiteralNotNullishValues: () => isZodLiteralNotNullishValues,
+  isZodObject: () => isZodObject,
+  isZodSchemaDeprecated: () => isZodSchemaDeprecated,
+  isZodSchemaOptional: () => isZodSchemaOptional,
+  oneOfUnion: () => oneOfUnion,
+  pz: () => pz,
+  zodToProto: () => zodToProto
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/asserts/not_empty_array.ts
+var assertsNotEmptyArray = function(array) {
+  if (array.length === 0) {
+    throw new Error("Array should have one element minimum");
+  }
+};
+
+// src/core/asserts/one_element_array.ts
+var assertsOneElementArray = function(array) {
+  if (array.length !== 1) {
+    throw new Error("Array should have one element only");
+  }
+};
+
+// src/file/classes/content_matter.ts
+var $FileContentMatter = class {
+  constructor(config) {
+    this.config = config;
+  }
+  #settings = {
+    lineTabLevel: 0,
+    blockLevel: 0,
+    listLevel: 0
+  };
+  #sources = [""];
+  get settings() {
+    return this.#settings;
+  }
+  get ["~sources"]() {
+    return this.#sources;
+  }
+  safeDecreaseLineTabLevel() {
+    if (this.#settings.lineTabLevel > 0) {
+      this.#settings.lineTabLevel -= 1;
+    }
+  }
+  safeDecreaseBlockLevel() {
+    if (this.#settings.blockLevel > 0) {
+      this.#settings.blockLevel -= 1;
+    }
+  }
+  safeDecreaseListLevel() {
+    if (this.#settings.listLevel > 0) {
+      this.#settings.listLevel -= 1;
+    }
+  }
+  indent() {
+    this.#settings.lineTabLevel += 1;
+    return this;
+  }
+  outdent() {
+    if (this.#settings.lineTabLevel === 0) {
+      throw new Error("You should indent before calling the outdent method");
+    }
+    this.safeDecreaseLineTabLevel();
+    return this;
+  }
+  openBlock() {
+    this.write(this.config.openingBlockCharacter);
+    this.#settings.lineTabLevel += 1;
+    this.#settings.blockLevel += 1;
+    this.endLine();
+    return this;
+  }
+  closeBlock() {
+    if (this.#settings.blockLevel === 0) {
+      throw new Error("You should open a block before calling the close method");
+    }
+    this.safeDecreaseLineTabLevel();
+    this.safeDecreaseBlockLevel();
+    this.endLine();
+    this.write(this.config.closingBlockCharacter);
+    return this;
+  }
+  openList() {
+    this.write(this.config.openingListCharacter);
+    this.#settings.lineTabLevel += 1;
+    this.#settings.listLevel += 1;
+    this.endLine();
+    return this;
+  }
+  closeList() {
+    if (this.#settings.listLevel === 0) {
+      throw new Error("You should open an array before calling the close method");
+    }
+    this.safeDecreaseLineTabLevel();
+    this.safeDecreaseListLevel();
+    this.endLine();
+    this.write(this.config.closingListCharacter);
+    return this;
+  }
+  popLastSource() {
+    const lastSource = this.#sources.pop();
+    if (lastSource === void 0) {
+      throw new Error("The source should never be empty");
+    }
+    return lastSource;
+  }
+  write(data) {
+    if (typeof data === "string") {
+      let lastSource = this.popLastSource();
+      const updatedSource = `${lastSource}${data}`;
+      this.#sources.push(updatedSource);
+    } else {
+      let isFirst = true;
+      for (const source of data["~sources"]) {
+        if (!isFirst) {
+          this.endLine();
+        }
+        this.write(source);
+        isFirst = false;
+      }
+    }
+    return this;
+  }
+  writeIf(condition, data) {
+    if (condition) {
+      return this.write(data);
+    }
+    return this;
+  }
+  endLine() {
+    let newLine = "";
+    for (let currentLevel = 0; currentLevel < this.#settings.lineTabLevel; currentLevel++) {
+      newLine += this.config.lineTabCharacter;
+    }
+    this.#sources.push(newLine);
+    return this;
+  }
+  writeBlock(content) {
+    if (content.isEmpty()) {
+      this.write(this.config.openingBlockCharacter).write(
+        this.config.closingBlockCharacter
+      );
+      return this;
+    }
+    this.openBlock();
+    let isFirst = true;
+    for (const source of content["~sources"]) {
+      if (!isFirst) {
+        this.endLine();
+      }
+      this.write(source);
+      isFirst = false;
+    }
+    this.closeBlock();
+    return this;
+  }
+  writeList(...contents) {
+    if (contents.length === 0) {
+      this.write(this.config.openingListCharacter).write(
+        this.config.closingListCharacter
+      );
+      return this;
+    }
+    this.openList();
+    let isFirstContent = true;
+    for (const content of contents) {
+      if (!isFirstContent) {
+        this.write(this.config.listSeparatorCharacter).endLine();
+      }
+      let isFirstSource = true;
+      for (const source of content["~sources"]) {
+        if (!isFirstSource) {
+          this.endLine();
+        }
+        this.write(source);
+        isFirstSource = false;
+      }
+      isFirstContent = false;
+    }
+    this.closeList();
+    return this;
+  }
+  writeRecord(...entries) {
+    if (entries.length === 0) {
+      this.write(this.config.openingBlockCharacter).write(
+        this.config.closingBlockCharacter
+      );
+      return this;
+    }
+    this.openBlock();
+    let isFirstContent = true;
+    for (const entry of entries) {
+      if (!isFirstContent) {
+        this.write(this.config.listSeparatorCharacter).endLine();
+      }
+      this.write(`${entry.key}${this.config.recordKeyValueSeparatorCharacter}`);
+      let isFirstSource = true;
+      for (const source of entry.content["~sources"]) {
+        if (!isFirstSource) {
+          this.endLine();
+        }
+        this.write(source);
+        isFirstSource = false;
+      }
+      isFirstContent = false;
+    }
+    this.closeBlock();
+    return this;
+  }
+  isEmpty() {
+    if (this.#sources.length === 0) {
+      return true;
+    }
+    if (this.#sources.length === 1) {
+      return this.#sources[0] === "";
+    }
+    return false;
+  }
+};
+var fileContentMatter = function() {
+  return new $FileContentMatter({
+    lineTabCharacter: "  ",
+    openingBlockCharacter: "{",
+    closingBlockCharacter: "}",
+    openingListCharacter: "[",
+    closingListCharacter: "]",
+    listSeparatorCharacter: ",",
+    recordKeyValueSeparatorCharacter: ": ",
+    recordEntrySeparatorCharacter: ","
+  });
+};
+
+// src/file/classes/file_builder.ts
+var FileBuilder = class {
+  constructor(content) {
+    this.content = content;
+  }
+  compute() {
+    const computedSources = this.content["~sources"].join("\n");
+    return computedSources;
+  }
+};
+
+// src/proto3_definition/types/types.ts
+var import_ts_pattern = require("ts-pattern");
+var Proto3GlobalType = {
+  new: (params) => {
+    return {
+      internalName: "global_type",
+      getDeepMessages() {
+        return [];
+      },
+      getDeepImportedTypes() {
+        return [];
+      },
+      ...params
+    };
+  }
+};
+var Proto3ImportedType = {
+  new: (params) => {
+    return {
+      internalName: "imported_type",
+      getDeepMessages() {
+        return [];
+      },
+      getDeepImportedTypes() {
+        return [this];
+      },
+      ...params
+    };
+  }
+};
+var AnyProto3Type = {
+  new: (params) => {
+    return (0, import_ts_pattern.match)(params).with(
+      { internalName: "global_type" },
+      (params2) => Proto3GlobalType.new(params2)
+    ).with(
+      { internalName: "imported_type" },
+      (params2) => Proto3ImportedType.new(params2)
+    ).exhaustive();
+  }
+};
+
+// src/proto3_definition/types/extension.ts
+var Proto3Extension = {
+  new: function(params) {
+    return {
+      internalName: "extension",
+      getDeepImportedTypes() {
+        return this.key.getDeepImportedTypes();
+      },
+      ...params
+    };
+  },
+  simplify: function(extension) {
+    if (typeof extension.value !== "object" || Array.isArray(extension.value)) {
+      return extension;
+    }
+    const messageEntries = Object.entries(extension.value);
+    if (messageEntries.length < 1 || messageEntries.length > 1) {
+      return extension;
+    }
+    const firstKey = messageEntries[0][0];
+    const firstValue = messageEntries[0][1];
+    return this.new({
+      ...extension,
+      key: AnyProto3Type.new({
+        ...extension.key,
+        typeReference: `(${extension.key.typeReference}).${firstKey}`
+      }),
+      value: firstValue
+    });
+  }
+};
+
+// src/plugin/types/global.ts
+var Proto3Deprecated = {
+  useType: function() {
+    return Proto3GlobalType.new({
+      typeReference: "deprecated"
+    });
+  },
+  useExtension: function(value) {
+    return Proto3Extension.new({
+      key: this.useType(),
+      value
+    });
+  }
+};
+
+// src/proto3_definition/types/messages.ts
+var Proto3Message = {
+  new: (params) => {
+    return {
+      internalName: "message",
+      getDeepMessages() {
+        const deepMessages = this.fields.map((field) => field.getDeepMessages()).flat();
+        return [this, ...deepMessages];
+      },
+      getDeepImportedTypes() {
+        return this.fields.map((field) => field.getDeepImportedTypes()).flat();
+      },
+      getNextIndex() {
+        const normalFieldsCount = this.fields.filter(
+          (field) => field.internalName === "message_field"
+        ).length;
+        const oneOfFieldsCounts = this.fields.filter((field) => field.internalName === "message_one_of_field").map((field) => field.subFields.length);
+        const counts = [normalFieldsCount, oneOfFieldsCounts].flat();
+        const fieldsCount = counts.reduce(
+          (accumulator, currentValue) => accumulator + currentValue,
+          0
+        );
+        return fieldsCount + 1;
+      },
+      ...params
+    };
+  }
+};
+var Proto3Enum = {
+  new: (params) => {
+    return {
+      internalName: "enum",
+      getDeepMessages() {
+        return [this];
+      },
+      getDeepImportedTypes() {
+        return [];
+      },
+      ...params
+    };
+  }
+};
+
+// src/zod_converter/types/check.ts
+var CompatibleZodTypeTuple = {
+  new: function(values) {
+    return values;
+  },
+  get: () => {
+    return CompatibleZodTypeTuple.new([
+      "string",
+      "number",
+      "bigint",
+      "boolean",
+      "object",
+      "literal",
+      "template_literal",
+      "enum",
+      "union",
+      "pipe",
+      "default",
+      "prefault",
+      "lazy",
+      "intersection",
+      "record",
+      "catch",
+      "optional",
+      "nonoptional",
+      "readonly",
+      "set",
+      "array"
+    ]);
+  }
+};
+var ZodCompatibleType = {
+  is: (schema) => {
+    const zodTypes = CompatibleZodTypeTuple.get();
+    return zodTypes.includes(schema._zod.def.type);
+  }
+};
+
+// src/zod_converter/types/error.ts
+var SchemaError = {
+  new: (message, schema, name) => {
+    const error = new Error(message);
+    if (name) {
+      error.name = name;
+    }
+    Object.assign(error, {
+      schema
+    });
+    return error;
+  }
+};
+
+// src/zod_converter/asserts/zod_compatible_type.ts
+var assertsZodCompatibleType = function(schema) {
+  if (!ZodCompatibleType.is(schema)) {
+    const validZodTypes = CompatibleZodTypeTuple.get();
+    throw SchemaError.new(
+      `The schema type should be one of: [${validZodTypes.join(", ")}]`,
+      schema,
+      "assertsZodCompatibleType"
+    );
+  }
+};
+
+// src/zod_converter/helpers/is_zod_object.ts
+var isZodObject = function(schema) {
+  return schema._zod.def.type === "object";
+};
+
+// src/zod_converter/asserts/zod_object.ts
+var assertsZodObject = function(schema) {
+  if (!isZodObject(schema)) {
+    throw SchemaError.new("The schema should be a zod object", schema);
+  }
+};
+
+// src/zod_converter/types/passthroughs.ts
+var import_ts_pattern2 = require("ts-pattern");
+var ZodPassthroughTypeTuple = {
+  new: function(values) {
+    return values;
+  }
+};
+var ZodPassthroughType = {
+  is: (schema) => {
+    const zodTypes = ZodPassthroughTypeTuple.new([
+      "catch",
+      "optional",
+      "nonoptional",
+      "readonly",
+      "default",
+      "prefault",
+      "lazy",
+      "pipe",
+      "intersection"
+    ]);
+    return zodTypes.includes(schema._zod.def.type);
+  },
+  pass: (schema) => {
+    if (!ZodPassthroughType.is(schema)) {
+      return schema;
+    }
+    let passthroughSchema = schema;
+    while (true) {
+      const inner = (0, import_ts_pattern2.match)(passthroughSchema).returnType().with(
+        {
+          _zod: {
+            def: {
+              type: import_ts_pattern2.P.union(
+                "catch",
+                "readonly",
+                "default",
+                "prefault",
+                "optional",
+                "nonoptional"
+              )
+            }
+          }
+        },
+        (schema2) => {
+          assertsZodCompatibleType(schema2._zod.def.innerType);
+          return schema2._zod.def.innerType;
+        }
+      ).with(
+        {
+          _zod: {
+            def: {
+              type: "lazy"
+            }
+          }
+        },
+        (schema2) => {
+          const lazySchema = schema2._zod.def.getter();
+          assertsZodCompatibleType(lazySchema);
+          return lazySchema;
+        }
+      ).with(
+        {
+          _zod: {
+            def: {
+              type: "pipe"
+            }
+          }
+        },
+        (schema2) => {
+          assertsZodCompatibleType(schema2._zod.def.in);
+          return schema2._zod.def.in;
+        }
+      ).with(
+        {
+          _zod: {
+            def: {
+              type: "intersection"
+            }
+          }
+        },
+        (schema2) => {
+          assertsZodObject(schema2._zod.def.right);
+          assertsZodObject(schema2._zod.def.left);
+          const finalSchema = schema2._zod.def.left.extend(
+            schema2._zod.def.right["shape"]
+          );
+          assertsZodCompatibleType(finalSchema);
+          return finalSchema;
+        }
+      ).exhaustive();
+      if (ZodPassthroughType.is(inner)) {
+        passthroughSchema = inner;
+      } else {
+        return inner;
+      }
+    }
+  },
+  getMetaAsDeepAsPossible: (schema) => {
+    const allMeta = [schema.meta() ?? {}];
+    if (!ZodPassthroughType.is(schema)) {
+      return allMeta;
+    }
+    let passthroughSchema = schema;
+    while (true) {
+      const inner = (0, import_ts_pattern2.match)(passthroughSchema).returnType().with(
+        {
+          _zod: {
+            def: {
+              type: import_ts_pattern2.P.union(
+                "catch",
+                "readonly",
+                "default",
+                "prefault",
+                "optional",
+                "nonoptional"
+              )
+            }
+          }
+        },
+        (schema2) => {
+          assertsZodCompatibleType(schema2._zod.def.innerType);
+          return schema2._zod.def.innerType;
+        }
+      ).with(
+        {
+          _zod: {
+            def: {
+              type: "lazy"
+            }
+          }
+        },
+        (schema2) => {
+          const lazySchema = schema2._zod.def.getter();
+          assertsZodCompatibleType(lazySchema);
+          return lazySchema;
+        }
+      ).with(
+        {
+          _zod: {
+            def: {
+              type: "pipe"
+            }
+          }
+        },
+        (schema2) => {
+          assertsZodCompatibleType(schema2._zod.def.in);
+          return schema2._zod.def.in;
+        }
+      ).with(
+        {
+          _zod: {
+            def: {
+              type: "intersection"
+            }
+          }
+        },
+        (schema2) => {
+          assertsZodObject(schema2._zod.def.right);
+          assertsZodObject(schema2._zod.def.left);
+          const finalSchema = schema2._zod.def.left.extend(
+            schema2._zod.def.right["shape"]
+          );
+          assertsZodCompatibleType(finalSchema);
+          return finalSchema;
+        }
+      ).exhaustive();
+      allMeta.push(inner.meta() ?? {});
+      if (ZodPassthroughType.is(inner)) {
+        passthroughSchema = inner;
+      } else {
+        return allMeta;
+      }
+    }
+  }
+};
+
+// src/zod_converter/helpers/is_zod_schema_deprecated.ts
+var isZodSchemaDeprecated = function(schema) {
+  const allMeta = ZodPassthroughType.getMetaAsDeepAsPossible(schema);
+  const isDeprecated = allMeta.some((meta) => meta.deprecated);
+  return isDeprecated;
+};
+
+// src/plugin/classes/zod_deprecated_enum_conversion_transformer.ts
+var ZodDeprecatedEnumConversionTransformer = class {
+  transform(schema, protoDefinition) {
+    const isDeprecated = isZodSchemaDeprecated(schema);
+    if (!isDeprecated) {
+      return protoDefinition;
+    }
+    return Proto3Enum.new({
+      ...protoDefinition,
+      extensions: [
+        ...protoDefinition.extensions,
+        Proto3Deprecated.useExtension(true)
+      ]
+    });
+  }
+};
+
+// src/proto3_definition/types/fields.ts
+var Proto3OptionalState = {
+  PRESENT: "PRESENT",
+  NONE: "NONE",
+  NOT_NEEDED: "NOT_NEEDED"
+};
+var Proto3MessageField = {
+  new: (params) => {
+    return {
+      internalName: "message_field",
+      getDeepMessages() {
+        return this.type.getDeepMessages();
+      },
+      getDeepImportedTypes() {
+        return [
+          ...this.type.getDeepImportedTypes(),
+          ...this.extensions.map(
+            (extension) => extension.getDeepImportedTypes()
+          )
+        ].flat();
+      },
+      ...params
+    };
+  }
+};
+var Proto3MessageOneOfFieldSubField = {
+  new: (params) => {
+    return {
+      ...Proto3MessageField.new(params),
+      optionalState: "NOT_NEEDED"
+    };
+  }
+};
+var Proto3MessageOneOfField = {
+  new: (params) => {
+    return {
+      internalName: "message_one_of_field",
+      getDeepMessages() {
+        return this.subFields.map((field) => field.getDeepMessages()).flat();
+      },
+      getDeepImportedTypes() {
+        return this.subFields.map((field) => field.getDeepImportedTypes()).flat();
+      },
+      ...params
+    };
+  }
+};
+var Proto3EnumField = {
+  new: (params) => {
+    return {
+      internalName: "enum_field",
+      ...params
+    };
+  }
+};
+
+// src/plugin/classes/zod_deprecated_field_conversion_transformer.ts
+var ZodDeprecatedFieldConversionTransformer = class {
+  transform(schema, protoDefinition) {
+    const isDeprecated = isZodSchemaDeprecated(schema);
+    if (!isDeprecated) {
+      return protoDefinition;
+    }
+    return Proto3MessageField.new({
+      ...protoDefinition,
+      extensions: [
+        ...protoDefinition.extensions,
+        Proto3Deprecated.useExtension(true)
+      ]
+    });
+  }
+};
+
+// src/plugin/classes/zod_deprecated_message_conversion_transformer.ts
+var ZodDeprecatedMessageConversionTransformer = class {
+  transform(schema, protoDefinition) {
+    const isDeprecated = isZodSchemaDeprecated(schema);
+    if (!isDeprecated) {
+      return protoDefinition;
+    }
+    return Proto3Message.new({
+      ...protoDefinition,
+      extensions: [
+        ...protoDefinition.extensions,
+        Proto3Deprecated.useExtension(true)
+      ]
+    });
+  }
+};
+
+// src/plugin/classes/zod_deprecated_one_of_field_conversion_transformer.ts
+var ZodDeprecatedOneOfFieldConversionTransformer = class {
+  transform(schema, protoDefinition) {
+    const isDeprecated = isZodSchemaDeprecated(schema);
+    if (!isDeprecated) {
+      return protoDefinition;
+    }
+    return Proto3MessageOneOfField.new({
+      ...protoDefinition,
+      extensions: [
+        ...protoDefinition.extensions,
+        Proto3Deprecated.useExtension(true)
+      ]
+    });
+  }
+};
+
+// src/plugin/types/buf_validate.ts
+var Proto3ValidateFieldAnnotation = {
+  useType: function() {
+    return Proto3ImportedType.new({
+      importPath: "buf/validate/validate.proto",
+      typeReference: "buf.validate.field"
+    });
+  },
+  useExtension: function(value) {
+    return Proto3Extension.new({
+      key: this.useType(),
+      value
+    });
+  }
+};
+var Proto3ValidateOneOfAnnotation = {
+  useType: function() {
+    return Proto3ImportedType.new({
+      importPath: "buf/validate/validate.proto",
+      typeReference: "buf.validate.oneof"
+    });
+  },
+  useExtension: function(value) {
+    return Proto3Extension.new({
+      key: this.useType(),
+      value
+    });
+  }
+};
+
+// src/zod_converter/helpers/is_zod_schema_optional.ts
+var isZodSchemaOptional = function(schema) {
+  return schema.safeParse(void 0).success;
+};
+
+// src/plugin/classes/zod_required_field_conversion_transformer.ts
+var ZodRequiredFieldConversionTransformer = class {
+  transform(schema, protoDefinition) {
+    const isOptional = isZodSchemaOptional(schema);
+    if (isOptional) {
+      return protoDefinition;
+    }
+    return Proto3MessageField.new({
+      ...protoDefinition,
+      extensions: [
+        ...protoDefinition.extensions,
+        Proto3ValidateFieldAnnotation.useExtension({ required: true })
+      ]
+    });
+  }
+};
+
+// src/plugin/classes/zod_required_one_of_field_conversion_transformer.ts
+var ZodRequiredOneOfFieldConversionTransformer = class {
+  transform(schema, protoDefinition) {
+    const isOptional = isZodSchemaOptional(schema);
+    if (isOptional) {
+      return protoDefinition;
+    }
+    return Proto3MessageOneOfField.new({
+      ...protoDefinition,
+      extensions: [
+        ...protoDefinition.extensions,
+        Proto3ValidateOneOfAnnotation.useExtension({ required: true })
+      ]
+    });
+  }
+};
+
+// src/plugin/helpers/get_full_transformers.ts
+var getFullTransformers = function() {
+  return {
+    message: [new ZodDeprecatedMessageConversionTransformer()],
+    messageField: [
+      new ZodDeprecatedFieldConversionTransformer(),
+      new ZodRequiredFieldConversionTransformer()
+    ],
+    messageOneOfField: [
+      new ZodDeprecatedOneOfFieldConversionTransformer(),
+      new ZodRequiredOneOfFieldConversionTransformer()
+    ],
+    enum: [new ZodDeprecatedEnumConversionTransformer()]
+  };
+};
+
+// src/plugin/types/google_api_annotations.ts
+var Proto3HttpAnnotation = {
+  useType: function() {
+    return Proto3ImportedType.new({
+      importPath: "google/api/annotations.proto",
+      typeReference: "google.api.http"
+    });
+  },
+  useExtension: function(value) {
+    return Proto3Extension.new({
+      key: this.useType(),
+      value
+    });
+  }
+};
+
+// src/plugin/types/google_protobuf.ts
+var Proto3Empty = {
+  useType: () => {
+    return Proto3ImportedType.new({
+      importPath: "google/protobuf/empty.proto",
+      typeReference: "google.protobuf.Empty"
+    });
+  }
+};
+
+// src/proto3_definition/types/dynamic_size.ts
+var Proto3MapType = {
+  new: (params) => {
+    return {
+      internalName: "map",
+      getDeepMessages() {
+        return this.value.getDeepMessages();
+      },
+      getDeepImportedTypes() {
+        return this.value.getDeepImportedTypes();
+      },
+      ...params
+    };
+  }
+};
+var Proto3RepeatedType = {
+  new: (params) => {
+    return {
+      internalName: "repeated",
+      getDeepMessages() {
+        let currentItem = this;
+        while (currentItem.internalName === "repeated") {
+          currentItem = currentItem.inner;
+        }
+        return currentItem.getDeepMessages();
+      },
+      getDeepImportedTypes() {
+        let currentItem = this;
+        while (currentItem.internalName === "repeated") {
+          currentItem = currentItem.inner;
+        }
+        return currentItem.getDeepImportedTypes();
+      },
+      ...params
+    };
+  }
+};
+
+// src/proto3_definition/types/file.ts
+var Proto3File = {
+  new: (params) => {
+    return {
+      internalName: "file",
+      getDeepMessages() {
+        return [
+          ...this.service?.getDeepMessages() ?? [],
+          ...this.unscopedMessages.map((message) => message.getDeepMessages())
+        ].flat();
+      },
+      getDeepImportedTypes() {
+        return [
+          ...this.service?.getDeepImportedTypes() ?? [],
+          ...this.unscopedMessages.map(
+            (message) => message.getDeepImportedTypes()
+          )
+        ].flat();
+      },
+      applyTypePrefix() {
+        this.service?.applyTypePrefix();
+      },
+      ...params
+    };
+  }
+};
+
+// src/proto3_definition/types/functions.ts
+var Proto3RpcFunction = {
+  new: (params) => {
+    return {
+      internalName: "rpc_function",
+      getDeepMessages() {
+        return [...this.in.getDeepMessages(), ...this.out.getDeepMessages()];
+      },
+      getDeepImportedTypes() {
+        return [
+          ...this.in.getDeepImportedTypes(),
+          ...this.out.getDeepImportedTypes(),
+          ...this.extensions.map(
+            (extension) => extension.getDeepImportedTypes()
+          )
+        ].flat();
+      },
+      applyTypePrefix() {
+        if (this.typePrefix === void 0) {
+          return;
+        }
+        const messages = this.getDeepMessages();
+        for (const message of messages) {
+          message.name = `${this.typePrefix}${message.name}`;
+        }
+      },
+      ...params
+    };
+  }
+};
+
+// src/proto3_definition/types/scalar_standalones.ts
+var Proto3StringType = {
+  new: () => {
+    return {
+      internalName: "string",
+      name: "string",
+      getDeepMessages() {
+        return [];
+      },
+      getDeepImportedTypes() {
+        return [];
+      }
+    };
+  }
+};
+var Proto3BoolType = {
+  new: () => {
+    return {
+      internalName: "bool",
+      name: "bool",
+      getDeepMessages() {
+        return [];
+      },
+      getDeepImportedTypes() {
+        return [];
+      }
+    };
+  }
+};
+var Proto3Int32Type = {
+  new: () => {
+    return {
+      internalName: "int32",
+      name: "int32",
+      getDeepMessages() {
+        return [];
+      },
+      getDeepImportedTypes() {
+        return [];
+      }
+    };
+  }
+};
+var Proto3Int64Type = {
+  new: () => {
+    return {
+      internalName: "int64",
+      name: "int64",
+      getDeepMessages() {
+        return [];
+      },
+      getDeepImportedTypes() {
+        return [];
+      }
+    };
+  }
+};
+var Proto3UInt32Type = {
+  new: () => {
+    return {
+      internalName: "uint32",
+      name: "uint32",
+      getDeepMessages() {
+        return [];
+      },
+      getDeepImportedTypes() {
+        return [];
+      }
+    };
+  }
+};
+var Proto3UInt64Type = {
+  new: () => {
+    return {
+      internalName: "uint64",
+      name: "uint64",
+      getDeepMessages() {
+        return [];
+      },
+      getDeepImportedTypes() {
+        return [];
+      }
+    };
+  }
+};
+var Proto3SInt32Type = {
+  new: () => {
+    return {
+      internalName: "sint32",
+      name: "sint32",
+      getDeepMessages() {
+        return [];
+      },
+      getDeepImportedTypes() {
+        return [];
+      }
+    };
+  }
+};
+var Proto3SInt64Type = {
+  new: () => {
+    return {
+      internalName: "sint64",
+      name: "sint64",
+      getDeepMessages() {
+        return [];
+      },
+      getDeepImportedTypes() {
+        return [];
+      }
+    };
+  }
+};
+var Proto3Fixed32Type = {
+  new: () => {
+    return {
+      internalName: "fixed32",
+      name: "fixed32",
+      getDeepMessages() {
+        return [];
+      },
+      getDeepImportedTypes() {
+        return [];
+      }
+    };
+  }
+};
+var Proto3Fixed64Type = {
+  new: () => {
+    return {
+      internalName: "fixed64",
+      name: "fixed64",
+      getDeepMessages() {
+        return [];
+      },
+      getDeepImportedTypes() {
+        return [];
+      }
+    };
+  }
+};
+var Proto3SFixed32Type = {
+  new: () => {
+    return {
+      internalName: "sfixed32",
+      name: "sfixed32",
+      getDeepMessages() {
+        return [];
+      },
+      getDeepImportedTypes() {
+        return [];
+      }
+    };
+  }
+};
+var Proto3SFixed64Type = {
+  new: () => {
+    return {
+      internalName: "sfixed64",
+      name: "sfixed64",
+      getDeepMessages() {
+        return [];
+      },
+      getDeepImportedTypes() {
+        return [];
+      }
+    };
+  }
+};
+var Proto3DoubleType = {
+  new: () => {
+    return {
+      internalName: "double",
+      name: "double",
+      getDeepMessages() {
+        return [];
+      },
+      getDeepImportedTypes() {
+        return [];
+      }
+    };
+  }
+};
+var Proto3FloatType = {
+  new: () => {
+    return {
+      internalName: "float",
+      name: "float",
+      getDeepMessages() {
+        return [];
+      },
+      getDeepImportedTypes() {
+        return [];
+      }
+    };
+  }
+};
+var Proto3BytesType = {
+  new: () => {
+    return {
+      internalName: "bytes",
+      name: "bytes",
+      getDeepMessages() {
+        return [];
+      },
+      getDeepImportedTypes() {
+        return [];
+      }
+    };
+  }
+};
+
+// src/proto3_definition/types/service.ts
+var Proto3RpcService = {
+  new: (params) => {
+    return {
+      internalName: "rpc_service",
+      getDeepMessages() {
+        return this.functions.map((rpcFunction) => rpcFunction.getDeepMessages()).flat();
+      },
+      getDeepImportedTypes() {
+        return this.functions.map((rpcFunction) => rpcFunction.getDeepImportedTypes()).flat();
+      },
+      applyTypePrefix() {
+        for (const rpcFunction of this.functions) {
+          rpcFunction.applyTypePrefix();
+        }
+        if (this.typePrefix === void 0) {
+          return;
+        }
+        const messages = this.getDeepMessages();
+        for (const message of messages) {
+          message.name = `${this.typePrefix}${message.name}`;
+        }
+      },
+      ...params
+    };
+  }
+};
+
+// src/proto3_processor/classes/proto3_comment_processor.ts
+var Proto3CommentProcessor = class {
+  constructor(content) {
+    this.content = content;
+  }
+  process(comments) {
+    let isFirst = true;
+    for (const comment of comments) {
+      if (!isFirst) {
+        this.content.endLine();
+      }
+      this.content.write(`// ${comment}`);
+      isFirst = false;
+    }
+    if (!this.content.isEmpty()) {
+      this.content.endLine();
+    }
+  }
+};
+
+// src/proto3_processor/classes/proto3_extension_value_processor.ts
+var Proto3ExtensionValueProcessor = class _Proto3ExtensionValueProcessor {
+  constructor(content) {
+    this.content = content;
+  }
+  process(extensionValue) {
+    if (extensionValue === void 0) {
+      return;
+    } else if (Array.isArray(extensionValue)) {
+      const arrayContents = [];
+      for (const arrayValue of extensionValue) {
+        const arrayValueContent = fileContentMatter();
+        const processor = new _Proto3ExtensionValueProcessor(arrayValueContent);
+        processor.process(arrayValue);
+        if (arrayValueContent.isEmpty()) {
+          continue;
+        }
+        arrayContents.push(arrayValueContent);
+      }
+      this.content.writeList(...arrayContents);
+    } else if (typeof extensionValue === "object") {
+      const recordContentEntries = [];
+      const messageEntries = Object.entries(extensionValue);
+      if (messageEntries.length === 0) {
+        return;
+      }
+      for (const [key, value] of messageEntries) {
+        const valueContent = fileContentMatter();
+        const processor = new _Proto3ExtensionValueProcessor(valueContent);
+        processor.process(value);
+        if (valueContent.isEmpty()) {
+          continue;
+        }
+        recordContentEntries.push({
+          key,
+          content: valueContent
+        });
+      }
+      this.content.writeRecord(...recordContentEntries);
+    } else if (typeof extensionValue === "string") {
+      this.content.write(`"${extensionValue}"`);
+    } else {
+      this.content.write("" + extensionValue);
+    }
+  }
+};
+
+// src/proto3_processor/classes/proto3_field_extension_processor.ts
+var Proto3FieldExtensionProcessor = class {
+  constructor(content) {
+    this.content = content;
+  }
+  process(extension) {
+    const extensionValueContent = fileContentMatter();
+    const processor = new Proto3ExtensionValueProcessor(extensionValueContent);
+    processor.process(extension.value);
+    if (extensionValueContent.isEmpty()) {
+      return;
+    }
+    this.content.write(`${extension.key.typeReference} = `).write(extensionValueContent);
+  }
+};
+
+// src/proto3_processor/classes/proto3_record_extension_processor.ts
+var Proto3RecordExtensionProcessor = class {
+  constructor(content) {
+    this.content = content;
+  }
+  process(extension) {
+    const extensionValueContent = fileContentMatter();
+    const processor = new Proto3ExtensionValueProcessor(extensionValueContent);
+    processor.process(extension.value);
+    if (extensionValueContent.isEmpty()) {
+      return;
+    }
+    this.content.write(`option ${extension.key.typeReference} = `).write(extensionValueContent).write(";");
+  }
+};
+
+// src/proto3_processor/classes/proto3_field_processor.ts
+var import_ts_pattern3 = require("ts-pattern");
+var Proto3FieldProcessor = class _Proto3FieldProcessor {
+  constructor(fileContent) {
+    this.fileContent = fileContent;
+  }
+  getCommentContent(comments) {
+    const content = fileContentMatter();
+    const processor = new Proto3CommentProcessor(content);
+    processor.process(comments);
+    return content;
+  }
+  getScalarTypeReferenceString(scalarType) {
+    return scalarType.name;
+  }
+  getTypeReferenceString(item) {
+    let finalType = "";
+    let currentItem = item;
+    while (currentItem) {
+      let currentType = (0, import_ts_pattern3.match)(currentItem).returnType().with(
+        { internalName: "string" },
+        { internalName: "bool" },
+        { internalName: "int32" },
+        { internalName: "int64" },
+        { internalName: "uint32" },
+        { internalName: "uint64" },
+        { internalName: "sint32" },
+        { internalName: "sint64" },
+        { internalName: "fixed32" },
+        { internalName: "fixed64" },
+        { internalName: "sfixed32" },
+        { internalName: "sfixed64" },
+        { internalName: "float" },
+        { internalName: "double" },
+        { internalName: "bytes" },
+        this.getScalarTypeReferenceString
+      ).with(
+        { internalName: "message" },
+        { internalName: "enum" },
+        (message) => message.name
+      ).with({ internalName: "repeated" }, () => "repeated").with({ internalName: "map" }, (map) => {
+        const keyType = this.getScalarTypeReferenceString(map.key);
+        const valueType = this.getTypeReferenceString(map.value);
+        return `map<${keyType}, ${valueType}>`;
+      }).with({ internalName: "imported_type" }, (imported) => {
+        return imported.typeReference;
+      }).exhaustive();
+      if (finalType === "") {
+        finalType = currentType;
+      } else {
+        finalType += ` ${currentType}`;
+      }
+      currentItem = (0, import_ts_pattern3.match)(currentItem).with({ internalName: "repeated" }, (current) => current.inner).otherwise(() => void 0);
+    }
+    return finalType;
+  }
+  getFieldExtensionContent(extension) {
+    const extensionContent = fileContentMatter();
+    const extensionProcessor = new Proto3FieldExtensionProcessor(extensionContent);
+    extensionProcessor.process(extension);
+    return extensionContent;
+  }
+  getRecordExtensionContent(extension) {
+    const extensionContent = fileContentMatter();
+    const extensionProcessor = new Proto3RecordExtensionProcessor(extensionContent);
+    extensionProcessor.process(extension);
+    return extensionContent;
+  }
+  process(anyField) {
+    const commentContent = this.getCommentContent(anyField.comments);
+    this.fileContent.write(commentContent);
+    (0, import_ts_pattern3.match)(anyField).with({ internalName: "message_field" }, (field) => {
+      const extensionContents = [];
+      for (const extension of field.extensions) {
+        const updatedExtension = Proto3Extension.simplify(extension);
+        const extensionContent = this.getFieldExtensionContent(updatedExtension);
+        if (extensionContent.isEmpty()) {
+          continue;
+        }
+        extensionContents.push(extensionContent);
+      }
+      const typeString = this.getTypeReferenceString(field.type);
+      if (field.optionalState === "PRESENT") {
+        this.fileContent.write("optional ");
+      }
+      this.fileContent.write(`${typeString} ${field.key} = ${field.index}`);
+      if (extensionContents.length > 0) {
+        this.fileContent.write(" ").writeList(...extensionContents);
+      }
+      this.fileContent.write(";");
+    }).with({ internalName: "message_one_of_field" }, (field) => {
+      const oneOfFieldContent = fileContentMatter();
+      let isFirst = true;
+      for (const extension of field.extensions) {
+        const updatedExtension = Proto3Extension.simplify(extension);
+        const extensionContent = this.getRecordExtensionContent(updatedExtension);
+        if (extensionContent.isEmpty()) {
+          continue;
+        }
+        if (!isFirst) {
+          oneOfFieldContent.endLine();
+        }
+        oneOfFieldContent.write(extensionContent);
+        isFirst = false;
+      }
+      for (const subField of field.subFields) {
+        if (!isFirst) {
+          oneOfFieldContent.endLine();
+        }
+        const fieldProcessor = new _Proto3FieldProcessor(oneOfFieldContent);
+        fieldProcessor.process(subField);
+        isFirst = false;
+      }
+      this.fileContent.write(`oneof ${field.key} `).writeBlock(oneOfFieldContent);
+    }).with({ internalName: "enum_field" }, (field) => {
+      const extensionContents = [];
+      for (const extension of field.extensions) {
+        const updatedExtension = Proto3Extension.simplify(extension);
+        const extensionContent = this.getFieldExtensionContent(updatedExtension);
+        if (extensionContent.isEmpty()) {
+          continue;
+        }
+        extensionContents.push(extensionContent);
+      }
+      this.fileContent.write(`${field.key} = ${field.index}`);
+      if (extensionContents.length > 0) {
+        this.fileContent.write(" ").writeList(...extensionContents);
+      }
+      this.fileContent.write(";");
+    }).exhaustive();
+  }
+};
+
+// src/proto3_processor/classes/proto3_import_processor.ts
+var Proto3ImportProcessor = class {
+  constructor(content) {
+    this.content = content;
+  }
+  process(importedTypes) {
+    let isFirst = true;
+    const importPaths = importedTypes.map((importedType) => importedType.importPath);
+    const uniqueImportPaths = new Set(importPaths);
+    for (const importPath of uniqueImportPaths) {
+      if (!isFirst) {
+        this.content.endLine();
+      }
+      this.content.write(`import "${importPath}";`);
+      isFirst = false;
+    }
+  }
+};
+
+// src/proto3_processor/classes/proto3_message_processor.ts
+var import_ts_pattern4 = require("ts-pattern");
+var Proto3MessageProcessor = class {
+  constructor(content) {
+    this.content = content;
+  }
+  getCommentContent(comments) {
+    const content = fileContentMatter();
+    const processor = new Proto3CommentProcessor(content);
+    processor.process(comments);
+    return content;
+  }
+  getRecordExtensionContent(extension) {
+    const extensionContent = fileContentMatter();
+    const extensionProcessor = new Proto3RecordExtensionProcessor(extensionContent);
+    extensionProcessor.process(extension);
+    return extensionContent;
+  }
+  process(anyMessage) {
+    const commentContent = this.getCommentContent(anyMessage.comments);
+    this.content.write(commentContent);
+    (0, import_ts_pattern4.match)(anyMessage).with({ internalName: "message" }, (message) => {
+      const messageContent = fileContentMatter();
+      let isFirst = true;
+      for (const extension of message.extensions) {
+        const updatedExtension = Proto3Extension.simplify(extension);
+        const extensionContent = this.getRecordExtensionContent(updatedExtension);
+        if (extensionContent.isEmpty()) {
+          continue;
+        }
+        if (!isFirst) {
+          messageContent.endLine();
+        }
+        messageContent.write(extensionContent);
+        isFirst = false;
+      }
+      for (const field of message.fields) {
+        if (!isFirst) {
+          messageContent.endLine();
+        }
+        const fieldProcessor = new Proto3FieldProcessor(messageContent);
+        fieldProcessor.process(field);
+        isFirst = false;
+      }
+      this.content.write(`message ${message.name} `).writeBlock(messageContent);
+    }).with({ internalName: "enum" }, (messageEnum) => {
+      const enumContent = fileContentMatter();
+      let isFirst = true;
+      for (const extension of messageEnum.extensions) {
+        const updatedExtension = Proto3Extension.simplify(extension);
+        const extensionContent = this.getRecordExtensionContent(updatedExtension);
+        if (extensionContent.isEmpty()) {
+          continue;
+        }
+        if (!isFirst) {
+          enumContent.endLine();
+        }
+        enumContent.write(extensionContent);
+        isFirst = false;
+      }
+      for (const field of messageEnum.fields) {
+        if (!isFirst) {
+          enumContent.endLine();
+        }
+        const fieldProcessor = new Proto3FieldProcessor(enumContent);
+        fieldProcessor.process(field);
+        isFirst = false;
+      }
+      this.content.write(`enum ${messageEnum.name} `).writeBlock(enumContent);
+    }).exhaustive();
+  }
+};
+
+// src/proto3_processor/classes/proto3_function_processor.ts
+var import_ts_pattern5 = require("ts-pattern");
+var Proto3FunctionProcessor = class {
+  constructor(content) {
+    this.content = content;
+  }
+  getCommentContent(comments) {
+    const content = fileContentMatter();
+    const processor = new Proto3CommentProcessor(content);
+    processor.process(comments);
+    return content;
+  }
+  getTypeReferenceString(item) {
+    return (0, import_ts_pattern5.match)(item).returnType().with(
+      { internalName: "enum" },
+      { internalName: "message" },
+      (message) => message.name
+    ).with({ internalName: "imported_type" }, (imported) => imported.typeReference).exhaustive();
+  }
+  process(rpcFunction) {
+    const commentContent = this.getCommentContent(rpcFunction.comments);
+    const inTypeReference = this.getTypeReferenceString(rpcFunction.in);
+    const outTypeReference = this.getTypeReferenceString(rpcFunction.out);
+    const extensionBlockContent = fileContentMatter();
+    let isFirstExtension = true;
+    for (const extension of rpcFunction.extensions) {
+      const extensionContent = fileContentMatter();
+      const extensionProcessor = new Proto3RecordExtensionProcessor(
+        extensionContent
+      );
+      const updatedExtension = Proto3Extension.simplify(extension);
+      extensionProcessor.process(updatedExtension);
+      if (extensionContent.isEmpty()) {
+        continue;
+      }
+      if (!isFirstExtension) {
+        extensionBlockContent.endLine();
+      }
+      extensionBlockContent.write(extensionContent);
+      isFirstExtension = false;
+    }
+    this.content.write(commentContent).write(`rpc ${rpcFunction.name}(`).writeIf(rpcFunction.inStream, "stream ").write(`${inTypeReference}) returns (`).writeIf(rpcFunction.outStream, "stream ").write(`${outTypeReference}) `).writeBlock(extensionBlockContent);
+  }
+};
+
+// src/proto3_processor/classes/proto3_service_processor.ts
+var Proto3ServiceProcessor = class {
+  constructor(content) {
+    this.content = content;
+  }
+  getCommentContent(comments) {
+    const content = fileContentMatter();
+    const processor = new Proto3CommentProcessor(content);
+    processor.process(comments);
+    return content;
+  }
+  getRecordExtensionContent(extension) {
+    const extensionContent = fileContentMatter();
+    const extensionProcessor = new Proto3RecordExtensionProcessor(extensionContent);
+    extensionProcessor.process(extension);
+    return extensionContent;
+  }
+  process(service) {
+    const commentContent = this.getCommentContent(service.comments);
+    const serviceContent = fileContentMatter();
+    let isFirst = true;
+    for (const extension of service.extensions) {
+      const updatedExtension = Proto3Extension.simplify(extension);
+      const extensionContent = this.getRecordExtensionContent(updatedExtension);
+      if (extensionContent.isEmpty()) {
+        continue;
+      }
+      if (!isFirst) {
+        serviceContent.endLine();
+      }
+      serviceContent.write(extensionContent);
+      isFirst = false;
+    }
+    for (const rpcFunction of service.functions) {
+      if (!isFirst) {
+        serviceContent.endLine();
+      }
+      const functionProcessor = new Proto3FunctionProcessor(serviceContent);
+      functionProcessor.process(rpcFunction);
+      isFirst = false;
+    }
+    this.content.write(commentContent).write(`service ${service.name} `).writeBlock(serviceContent);
+  }
+};
+
+// src/proto3_processor/classes/proto3_file_processor.ts
+var Proto3FileProcessor = class {
+  getImportContent(importedTypes) {
+    const content = fileContentMatter();
+    const processor = new Proto3ImportProcessor(content);
+    processor.process(importedTypes);
+    return content;
+  }
+  getRecordExtensionContent(extension) {
+    const extensionContent = fileContentMatter();
+    const extensionProcessor = new Proto3RecordExtensionProcessor(extensionContent);
+    extensionProcessor.process(extension);
+    return extensionContent;
+  }
+  getExtensionContents(extensions) {
+    const contents = [];
+    for (const extension of extensions) {
+      const updatedExtension = Proto3Extension.simplify(extension);
+      const content = this.getRecordExtensionContent(updatedExtension);
+      if (content.isEmpty()) {
+        continue;
+      }
+      contents.push(content);
+    }
+    return contents;
+  }
+  getServiceContent(service) {
+    const content = fileContentMatter();
+    const processor = new Proto3ServiceProcessor(content);
+    processor.process(service);
+    return content;
+  }
+  getMessageContent(messages) {
+    const content = fileContentMatter();
+    const processor = new Proto3MessageProcessor(content);
+    let isFirst = true;
+    for (const message of messages) {
+      if (!isFirst) {
+        content.endLine().endLine();
+      }
+      processor.process(message);
+      isFirst = false;
+    }
+    return content;
+  }
+  process(file) {
+    file.applyTypePrefix();
+    const content = fileContentMatter();
+    const importedTypes = file.getDeepImportedTypes();
+    const importContent = this.getImportContent(importedTypes);
+    const extensionContents = this.getExtensionContents(file.extensions);
+    const serviceContent = file.service ? this.getServiceContent(file.service) : fileContentMatter();
+    const messages = file.getDeepMessages();
+    const messageContent = this.getMessageContent(messages);
+    content.write(`syntax = "${file.syntax}";`);
+    if (!importContent.isEmpty()) {
+      content.endLine().endLine().write(importContent);
+    }
+    content.endLine().endLine().write(`package ${file.packageName};`);
+    if (extensionContents.length > 0) {
+      content.endLine().endLine();
+      let isFirst = true;
+      for (const extensionContent of extensionContents) {
+        if (!isFirst) {
+          extensionContent.endLine();
+        }
+        content.write(extensionContent);
+        isFirst = false;
+      }
+    }
+    if (!serviceContent.isEmpty()) {
+      content.endLine().endLine().write(serviceContent);
+    }
+    if (!messageContent.isEmpty()) {
+      content.endLine().endLine().write(messageContent);
+    }
+    return content;
+  }
+};
+
+// src/zod_converter/types/messages.ts
+var AnyZodMessageTypeTuple = {
+  new: function(values) {
+    return values;
+  }
+};
+var AnyZodMessage = {
+  is: function(schema) {
+    const deepSchema = ZodPassthroughType.pass(schema);
+    const zodTypes = AnyZodMessageTypeTuple.new(["object", "enum"]);
+    return zodTypes.includes(deepSchema._zod.def.type);
+  }
+};
+var ZodMessageFieldTypeTuple = {
+  new: function(values) {
+    return values;
+  },
+  get: () => {
+    return ZodMessageFieldTypeTuple.new([
+      "string",
+      "number",
+      "bigint",
+      "boolean",
+      "literal",
+      "template_literal",
+      "array",
+      "set",
+      "record",
+      "object",
+      "enum"
+    ]);
+  }
+};
+var ZodMessageFieldType = {
+  is: function(schema) {
+    const deepSchema = ZodPassthroughType.pass(schema);
+    const zodTypes = ZodMessageFieldTypeTuple.get();
+    return zodTypes.includes(deepSchema._zod.def.type);
+  }
+};
+var ZodMessageOneOfFieldTypeTuple = {
+  new: function(values) {
+    return values;
+  },
+  get: () => {
+    return ZodMessageOneOfFieldTypeTuple.new(["union"]);
+  }
+};
+var ZodMessageOneOfFieldType = {
+  is: function(schema) {
+    const deepSchema = ZodPassthroughType.pass(schema);
+    const zodTypes = ZodMessageOneOfFieldTypeTuple.get();
+    return zodTypes.includes(deepSchema._zod.def.type);
+  }
+};
+var AnyZodMessageFieldTypeTuple = {
+  new: function(values) {
+    return values;
+  },
+  get: () => {
+    return AnyZodMessageFieldTypeTuple.new([
+      "string",
+      "number",
+      "bigint",
+      "boolean",
+      "literal",
+      "template_literal",
+      "array",
+      "set",
+      "record",
+      "object",
+      "enum",
+      "union"
+    ]);
+  }
+};
+var AnyZodMessageFieldType = {
+  is: function(schema) {
+    const deepSchema = ZodPassthroughType.pass(schema);
+    const zodTypes = AnyZodMessageFieldTypeTuple.get();
+    return zodTypes.includes(deepSchema._zod.def.type);
+  }
+};
+
+// src/zod_converter/asserts/any_zod_message_field_type.ts
+var assertsAnyZodMessageFieldType = function(schema) {
+  if (!AnyZodMessageFieldType.is(schema)) {
+    const validZodTypes = AnyZodMessageFieldTypeTuple.get();
+    throw SchemaError.new(
+      `The schema type should be one of: [${validZodTypes.join(", ")}]`,
+      schema,
+      "assertsAnyZodMessageFieldType"
+    );
+  }
+};
+
+// src/zod_converter/types/dynamic_size.ts
+var ZodDynamicSizeTypeTuple = {
+  new: function(values) {
+    return values;
+  }
+};
+var ZodDynamicSizeType = {
+  is: function(schema) {
+    const deepSchema = ZodPassthroughType.pass(schema);
+    const zodTypes = ZodDynamicSizeTypeTuple.new(["array", "set", "record"]);
+    return zodTypes.includes(deepSchema._zod.def.type);
+  }
+};
+var ZodRepeatedInnerTypeTuple = {
+  new: function(values) {
+    return values;
+  },
+  get: () => {
+    return ZodRepeatedInnerTypeTuple.new([
+      "string",
+      "number",
+      "bigint",
+      "boolean",
+      "literal",
+      "template_literal",
+      "object",
+      "enum",
+      "set",
+      "array"
+    ]);
+  }
+};
+var ZodRepeatedInnerType = {
+  is: function(schema) {
+    const deepSchema = ZodPassthroughType.pass(schema);
+    const zodTypes = ZodRepeatedInnerTypeTuple.get();
+    return zodTypes.includes(deepSchema._zod.def.type);
+  }
+};
+var ZodMapValueTypeTuple = {
+  new: function(values) {
+    return values;
+  },
+  get: () => {
+    return ZodMapValueTypeTuple.new([
+      "string",
+      "number",
+      "bigint",
+      "boolean",
+      "literal",
+      "template_literal",
+      "object",
+      "enum"
+    ]);
+  }
+};
+var ZodMapValueType = {
+  is: function(schema) {
+    const deepSchema = ZodPassthroughType.pass(schema);
+    const zodTypes = ZodMapValueTypeTuple.get();
+    return zodTypes.includes(deepSchema._zod.def.type);
+  }
+};
+
+// src/zod_converter/asserts/zod_map_value.ts
+var assertsZodMapValueType = function(schema) {
+  if (!ZodMapValueType.is(schema)) {
+    const validZodTypes = ZodMapValueTypeTuple.get();
+    throw SchemaError.new(
+      `The schema type should be one of: [${validZodTypes.join(", ")}]`,
+      schema,
+      "assertsZodMapValueType"
+    );
+  }
+};
+
+// src/zod_converter/asserts/zod_repeated_inner_type.ts
+var assertsZodRepeatedInnerType = function(schema) {
+  if (!ZodRepeatedInnerType.is(schema)) {
+    const validZodTypes = ZodRepeatedInnerTypeTuple.get();
+    throw SchemaError.new(
+      `The schema type should be one of: [${validZodTypes.join(", ")}]`,
+      schema,
+      "assertsZodRepeatedInnerType"
+    );
+  }
+};
+
+// src/zod_converter/types/scalars.ts
+var ZodScalarTypeTuple = {
+  new: function(values) {
+    return values;
+  },
+  get: () => {
+    return ZodScalarTypeTuple.new([
+      "string",
+      "number",
+      "bigint",
+      "boolean",
+      "literal",
+      "template_literal"
+    ]);
+  }
+};
+var ZodScalarType = {
+  is: function(schema) {
+    const deepSchema = ZodPassthroughType.pass(schema);
+    const zodTypes = ZodScalarTypeTuple.get();
+    return zodTypes.includes(deepSchema._zod.def.type);
+  }
+};
+
+// src/zod_converter/asserts/zod_scalar_type.ts
+var assertsZodScalarType = function(schema) {
+  if (!ZodScalarType.is(schema)) {
+    const validZodTypes = ZodScalarTypeTuple.get();
+    throw SchemaError.new(
+      `The schema type should be one of: [${validZodTypes.join(", ")}]`,
+      schema,
+      "assertsZodScalarType"
+    );
+  }
+};
+
+// src/zod_converter/classes/zod_dynamic_size_converter.ts
+var import_pluralize = __toESM(require("pluralize"));
+var import_ts_pattern6 = require("ts-pattern");
+var ZodDynamicSizeConverter = class {
+  constructor(transformers) {
+    this.transformers = transformers;
+  }
+  convert(key, rootSchema) {
+    const deepSchema = ZodPassthroughType.pass(rootSchema);
+    return (0, import_ts_pattern6.match)(deepSchema).returnType().with(
+      {
+        _zod: {
+          def: {
+            type: "array"
+          }
+        }
+      },
+      (schema) => {
+        const converter = new ZodMessageFieldTypeConverter(this.transformers);
+        assertsZodRepeatedInnerType(schema._zod.def.element);
+        const inner = converter.convert(
+          (0, import_pluralize.default)(key, 1),
+          schema._zod.def.element
+        );
+        return Proto3RepeatedType.new({
+          inner
+        });
+      }
+    ).with(
+      {
+        _zod: {
+          def: {
+            type: "set"
+          }
+        }
+      },
+      (schema) => {
+        const converter = new ZodMessageFieldTypeConverter(this.transformers);
+        assertsZodRepeatedInnerType(schema._zod.def.valueType);
+        const inner = converter.convert(key, schema._zod.def.valueType);
+        return Proto3RepeatedType.new({
+          inner
+        });
+      }
+    ).with(
+      {
+        _zod: {
+          def: {
+            type: "record"
+          }
+        }
+      },
+      (schema) => {
+        const converter = new ZodMessageFieldTypeConverter(this.transformers);
+        assertsZodScalarType(schema._zod.def.keyType);
+        const keyType = converter.convert(key, schema._zod.def.keyType);
+        assertsZodMapValueType(schema._zod.def.valueType);
+        const valueType = converter.convert(key, schema._zod.def.valueType);
+        return Proto3MapType.new({
+          key: keyType,
+          value: valueType
+        });
+      }
+    ).exhaustive();
+  }
+};
+
+// src/zod_converter/helpers/is_format_compatible.ts
+var isFormatCompatible = (formatValues, object) => {
+  if (object.format === null) {
+    return false;
+  }
+  return formatValues.includes(object.format);
+};
+
+// src/zod_converter/asserts/zod_format.ts
+var assertsZodFormat = function(formatValues, object) {
+  if (!isFormatCompatible(formatValues, object)) {
+    throw SchemaError.new(
+      `The schema should be uses these formats: [${formatValues.join(", ")}]`,
+      object
+    );
+  }
+};
+
+// src/zod_converter/classes/zod_scalar_converter.ts
+var import_ts_pattern7 = require("ts-pattern");
+var ZodScalarConverter = class {
+  convert(rootSchema) {
+    const deepSchema = ZodPassthroughType.pass(rootSchema);
+    return (0, import_ts_pattern7.match)(deepSchema).returnType().with(
+      {
+        _zod: {
+          def: {
+            type: "string"
+          }
+        }
+      },
+      () => Proto3StringType.new()
+    ).with(
+      {
+        _zod: {
+          def: {
+            type: "number"
+          }
+        }
+      },
+      (schema) => {
+        if (schema.format === null) {
+          return Proto3DoubleType.new();
+        }
+        assertsZodFormat(
+          ["safeint", "float32", "float64", "int32", "uint32"],
+          schema
+        );
+        return (0, import_ts_pattern7.match)(schema).with({ format: "safeint" }, () => {
+          return Proto3Int64Type.new();
+        }).with({ format: "int32" }, () => Proto3Int32Type.new()).with({ format: "float32" }, () => Proto3FloatType.new()).with({ format: "float64" }, () => Proto3DoubleType.new()).with({ format: "uint32" }, () => Proto3UInt32Type.new()).exhaustive();
+      }
+    ).with(
+      {
+        _zod: {
+          def: {
+            type: "bigint"
+          }
+        }
+      },
+      (schema) => {
+        assertsZodFormat(["int64", "uint64"], schema);
+        return (0, import_ts_pattern7.match)(schema).with({ format: "int64" }, () => Proto3Int64Type.new()).with({ format: "uint64" }, () => Proto3UInt64Type.new()).exhaustive();
+      }
+    ).with(
+      {
+        _zod: {
+          def: {
+            type: "boolean"
+          }
+        }
+      },
+      () => Proto3BoolType.new()
+    ).with(
+      {
+        _zod: {
+          def: {
+            type: "literal"
+          }
+        }
+      },
+      () => Proto3StringType.new()
+    ).with(
+      {
+        _zod: {
+          def: {
+            type: "template_literal"
+          }
+        }
+      },
+      () => Proto3StringType.new()
+    ).exhaustive();
+  }
+};
+
+// src/zod_converter/classes/zod_message_field_type_converter.ts
+var ZodMessageFieldTypeConverter = class {
+  constructor(transformers) {
+    this.transformers = transformers;
+  }
+  convert(key, schema) {
+    if (ZodScalarType.is(schema)) {
+      const converter = new ZodScalarConverter();
+      return converter.convert(schema);
+    }
+    if (ZodDynamicSizeType.is(schema)) {
+      const converter = new ZodDynamicSizeConverter(this.transformers);
+      return converter.convert(key, schema);
+    }
+    if (AnyZodMessage.is(schema)) {
+      const converter = new ZodMessageConverter(this.transformers);
+      return converter.convert(key, schema);
+    }
+    throw SchemaError.new("Not possible", schema);
+  }
+};
+
+// src/zod_converter/helpers/get_zod_schema_comments.ts
+var getZodSchemaComments = function(schema) {
+  const allMeta = ZodPassthroughType.getMetaAsDeepAsPossible(schema);
+  const descriptions = allMeta.map((meta) => meta.description).filter(Boolean);
+  const comments = descriptions.map((description) => description.split("\n")).flat();
+  let startIndex = -1;
+  let endIndex = -1;
+  for (let index = 0; index < comments.length; index++) {
+    const comment = comments[index];
+    if (comment === "") {
+      continue;
+    } else {
+      startIndex = index;
+      break;
+    }
+  }
+  for (let index = comments.length - 1; index >= 0; index--) {
+    const comment = comments[index];
+    if (comment === "") {
+      continue;
+    } else {
+      endIndex = index;
+      break;
+    }
+  }
+  if (startIndex === -1 || endIndex === -1) {
+    return [];
+  }
+  return comments.slice(startIndex, endIndex + 1);
+};
+
+// src/zod_converter/classes/zod_message_field_converter.ts
+var import_change_case = require("change-case");
+var ZodMessageFieldConverter = class {
+  constructor(message, transformers) {
+    this.message = message;
+    this.transformers = transformers;
+  }
+  convert(key, rootSchema, optionalState) {
+    const deepSchema = ZodPassthroughType.pass(rootSchema);
+    const converter = new ZodMessageFieldTypeConverter(this.transformers);
+    optionalState ??= isZodSchemaOptional(rootSchema) ? "PRESENT" : "NONE";
+    const index = this.message.getNextIndex();
+    const type = converter.convert(key, deepSchema);
+    const field = Proto3MessageField.new({
+      index,
+      key: (0, import_change_case.snakeCase)(key),
+      optionalState,
+      type,
+      extensions: [],
+      comments: getZodSchemaComments(rootSchema)
+    });
+    const updatedField = this.transformers.messageField.reduce(
+      (field2, transformer) => {
+        return transformer.transform(rootSchema, field2);
+      },
+      field
+    );
+    return updatedField;
+  }
+};
+
+// src/zod_converter/asserts/zod_message_field_type.ts
+var assertsZodMessageFieldType = function(schema) {
+  if (!ZodMessageFieldType.is(schema)) {
+    const validZodTypes = ZodMessageFieldTypeTuple.get();
+    throw SchemaError.new(
+      `The schema type should be one of: [${validZodTypes.join(", ")}]`,
+      schema,
+      "assertsZodMessageFieldType"
+    );
+  }
+};
+
+// src/zod_converter/classes/zod_message_one_of_field_converter.ts
+var import_change_case2 = require("change-case");
+var ZodMessageOneOfFieldConverter = class {
+  constructor(message, transformers) {
+    this.message = message;
+    this.transformers = transformers;
+  }
+  getSubField(schema, key) {
+    const converter = new ZodMessageFieldConverter(this.message, this.transformers);
+    assertsZodMessageFieldType(schema);
+    const subField = converter.convert(key, schema, "NOT_NEEDED");
+    return subField;
+  }
+  convert(key, rootSchema) {
+    const deepSchema = ZodPassthroughType.pass(rootSchema);
+    let subFields = [];
+    for (let subFieldIndex = 0; subFieldIndex < deepSchema._zod.def.options.length; subFieldIndex++) {
+      const unionOptionSchema = deepSchema._zod.def.options[subFieldIndex];
+      const caseName = unionOptionSchema.shape.$case._zod.def.values;
+      const valueSchema = unionOptionSchema.shape.value;
+      assertsOneElementArray(caseName);
+      const subField = this.getSubField(valueSchema, caseName[0]);
+      subFields.push(subField);
+    }
+    for (let subFieldIndex = 0; subFieldIndex < subFields.length; subFieldIndex++) {
+      const subField = subFields[subFieldIndex];
+      subField.index = this.message.getNextIndex() + subFieldIndex;
+    }
+    const field = Proto3MessageOneOfField.new({
+      key: (0, import_change_case2.snakeCase)(key),
+      subFields,
+      extensions: [],
+      comments: getZodSchemaComments(rootSchema)
+    });
+    const updatedField = this.transformers.messageOneOfField.reduce(
+      (field2, transformer) => {
+        return transformer.transform(rootSchema, field2);
+      },
+      field
+    );
+    return updatedField;
+  }
+};
+
+// src/zod_converter/classes/zod_message_converter.ts
+var import_change_case3 = require("change-case");
+var import_ts_pattern8 = require("ts-pattern");
+var ZodMessageConverter = class {
+  constructor(transformers) {
+    this.transformers = transformers;
+  }
+  convert(name, rootSchema) {
+    const deepSchema = ZodPassthroughType.pass(rootSchema);
+    return (0, import_ts_pattern8.match)(deepSchema).returnType().with(
+      {
+        _zod: {
+          def: {
+            type: "object"
+          }
+        }
+      },
+      (schema) => {
+        const message = Proto3Message.new({
+          name: (0, import_change_case3.pascalCase)(name),
+          fields: [],
+          extensions: [],
+          comments: getZodSchemaComments(rootSchema)
+        });
+        for (const [key, entrySchema] of Object.entries(schema.shape)) {
+          assertsAnyZodMessageFieldType(entrySchema);
+          let field;
+          if (ZodMessageFieldType.is(entrySchema)) {
+            const converter = new ZodMessageFieldConverter(
+              message,
+              this.transformers
+            );
+            field = converter.convert(key, entrySchema);
+          } else {
+            const converter = new ZodMessageOneOfFieldConverter(
+              message,
+              this.transformers
+            );
+            field = converter.convert(key, entrySchema);
+          }
+          message.fields.push(field);
+        }
+        const updatedMessage = this.transformers.message.reduce(
+          (message2, transformer) => {
+            return transformer.transform(rootSchema, message2);
+          },
+          message
+        );
+        return updatedMessage;
+      }
+    ).with(
+      {
+        _zod: {
+          def: {
+            type: "enum"
+          }
+        }
+      },
+      (schema) => {
+        const fields = Array.from(schema._zod.values).map((value, index) => {
+          if (typeof value !== "string") {
+            throw new Error(
+              "This `ZodEnum` contains a value that is not a string, this is impossible depending one the `z.enum()` method type"
+            );
+          }
+          return Proto3EnumField.new({
+            index,
+            key: value,
+            extensions: [],
+            comments: []
+          });
+        });
+        const messageEnum = Proto3Enum.new({
+          name: (0, import_change_case3.pascalCase)(name),
+          fields,
+          extensions: [],
+          comments: getZodSchemaComments(rootSchema)
+        });
+        const updatedMessageEnum = this.transformers.enum.reduce(
+          (messageEnum2, transformer) => {
+            return transformer.transform(rootSchema, messageEnum2);
+          },
+          messageEnum
+        );
+        return updatedMessageEnum;
+      }
+    ).exhaustive();
+  }
+};
+
+// src/usage/types/functions.ts
+var Proto3RpcRawFunction = {
+  into: function(raw, settings) {
+    const converter = new ZodMessageConverter(settings.transformers);
+    const inMessageName = raw.typePrefix ? `Input` : `${raw.name}Input`;
+    const outMessageName = raw.typePrefix ? `Output` : `${raw.name}Output`;
+    const convertedIn = raw.in && converter.convert(inMessageName, raw.in);
+    const convertedOut = raw.out && converter.convert(outMessageName, raw.out);
+    return Proto3RpcFunction.new({
+      ...raw,
+      typePrefix: raw.typePrefix,
+      in: convertedIn ?? settings.protoVoidType,
+      inStream: raw.inStream ?? false,
+      out: convertedOut ?? settings.protoVoidType,
+      outStream: raw.outStream ?? false,
+      extensions: raw.extensions ?? [],
+      comments: raw.comments ?? []
+    });
+  }
+};
+
+// src/usage/types/services.ts
+var Proto3RpcRawService = {
+  into: function(raw, settings) {
+    const convertedFunctions = raw.functions.map((rawFunction) => {
+      return Proto3RpcRawFunction.into(rawFunction, settings);
+    });
+    return Proto3RpcService.new({
+      ...raw,
+      typePrefix: raw.typePrefix,
+      functions: convertedFunctions,
+      extensions: raw.extensions ?? [],
+      comments: raw.comments ?? []
+    });
+  }
+};
+
+// src/usage/types/file.ts
+var import_change_case4 = require("change-case");
+var Proto3RawFile = {
+  into: function(raw, settings) {
+    const convertedService = raw.service && Proto3RpcRawService.into(raw.service, settings);
+    raw.unscopedMessages ??= {};
+    const converter = new ZodMessageConverter(settings.transformers);
+    const convertedMessages = [];
+    for (const [name, schema] of Object.entries(raw.unscopedMessages)) {
+      const message = converter.convert((0, import_change_case4.pascalCase)(name), schema);
+      convertedMessages.push(message);
+    }
+    return Proto3File.new({
+      ...raw,
+      syntax: raw.syntax ?? "proto3",
+      service: convertedService,
+      unscopedMessages: convertedMessages,
+      extensions: raw.extensions ?? []
+    });
+  }
+};
+
+// src/usage/helpers/zodToProto.ts
+var zodToProto = function(raw, settings) {
+  const fullSettings = {
+    transformers: settings?.transformers ?? getFullTransformers(),
+    protoVoidType: settings?.protoVoidType ?? Proto3Empty.useType()
+  };
+  const file = Proto3RawFile.into(raw, fullSettings);
+  const processor = new Proto3FileProcessor();
+  const fileContent = processor.process(file);
+  const fileBuilder = new FileBuilder(fileContent);
+  return fileBuilder.compute();
+};
+
+// src/usage/types/message.ts
+var Proto3RpcRawMessage = {
+  safe: function(schema) {
+    return schema;
+  }
+};
+
+// src/zod_converter/helpers/get_empty_transformers.ts
+var getEmptyTranformers = function() {
+  return {
+    message: [],
+    messageField: [],
+    messageOneOfField: [],
+    enum: []
+  };
+};
+
+// src/zod_converter/helpers/is_zod_literal.ts
+var isZodLiteral = function(schema) {
+  return schema._zod.def.type === "literal";
+};
+
+// src/zod_converter/helpers/is_zod_literal_not_nullish_values.ts
+var import_ts_pattern9 = require("ts-pattern");
+var isZodLiteralNotNullishValues = function(schema) {
+  if (!isZodLiteral(schema)) {
+    return false;
+  }
+  return Array.from(schema.values).every((value) => {
+    return (0, import_ts_pattern9.match)(typeof value).with("string", () => true).with("number", () => true).with("bigint", () => true).with("boolean", () => true).otherwise(() => false);
+  });
+};
+
+// src/zod/helpers/zod_one_of_union.ts
+var import_zod = __toESM(require("zod"));
+var oneOfUnion = function(cases) {
+  const unionOptions = cases.map(([caseName, object]) => {
+    return import_zod.default.object({ $case: import_zod.default.literal(caseName), value: object });
+  });
+  assertsNotEmptyArray(unionOptions);
+  return import_zod.default.discriminatedUnion("$case", unionOptions);
+};
+var pz = {
+  oneOfUnion
+};