Source file descriptor.ml

(********************************************************)
(*           AUTOGENERATED FILE - DO NOT EDIT!          *)
(********************************************************)
(* Generated by: ocaml-protoc-plugin                    *)
(* https://github.com/andersfugmann/ocaml-protoc-plugin *)
(********************************************************)
(*
  Source: google/protobuf/descriptor.proto
  Syntax: proto2
  Parameters:
    debug=false
    annot=''
    opens=[]
    int64_as_int=true
    int32_as_int=true
    fixed_as_int=false
    singleton_record=false
    prefix_output_with_package=false
*)
[@@@ocaml.alert "-protobuf"] (* Disable deprecation warnings for protobuf*)
(**/**)
module Runtime' = Ocaml_protoc_plugin [@@warning "-33"]
module Imported'modules = struct
end
(**/**)
module rec Google : sig
  module rec Protobuf : sig

    (**
{%html:
<p>The full set of known editions.</p>
%}
    *)
    module rec Edition : sig
      type t =
        | EDITION_UNKNOWN
        (**
{%html:
<p>A placeholder for an unknown edition value.</p>
%}
        *)

        | EDITION_LEGACY
        (**
{%html:
<p>A placeholder edition for specifying default behaviors <em>before</em> a feature
was first introduced.  This is effectively an &quot;infinite past&quot;.</p>
%}
        *)

        | EDITION_PROTO2
        (**
{%html:
<p>Legacy syntax &quot;editions&quot;.  These pre-date editions, but behave much like
distinct editions.  These can't be used to specify the edition of proto
files, but feature definitions must supply proto2/proto3 defaults for
backwards compatibility.</p>
%}
        *)

        | EDITION_PROTO3
        | EDITION_2023
        (**
{%html:
<p>Editions that have been released.  The specific values are arbitrary and
should not be depended on, but they will always be time-ordered for easy
comparison.</p>
%}
        *)

        | EDITION_2024
        | EDITION_UNSTABLE
        (**
{%html:
<p>A placeholder edition for developing and testing unscheduled features.</p>
%}
        *)

        | EDITION_1_TEST_ONLY
        (**
{%html:
<p>Placeholder editions for testing feature resolution.  These should not be
used or relied on outside of tests.</p>
%}
        *)

        | EDITION_2_TEST_ONLY
        | EDITION_99997_TEST_ONLY
        | EDITION_99998_TEST_ONLY
        | EDITION_99999_TEST_ONLY
        | EDITION_MAX
        (**
{%html:
<p>Placeholder for specifying unbounded edition support.  This should only
ever be used by plugins that can expect to never require any changes to
support a new edition.</p>
%}
        *)


      val name: unit -> string
      (** Fully qualified protobuf name of this enum *)

      (**/**)
      val to_int: t -> int
      val from_int: int -> t Runtime'.Result.t
      val from_int_exn: int -> t
      val to_string: t -> string
      val from_string_exn: string -> t
      (**/**)
    end


    (**
{%html:
<p>Describes the 'visibility' of a symbol with respect to the proto import
system. Symbols can only be imported when the visibility rules do not prevent
it (ex: local symbols cannot be imported).  Visibility modifiers can only set
on <code>message</code> and <code>enum</code> as they are the only types available to be referenced
from other files.</p>
%}
    *)
    and SymbolVisibility : sig
      type t =
        | VISIBILITY_UNSET
        | VISIBILITY_LOCAL
        | VISIBILITY_EXPORT

      val name: unit -> string
      (** Fully qualified protobuf name of this enum *)

      (**/**)
      val to_int: t -> int
      val from_int: int -> t Runtime'.Result.t
      val from_int_exn: int -> t
      val to_string: t -> string
      val from_string_exn: string -> t
      (**/**)
    end


    (**
{%html:
<p>The protocol compiler can output a FileDescriptorSet containing the .proto
files it parses.</p>
%}
    *)
    and FileDescriptorSet : sig
      type t = {
        file:FileDescriptorProto.t list;
        extensions':Runtime'.Extensions.t;
      }
      val make: ?file:FileDescriptorProto.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?file:FileDescriptorProto.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end


    (**
{%html:
<p>Describes a complete .proto file.</p>
%}
    *)
    and FileDescriptorProto : sig
      type t = {
        name:string option;
        (**
{%html:
<p>file name, relative to root of source tree</p>
%}
        *)

        package:string option;
        (**
{%html:
<p>e.g. &quot;foo&quot;, &quot;foo.bar&quot;, etc.</p>
%}
        *)

        dependency:string list;
        (**
{%html:
<p>Names of files imported by this file.</p>
%}
        *)

        message_type:DescriptorProto.t list;
        (**
{%html:
<p>All top-level definitions in this file.</p>
%}
        *)

        enum_type:EnumDescriptorProto.t list;
        service:ServiceDescriptorProto.t list;
        extension:FieldDescriptorProto.t list;
        options:FileOptions.t option;
        source_code_info:SourceCodeInfo.t option;
        (**
{%html:
<p>This field contains optional information about the original source code.
You may safely remove this entire field without harming runtime
functionality of the descriptors -- the information is needed only by
development tools.</p>
%}
        *)

        public_dependency:int list;
        (**
{%html:
<p>Indexes of the public imported files in the dependency list above.</p>
%}
        *)

        weak_dependency:int list;
        (**
{%html:
<p>Indexes of the weak imported files in the dependency list.
For Google-internal migration only. Do not use.</p>
%}
        *)

        syntax:string option;
        (**
{%html:
<p>The syntax of the proto file.
The supported values are &quot;proto2&quot;, &quot;proto3&quot;, and &quot;editions&quot;.</p>
<p>If <code>edition</code> is present, this value must be &quot;editions&quot;.
WARNING: This field should only be used by protobuf plugins or special
cases like the proto compiler. Other uses are discouraged and
developers should rely on the protoreflect APIs for their client language.</p>
%}
        *)

        edition:Edition.t option;
        (**
{%html:
<p>The edition of the proto file.
WARNING: This field should only be used by protobuf plugins or special
cases like the proto compiler. Other uses are discouraged and
developers should rely on the protoreflect APIs for their client language.</p>
%}
        *)

        option_dependency:string list;
        (**
{%html:
<p>Names of files imported by this file purely for the purpose of providing
option extensions. These are excluded from the dependency list above.</p>
%}
        *)

      }
      val make: ?name:string -> ?package:string -> ?dependency:string list -> ?message_type:DescriptorProto.t list -> ?enum_type:EnumDescriptorProto.t list -> ?service:ServiceDescriptorProto.t list -> ?extension:FieldDescriptorProto.t list -> ?options:FileOptions.t -> ?source_code_info:SourceCodeInfo.t -> ?public_dependency:int list -> ?weak_dependency:int list -> ?syntax:string -> ?edition:Edition.t -> ?option_dependency:string list -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?name:string -> ?package:string -> ?dependency:string list -> ?message_type:DescriptorProto.t list -> ?enum_type:EnumDescriptorProto.t list -> ?service:ServiceDescriptorProto.t list -> ?extension:FieldDescriptorProto.t list -> ?options:FileOptions.t -> ?source_code_info:SourceCodeInfo.t -> ?public_dependency:int list -> ?weak_dependency:int list -> ?syntax:string -> ?edition:Edition.t -> ?option_dependency:string list -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end


    (**
{%html:
<p>Describes a message type.</p>
%}
    *)
    and DescriptorProto : sig
      module rec ExtensionRange : sig
        type t = {
          start:int option;
          (**
{%html:
<p>Inclusive.</p>
%}
          *)

          end':int option;
          (**
{%html:
<p>Exclusive.</p>
%}
          *)

          options:ExtensionRangeOptions.t option;
        }
        val make: ?start:int -> ?end':int -> ?options:ExtensionRangeOptions.t -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?start:int -> ?end':int -> ?options:ExtensionRangeOptions.t -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end


      (**
{%html:
<p>Range of reserved tag numbers. Reserved tag numbers may not be used by
fields or extension ranges in the same message. Reserved ranges may
not overlap.</p>
%}
      *)
      and ReservedRange : sig
        type t = {
          start:int option;
          (**
{%html:
<p>Inclusive.</p>
%}
          *)

          end':int option;
          (**
{%html:
<p>Exclusive.</p>
%}
          *)

        }
        val make: ?start:int -> ?end':int -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?start:int -> ?end':int -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end

      type t = {
        name:string option;
        field:FieldDescriptorProto.t list;
        nested_type:t list;
        enum_type:EnumDescriptorProto.t list;
        extension_range:ExtensionRange.t list;
        extension:FieldDescriptorProto.t list;
        options:MessageOptions.t option;
        oneof_decl:OneofDescriptorProto.t list;
        reserved_range:ReservedRange.t list;
        reserved_name:string list;
        (**
{%html:
<p>Reserved field names, which may not be used by fields in the same message.
A given name may only be reserved once.</p>
%}
        *)

        visibility:SymbolVisibility.t option;
        (**
{%html:
<p>Support for <code>export</code> and <code>local</code> keywords on enums.</p>
%}
        *)

      }
      val make: ?name:string -> ?field:FieldDescriptorProto.t list -> ?nested_type:t list -> ?enum_type:EnumDescriptorProto.t list -> ?extension_range:ExtensionRange.t list -> ?extension:FieldDescriptorProto.t list -> ?options:MessageOptions.t -> ?oneof_decl:OneofDescriptorProto.t list -> ?reserved_range:ReservedRange.t list -> ?reserved_name:string list -> ?visibility:SymbolVisibility.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?name:string -> ?field:FieldDescriptorProto.t list -> ?nested_type:t list -> ?enum_type:EnumDescriptorProto.t list -> ?extension_range:ExtensionRange.t list -> ?extension:FieldDescriptorProto.t list -> ?options:MessageOptions.t -> ?oneof_decl:OneofDescriptorProto.t list -> ?reserved_range:ReservedRange.t list -> ?reserved_name:string list -> ?visibility:SymbolVisibility.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end

    and ExtensionRangeOptions : sig

      (**
{%html:
<p>The verification state of the extension range.</p>
%}
      *)
      module rec VerificationState : sig
        type t =
          | DECLARATION
          (**
{%html:
<p>All the extensions of the range must be declared.</p>
%}
          *)

          | UNVERIFIED

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      and Declaration : sig
        type t = {
          number:int option;
          (**
{%html:
<p>The extension number declared within the extension range.</p>
%}
          *)

          full_name:string option;
          (**
{%html:
<p>The fully-qualified name of the extension field. There must be a leading
dot in front of the full name.</p>
%}
          *)

          type':string option;
          (**
{%html:
<p>The fully-qualified type name of the extension field. Unlike
Metadata.type, Declaration.type must have a leading dot for messages
and enums.</p>
%}
          *)

          reserved:bool option;
          (**
{%html:
<p>If true, indicates that the number is reserved in the extension range,
and any extension field with the number will fail to compile. Set this
when a declared extension field is deleted.</p>
%}
          *)

          repeated:bool option;
          (**
{%html:
<p>If true, indicates that the extension must be defined as repeated.
Otherwise the extension must be defined as optional.</p>
%}
          *)

        }
        val make: ?number:int -> ?full_name:string -> ?type':string -> ?reserved:bool -> ?repeated:bool -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?number:int -> ?full_name:string -> ?type':string -> ?reserved:bool -> ?repeated:bool -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end

      type t = {
        declaration:Declaration.t list;
        (**
{%html:
<p>For external users: DO NOT USE. We are in the process of open sourcing
extension declaration and executing internal cleanups before it can be
used externally.</p>
%}
        *)

        verification:VerificationState.t;
        (**
{%html:
<p>The verification state of the range.
TODO: flip the default to DECLARATION once all empty ranges
are marked as UNVERIFIED.</p>
%}
        *)

        features:FeatureSet.t option;
        (**
{%html:
<p>Any features defined in the specific edition.</p>
%}
        *)

        uninterpreted_option:UninterpretedOption.t list;
        (**
{%html:
<p>The parser stores options it doesn't recognize here. See above.</p>
%}
        *)

        extensions':Runtime'.Extensions.t;
      }
      val make: ?declaration:Declaration.t list -> ?verification:VerificationState.t -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?declaration:Declaration.t list -> ?verification:VerificationState.t -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end


    (**
{%html:
<p>Describes a field within a message.</p>
%}
    *)
    and FieldDescriptorProto : sig
      module rec Type : sig
        type t =
          | TYPE_DOUBLE
          (**
{%html:
<p>0 is reserved for errors.
Order is weird for historical reasons.</p>
%}
          *)

          | TYPE_FLOAT
          | TYPE_INT64
          (**
{%html:
<p>Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT64 if
negative values are likely.</p>
%}
          *)

          | TYPE_UINT64
          | TYPE_INT32
          (**
{%html:
<p>Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT32 if
negative values are likely.</p>
%}
          *)

          | TYPE_FIXED64
          | TYPE_FIXED32
          | TYPE_BOOL
          | TYPE_STRING
          | TYPE_GROUP
          (**
{%html:
<p>Tag-delimited aggregate.
Group type is deprecated and not supported after google.protobuf. However, Proto3
implementations should still be able to parse the group wire format and
treat group fields as unknown fields.  In Editions, the group wire format
can be enabled via the <code>message_encoding</code> feature.</p>
%}
          *)

          | TYPE_MESSAGE
          (**
{%html:
<p>Length-delimited aggregate.</p>
%}
          *)

          | TYPE_BYTES
          (**
{%html:
<p>New in version 2.</p>
%}
          *)

          | TYPE_UINT32
          | TYPE_ENUM
          | TYPE_SFIXED32
          | TYPE_SFIXED64
          | TYPE_SINT32
          (**
{%html:
<p>Uses ZigZag encoding.</p>
%}
          *)

          | TYPE_SINT64
          (**
{%html:
<p>Uses ZigZag encoding.</p>
%}
          *)


        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      and Label : sig
        type t =
          | LABEL_OPTIONAL
          (**
{%html:
<p>0 is reserved for errors</p>
%}
          *)

          | LABEL_REPEATED
          | LABEL_REQUIRED
          (**
{%html:
<p>The required label is only allowed in google.protobuf.  In proto3 and Editions
it's explicitly prohibited.  In Editions, the <code>field_presence</code> feature
can be used to get this behavior.</p>
%}
          *)


        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      type t = {
        name:string option;
        extendee:string option;
        (**
{%html:
<p>For extensions, this is the name of the type being extended.  It is
resolved in the same manner as type_name.</p>
%}
        *)

        number:int option;
        label:Label.t option;
        type':Type.t option;
        (**
{%html:
<p>If type_name is set, this need not be set.  If both this and type_name
are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.</p>
%}
        *)

        type_name:string option;
        (**
{%html:
<p>For message and enum types, this is the name of the type.  If the name
starts with a '.', it is fully-qualified.  Otherwise, C++-like scoping
rules are used to find the type (i.e. first the nested types within this
message are searched, then within the parent, on up to the root
namespace).</p>
%}
        *)

        default_value:string option;
        (**
{%html:
<p>For numeric types, contains the original text representation of the value.
For booleans, &quot;true&quot; or &quot;false&quot;.
For strings, contains the default text contents (not escaped in any way).
For bytes, contains the C escaped value.  All bytes &gt;= 128 are escaped.</p>
%}
        *)

        options:FieldOptions.t option;
        oneof_index:int option;
        (**
{%html:
<p>If set, gives the index of a oneof in the containing type's oneof_decl
list.  This field is a member of that oneof.</p>
%}
        *)

        json_name:string option;
        (**
{%html:
<p>JSON name of this field. The value is set by protocol compiler. If the
user has set a &quot;json_name&quot; option on this field, that option's value
will be used. Otherwise, it's deduced from the field's name by converting
it to camelCase.</p>
%}
        *)

        proto3_optional:bool option;
        (**
{%html:
<p>If true, this is a proto3 &quot;optional&quot;. When a proto3 field is optional, it
tracks presence regardless of field type.</p>
<p>When proto3_optional is true, this field must belong to a oneof to signal
to old proto3 clients that presence is tracked for this field. This oneof
is known as a &quot;synthetic&quot; oneof, and this field must be its sole member
(each proto3 optional field gets its own synthetic oneof). Synthetic oneofs
exist in the descriptor only, and do not generate any API. Synthetic oneofs
must be ordered after all &quot;real&quot; oneofs.</p>
<p>For message fields, proto3_optional doesn't create any semantic change,
since non-repeated message fields always track presence. However it still
indicates the semantic detail of whether the user wrote &quot;optional&quot; or not.
This can be useful for round-tripping the .proto file. For consistency we
give message fields a synthetic oneof also, even though it is not required
to track presence. This is especially important because the parser can't
tell if a field is a message or an enum, so it must always create a
synthetic oneof.</p>
<p>Proto2 optional fields do not set this flag, because they already indicate
optional with <code>LABEL_OPTIONAL</code>.</p>
%}
        *)

      }
      val make: ?name:string -> ?extendee:string -> ?number:int -> ?label:Label.t -> ?type':Type.t -> ?type_name:string -> ?default_value:string -> ?options:FieldOptions.t -> ?oneof_index:int -> ?json_name:string -> ?proto3_optional:bool -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?name:string -> ?extendee:string -> ?number:int -> ?label:Label.t -> ?type':Type.t -> ?type_name:string -> ?default_value:string -> ?options:FieldOptions.t -> ?oneof_index:int -> ?json_name:string -> ?proto3_optional:bool -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end


    (**
{%html:
<p>Describes a oneof.</p>
%}
    *)
    and OneofDescriptorProto : sig
      type t = {
        name:string option;
        options:OneofOptions.t option;
      }
      val make: ?name:string -> ?options:OneofOptions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?name:string -> ?options:OneofOptions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end


    (**
{%html:
<p>Describes an enum type.</p>
%}
    *)
    and EnumDescriptorProto : sig

      (**
{%html:
<p>Range of reserved numeric values. Reserved values may not be used by
entries in the same enum. Reserved ranges may not overlap.</p>
<p>Note that this is distinct from DescriptorProto.ReservedRange in that it
is inclusive such that it can appropriately represent the entire int32
domain.</p>
%}
      *)
      module rec EnumReservedRange : sig
        type t = {
          start:int option;
          (**
{%html:
<p>Inclusive.</p>
%}
          *)

          end':int option;
          (**
{%html:
<p>Inclusive.</p>
%}
          *)

        }
        val make: ?start:int -> ?end':int -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?start:int -> ?end':int -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end

      type t = {
        name:string option;
        value:EnumValueDescriptorProto.t list;
        options:EnumOptions.t option;
        reserved_range:EnumReservedRange.t list;
        (**
{%html:
<p>Range of reserved numeric values. Reserved numeric values may not be used
by enum values in the same enum declaration. Reserved ranges may not
overlap.</p>
%}
        *)

        reserved_name:string list;
        (**
{%html:
<p>Reserved enum value names, which may not be reused. A given name may only
be reserved once.</p>
%}
        *)

        visibility:SymbolVisibility.t option;
        (**
{%html:
<p>Support for <code>export</code> and <code>local</code> keywords on enums.</p>
%}
        *)

      }
      val make: ?name:string -> ?value:EnumValueDescriptorProto.t list -> ?options:EnumOptions.t -> ?reserved_range:EnumReservedRange.t list -> ?reserved_name:string list -> ?visibility:SymbolVisibility.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?name:string -> ?value:EnumValueDescriptorProto.t list -> ?options:EnumOptions.t -> ?reserved_range:EnumReservedRange.t list -> ?reserved_name:string list -> ?visibility:SymbolVisibility.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end


    (**
{%html:
<p>Describes a value within an enum.</p>
%}
    *)
    and EnumValueDescriptorProto : sig
      type t = {
        name:string option;
        number:int option;
        options:EnumValueOptions.t option;
      }
      val make: ?name:string -> ?number:int -> ?options:EnumValueOptions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?name:string -> ?number:int -> ?options:EnumValueOptions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end


    (**
{%html:
<p>Describes a service.</p>
%}
    *)
    and ServiceDescriptorProto : sig
      type t = {
        name:string option;
        method':MethodDescriptorProto.t list;
        options:ServiceOptions.t option;
      }
      val make: ?name:string -> ?method':MethodDescriptorProto.t list -> ?options:ServiceOptions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?name:string -> ?method':MethodDescriptorProto.t list -> ?options:ServiceOptions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end


    (**
{%html:
<p>Describes a method of a service.</p>
%}
    *)
    and MethodDescriptorProto : sig
      type t = {
        name:string option;
        input_type:string option;
        (**
{%html:
<p>Input and output type names.  These are resolved in the same way as
FieldDescriptorProto.type_name, but must refer to a message type.</p>
%}
        *)

        output_type:string option;
        options:MethodOptions.t option;
        client_streaming:bool;
        (**
{%html:
<p>Identifies if client streams multiple client messages</p>
%}
        *)

        server_streaming:bool;
        (**
{%html:
<p>Identifies if server streams multiple server messages</p>
%}
        *)

      }
      val make: ?name:string -> ?input_type:string -> ?output_type:string -> ?options:MethodOptions.t -> ?client_streaming:bool -> ?server_streaming:bool -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?name:string -> ?input_type:string -> ?output_type:string -> ?options:MethodOptions.t -> ?client_streaming:bool -> ?server_streaming:bool -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end


    (**
{%html:
<p>===================================================================
Options</p>
<p>Each of the definitions above may have &quot;options&quot; attached.  These are
just annotations which may cause code to be generated slightly differently
or may contain hints for code that manipulates protocol messages.</p>
<p>Clients may define custom options as extensions of the *Options messages.
These extensions may not yet be known at parsing time, so the parser cannot
store the values in them.  Instead it stores them in a field in the *Options
message called uninterpreted_option. This field must have the same name
across all *Options messages. We then use this field to populate the
extensions when we build a descriptor, at which point all protos have been
parsed and so all extensions are known.</p>
<p>Extension numbers for custom options may be chosen as follows:</p>
<ul>
<li>
<p>For options which will only be used within a single application or</p>
<p>organization, or for experimental options, use field numbers 50000
through 99999.  It is up to you to ensure that you do not use the
same number for multiple options.</p>
</li>
<li>
<p>For options which will be published and used publicly by multiple</p>
<p>independent entities, e-mail protobuf-global-extension-registry@google.com
to reserve extension numbers. Simply provide your project name (e.g.
Objective-C plugin) and your project website (if available) -- there's no
need to explain how you intend to use them. Usually you only need one
extension number. You can declare multiple options with only one extension
number by putting them in a sub-message. See the Custom Options section of
the docs for examples:
https://developers.google.com/protocol-buffers/docs/proto#options
If this turns out to be popular, a web service will be set up
to automatically assign option numbers.</p>
</li>
</ul>
%}
    *)
    and FileOptions : sig

      (**
{%html:
<p>Generated classes can be optimized for speed or code size.</p>
%}
      *)
      module rec OptimizeMode : sig
        type t =
          | SPEED
          (**
{%html:
<p>Generate complete code for parsing, serialization,</p>
%}
          *)

          | CODE_SIZE
          (**
{%html:
<p>etc.</p>
<p>Use ReflectionOps to implement these methods.</p>
%}
          *)

          | LITE_RUNTIME
          (**
{%html:
<p>Generate code using MessageLite and the lite runtime.</p>
%}
          *)


        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      type t = {
        java_package:string option;
        (**
{%html:
<p>Sets the Java package where classes generated from this .proto will be
placed.  By default, the proto package is used, but this is often
inappropriate because proto packages do not normally start with backwards
domain names.</p>
%}
        *)

        java_outer_classname:string option;
        (**
{%html:
<p>Controls the name of the wrapper Java class generated for the .proto file.
That class will always contain the .proto file's getDescriptor() method as
well as any top-level extensions defined in the .proto file.
If java_multiple_files is disabled, then all the other classes from the
.proto file will be nested inside the single wrapper outer class.</p>
%}
        *)

        optimize_for:OptimizeMode.t;
        (**
{%html:
<p>Clients can define custom options in extensions of this message.
See the documentation for the &quot;Options&quot; section above.</p>
%}
        *)

        java_multiple_files:bool;
        (**
{%html:
<p>If enabled, then the Java code generator will generate a separate .java
file for each top-level message, enum, and service defined in the .proto
file.  Thus, these types will <em>not</em> be nested inside the wrapper class
named by java_outer_classname.  However, the wrapper class will still be
generated to contain the file's getDescriptor() method as well as any
top-level extensions defined in the file.</p>
%}
        *)

        go_package:string option;
        (**
{%html:
<p>Sets the Go package where structs generated from this .proto will be
placed. If omitted, the Go package will be derived from the following:</p>
<ul>
<li>The basename of the package import path, if provided.
</li>
<li>Otherwise, the package statement in the .proto file, if present.
</li>
<li>Otherwise, the basename of the .proto file, without extension.
</li>
</ul>
%}
        *)

        cc_generic_services:bool;
        (**
{%html:
<p>Should generic services be generated in each language?  &quot;Generic&quot; services
are not specific to any particular RPC system.  They are generated by the
main code generators in each language (without additional plugins).
Generic services were the only kind of service generation supported by
early versions of google.protobuf.</p>
<p>Generic services are now considered deprecated in favor of using plugins
that generate code specific to your particular RPC system.  Therefore,
these default to false.  Old code which depends on generic services should
explicitly set them to true.</p>
%}
        *)

        java_generic_services:bool;
        py_generic_services:bool;
        (**
{%html:
<p>removed php_generic_services</p>
%}
        *)

        java_generate_equals_and_hash:bool option[@ocaml.alert protobuf "Marked as deprecated in the .proto file"];
        (**
{%html:
<p>This option does nothing.</p>
%}
        *)

        deprecated:bool;
        (**
{%html:
<p>Is this file deprecated?
Depending on the target platform, this can emit Deprecated annotations
for everything in the file, or it will be completely ignored; in the very
least, this is a formalization for deprecating files.</p>
%}
        *)

        java_string_check_utf8:bool;
        (**
{%html:
<p>A proto2 file can set this to true to opt in to UTF-8 checking for Java,
which will throw an exception if invalid UTF-8 is parsed from the wire or
assigned to a string field.</p>
<p>TODO: clarify exactly what kinds of field types this option
applies to, and update these docs accordingly.</p>
<p>Proto3 files already perform these checks. Setting the option explicitly to
false has no effect: it cannot be used to opt proto3 files out of UTF-8
checks.</p>
%}
        *)

        cc_enable_arenas:bool;
        (**
{%html:
<p>Enables the use of arenas for the proto messages in this file. This applies
only to generated classes for C++.</p>
%}
        *)

        objc_class_prefix:string option;
        (**
{%html:
<p>Sets the objective c class prefix which is prepended to all objective c
generated classes from this .proto. There is no default.</p>
%}
        *)

        csharp_namespace:string option;
        (**
{%html:
<p>Namespace for generated classes; defaults to the package.</p>
%}
        *)

        swift_prefix:string option;
        (**
{%html:
<p>By default Swift generators will take the proto package and CamelCase it
replacing '.' with underscore and use that to prefix the types/symbols
defined. When this options is provided, they will use this value instead
to prefix the types/symbols defined.</p>
%}
        *)

        php_class_prefix:string option;
        (**
{%html:
<p>Sets the php class prefix which is prepended to all php generated classes
from this .proto. Default is empty.</p>
%}
        *)

        php_namespace:string option;
        (**
{%html:
<p>Use this option to change the namespace of php generated classes. Default
is empty. When this option is empty, the package name will be used for
determining the namespace.</p>
%}
        *)

        php_metadata_namespace:string option;
        (**
{%html:
<p>Use this option to change the namespace of php generated metadata classes.
Default is empty. When this option is empty, the proto file name will be
used for determining the namespace.</p>
%}
        *)

        ruby_package:string option;
        (**
{%html:
<p>Use this option to change the package of ruby generated classes. Default
is empty. When this option is not set, the package name will be used for
determining the ruby package.</p>
%}
        *)

        features:FeatureSet.t option;
        (**
{%html:
<p>Any features defined in the specific edition.
WARNING: This field should only be used by protobuf plugins or special
cases like the proto compiler. Other uses are discouraged and
developers should rely on the protoreflect APIs for their client language.</p>
%}
        *)

        uninterpreted_option:UninterpretedOption.t list;
        (**
{%html:
<p>The parser stores options it doesn't recognize here.
See the documentation for the &quot;Options&quot; section above.</p>
%}
        *)

        extensions':Runtime'.Extensions.t;
      }
      val make: ?java_package:string -> ?java_outer_classname:string -> ?optimize_for:OptimizeMode.t -> ?java_multiple_files:bool -> ?go_package:string -> ?cc_generic_services:bool -> ?java_generic_services:bool -> ?py_generic_services:bool -> ?java_generate_equals_and_hash:bool -> ?deprecated:bool -> ?java_string_check_utf8:bool -> ?cc_enable_arenas:bool -> ?objc_class_prefix:string -> ?csharp_namespace:string -> ?swift_prefix:string -> ?php_class_prefix:string -> ?php_namespace:string -> ?php_metadata_namespace:string -> ?ruby_package:string -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?java_package:string -> ?java_outer_classname:string -> ?optimize_for:OptimizeMode.t -> ?java_multiple_files:bool -> ?go_package:string -> ?cc_generic_services:bool -> ?java_generic_services:bool -> ?py_generic_services:bool -> ?java_generate_equals_and_hash:bool -> ?deprecated:bool -> ?java_string_check_utf8:bool -> ?cc_enable_arenas:bool -> ?objc_class_prefix:string -> ?csharp_namespace:string -> ?swift_prefix:string -> ?php_class_prefix:string -> ?php_namespace:string -> ?php_metadata_namespace:string -> ?ruby_package:string -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end

    and MessageOptions : sig
      type t = {
        message_set_wire_format:bool;
        (**
{%html:
<p>Set true to use the old proto1 MessageSet wire format for extensions.
This is provided for backwards-compatibility with the MessageSet wire
format.  You should not use this for any other reason:  It's less
efficient, has fewer features, and is more complicated.</p>
<p>The message must be defined exactly as follows:</p>
<pre><code> message Foo {
   option message_set_wire_format = true;
   extensions 4 to max;
 }
</code></pre>
<p>Note that the message cannot have any defined fields; MessageSets only
have extensions.</p>
<p>All extensions of your type must be singular messages; e.g. they cannot
be int32s, enums, or repeated messages.</p>
<p>Because this is an option, the above two restrictions are not enforced by
the protocol compiler.</p>
%}
        *)

        no_standard_descriptor_accessor:bool;
        (**
{%html:
<p>Disables the generation of the standard &quot;descriptor()&quot; accessor, which can
conflict with a field of the same name.  This is meant to make migration
from proto1 easier; new code should avoid fields named &quot;descriptor&quot;.</p>
%}
        *)

        deprecated:bool;
        (**
{%html:
<p>Is this message deprecated?
Depending on the target platform, this can emit Deprecated annotations
for the message, or it will be completely ignored; in the very least,
this is a formalization for deprecating messages.</p>
%}
        *)

        map_entry:bool option;
        (**
{%html:
<p>Whether the message is an automatically generated map entry type for the
maps field.</p>
<p>For maps fields:</p>
<pre><code> map&lt;KeyType, ValueType&gt; map_field = 1;
</code></pre>
<p>The parsed descriptor looks like:</p>
<pre><code> message MapFieldEntry {
     option map_entry = true;
     optional KeyType key = 1;
     optional ValueType value = 2;
 }
 repeated MapFieldEntry map_field = 1;
</code></pre>
<p>Implementations may choose not to generate the map_entry=true message, but
use a native map in the target language to hold the keys and values.
The reflection APIs in such implementations still need to work as
if the field is a repeated message field.</p>
<p>NOTE: Do not set the option in .proto files. Always use the maps syntax
instead. The option should only be implicitly set by the proto compiler
parser.</p>
%}
        *)

        deprecated_legacy_json_field_conflicts:bool option[@ocaml.alert protobuf "Marked as deprecated in the .proto file"];
        (**
{%html:
<p>Enable the legacy handling of JSON field name conflicts.  This lowercases
and strips underscored from the fields before comparison in proto3 only.
The new behavior takes <code>json_name</code> into account and applies to proto2 as
well.</p>
<p>This should only be used as a temporary measure against broken builds due
to the change in behavior for JSON field name conflicts.</p>
<p>TODO This is legacy behavior we plan to remove once downstream
teams have had time to migrate.</p>
%}
        *)

        features:FeatureSet.t option;
        (**
{%html:
<p>Clients can define custom options in extensions of this message. See above.</p>
%}
        *)

        uninterpreted_option:UninterpretedOption.t list;
        (**
{%html:
<p>The parser stores options it doesn't recognize here. See above.</p>
%}
        *)

        extensions':Runtime'.Extensions.t;
      }
      val make: ?message_set_wire_format:bool -> ?no_standard_descriptor_accessor:bool -> ?deprecated:bool -> ?map_entry:bool -> ?deprecated_legacy_json_field_conflicts:bool -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?message_set_wire_format:bool -> ?no_standard_descriptor_accessor:bool -> ?deprecated:bool -> ?map_entry:bool -> ?deprecated_legacy_json_field_conflicts:bool -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end

    and FieldOptions : sig
      module rec CType : sig
        type t =
          | STRING
          (**
{%html:
<p>Default mode.</p>
%}
          *)

          | CORD
          (**
{%html:
<p>The option [ctype=CORD] may be applied to a non-repeated field of type
&quot;bytes&quot;. It indicates that in C++, the data should be stored in a Cord
instead of a string.  For very large strings, this may reduce memory
fragmentation. It may also allow better performance when parsing from a
Cord, or when parsing with aliasing enabled, as the parsed Cord may then
alias the original buffer.</p>
%}
          *)

          | STRING_PIECE

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      and JSType : sig
        type t =
          | JS_NORMAL
          (**
{%html:
<p>Use the default type.</p>
%}
          *)

          | JS_STRING
          (**
{%html:
<p>Use JavaScript strings.</p>
%}
          *)

          | JS_NUMBER
          (**
{%html:
<p>Use JavaScript numbers.</p>
%}
          *)


        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end


      (**
{%html:
<p>If set to RETENTION_SOURCE, the option will be omitted from the binary.</p>
%}
      *)
      and OptionRetention : sig
        type t =
          | RETENTION_UNKNOWN
          | RETENTION_RUNTIME
          | RETENTION_SOURCE

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end


      (**
{%html:
<p>This indicates the types of entities that the field may apply to when used
as an option. If it is unset, then the field may be freely used as an
option on any kind of entity.</p>
%}
      *)
      and OptionTargetType : sig
        type t =
          | TARGET_TYPE_UNKNOWN
          | TARGET_TYPE_FILE
          | TARGET_TYPE_EXTENSION_RANGE
          | TARGET_TYPE_MESSAGE
          | TARGET_TYPE_FIELD
          | TARGET_TYPE_ONEOF
          | TARGET_TYPE_ENUM
          | TARGET_TYPE_ENUM_ENTRY
          | TARGET_TYPE_SERVICE
          | TARGET_TYPE_METHOD

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      and EditionDefault : sig
        type t = {
          value:string option;
          (**
{%html:
<p>Textproto value.</p>
%}
          *)

          edition:Edition.t option;
        }
        val make: ?value:string -> ?edition:Edition.t -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?value:string -> ?edition:Edition.t -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end


      (**
{%html:
<p>Information about the support window of a feature.</p>
%}
      *)
      and FeatureSupport : sig
        type t = {
          edition_introduced:Edition.t option;
          (**
{%html:
<p>The edition that this feature was first available in.  In editions
earlier than this one, the default assigned to EDITION_LEGACY will be
used, and proto files will not be able to override it.</p>
%}
          *)

          edition_deprecated:Edition.t option;
          (**
{%html:
<p>The edition this feature becomes deprecated in.  Using this after this
edition may trigger warnings.</p>
%}
          *)

          deprecation_warning:string option;
          (**
{%html:
<p>The deprecation warning text if this feature is used after the edition it
was marked deprecated in.</p>
%}
          *)

          edition_removed:Edition.t option;
          (**
{%html:
<p>The edition this feature is no longer available in.  In editions after
this one, the last default assigned will be used, and proto files will
not be able to override it.</p>
%}
          *)

          removal_error:string option;
          (**
{%html:
<p>The removal error text if this feature is used after the edition it was
removed in.</p>
%}
          *)

        }
        val make: ?edition_introduced:Edition.t -> ?edition_deprecated:Edition.t -> ?deprecation_warning:string -> ?edition_removed:Edition.t -> ?removal_error:string -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?edition_introduced:Edition.t -> ?edition_deprecated:Edition.t -> ?deprecation_warning:string -> ?edition_removed:Edition.t -> ?removal_error:string -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end

      type t = {
        ctype:CType.t;
        (**
{%html:
<p>NOTE: ctype is deprecated. Use <code>features.(pb.cpp).string_type</code> instead.
The ctype option instructs the C++ code generator to use a different
representation of the field than it normally would.  See the specific
options below.  This option is only implemented to support use of
[ctype=CORD] and [ctype=STRING] (the default) on non-repeated fields of
type &quot;bytes&quot; in the open source release.
TODO: make ctype actually deprecated.</p>
%}
        *)

        packed:bool option;
        (**
{%html:
<p>The packed option can be enabled for repeated primitive fields to enable
a more efficient representation on the wire. Rather than repeatedly
writing the tag and type for each element, the entire array is encoded as
a single length-delimited blob. In proto3, only explicit setting it to
false will avoid using packed encoding.  This option is prohibited in
Editions, but the <code>repeated_field_encoding</code> feature can be used to control
the behavior.</p>
%}
        *)

        deprecated:bool;
        (**
{%html:
<p>Clients can define custom options in extensions of this message. See above.</p>
%}
        *)

        lazy':bool;
        (**
{%html:
<p>Should this field be parsed lazily?  Lazy applies only to message-type
fields.  It means that when the outer message is initially parsed, the
inner message's contents will not be parsed but instead stored in encoded
form.  The inner message will actually be parsed when it is first accessed.</p>
<p>This is only a hint.  Implementations are free to choose whether to use
eager or lazy parsing regardless of the value of this option.  However,
setting this option true suggests that the protocol author believes that
using lazy parsing on this field is worth the additional bookkeeping
overhead typically needed to implement it.</p>
<p>This option does not affect the public interface of any generated code;
all method signatures remain the same.  Furthermore, thread-safety of the
interface is not affected by this option; const methods remain safe to
call from multiple threads concurrently, while non-const methods continue
to require exclusive access.</p>
<p>Note that lazy message fields are still eagerly verified to check
ill-formed wireformat or missing required fields. Calling IsInitialized()
on the outer message would fail if the inner message has missing required
fields. Failed verification would result in parsing failure (except when
uninitialized messages are acceptable).</p>
%}
        *)

        jstype:JSType.t;
        (**
{%html:
<p>The jstype option determines the JavaScript type used for values of the
field.  The option is permitted only for 64 bit integral and fixed types
(int64, uint64, sint64, fixed64, sfixed64).  A field with jstype JS_STRING
is represented as JavaScript string, which avoids loss of precision that
can happen when a large value is converted to a floating point JavaScript.
Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
use the JavaScript &quot;number&quot; type.  The behavior of the default option
JS_NORMAL is implementation dependent.</p>
<p>This option is an enum to permit additional types to be added, e.g.
goog.math.Integer.</p>
%}
        *)

        weak:bool[@ocaml.alert protobuf "Marked as deprecated in the .proto file"];
        (**
{%html:
<p>DEPRECATED. DO NOT USE!
For Google-internal migration only. Do not use.</p>
%}
        *)

        unverified_lazy:bool;
        (**
{%html:
<p>unverified_lazy does no correctness checks on the byte stream. This should
only be used where lazy with verification is prohibitive for performance
reasons.</p>
%}
        *)

        debug_redact:bool;
        (**
{%html:
<p>Indicate that the field value should not be printed out when using debug
formats, e.g. when the field contains sensitive credentials.</p>
%}
        *)

        retention:OptionRetention.t option;
        targets:OptionTargetType.t list;
        (**
{%html:
<p>reserve target, target_obsolete_do_not_use</p>
%}
        *)

        edition_defaults:EditionDefault.t list;
        features:FeatureSet.t option;
        (**
{%html:
<p>Any features defined in the specific edition.
WARNING: This field should only be used by protobuf plugins or special
cases like the proto compiler. Other uses are discouraged and
developers should rely on the protoreflect APIs for their client language.</p>
%}
        *)

        feature_support:FeatureSupport.t option;
        uninterpreted_option:UninterpretedOption.t list;
        (**
{%html:
<p>The parser stores options it doesn't recognize here. See above.</p>
%}
        *)

        extensions':Runtime'.Extensions.t;
      }
      val make: ?ctype:CType.t -> ?packed:bool -> ?deprecated:bool -> ?lazy':bool -> ?jstype:JSType.t -> ?weak:bool -> ?unverified_lazy:bool -> ?debug_redact:bool -> ?retention:OptionRetention.t -> ?targets:OptionTargetType.t list -> ?edition_defaults:EditionDefault.t list -> ?features:FeatureSet.t -> ?feature_support:FeatureSupport.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?ctype:CType.t -> ?packed:bool -> ?deprecated:bool -> ?lazy':bool -> ?jstype:JSType.t -> ?weak:bool -> ?unverified_lazy:bool -> ?debug_redact:bool -> ?retention:OptionRetention.t -> ?targets:OptionTargetType.t list -> ?edition_defaults:EditionDefault.t list -> ?features:FeatureSet.t -> ?feature_support:FeatureSupport.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end

    and OneofOptions : sig
      type t = {
        features:FeatureSet.t option;
        (**
{%html:
<p>Any features defined in the specific edition.
WARNING: This field should only be used by protobuf plugins or special
cases like the proto compiler. Other uses are discouraged and
developers should rely on the protoreflect APIs for their client language.</p>
%}
        *)

        uninterpreted_option:UninterpretedOption.t list;
        (**
{%html:
<p>The parser stores options it doesn't recognize here. See above.</p>
%}
        *)

        extensions':Runtime'.Extensions.t;
      }
      val make: ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end

    and EnumOptions : sig
      type t = {
        allow_alias:bool option;
        (**
{%html:
<p>Set this option to true to allow mapping different tag names to the same
value.</p>
%}
        *)

        deprecated:bool;
        (**
{%html:
<p>Is this enum deprecated?
Depending on the target platform, this can emit Deprecated annotations
for the enum, or it will be completely ignored; in the very least, this
is a formalization for deprecating enums.</p>
%}
        *)

        deprecated_legacy_json_field_conflicts:bool option[@ocaml.alert protobuf "Marked as deprecated in the .proto file"];
        (**
{%html:
<p>Enable the legacy handling of JSON field name conflicts.  This lowercases
and strips underscored from the fields before comparison in proto3 only.
The new behavior takes <code>json_name</code> into account and applies to proto2 as
well.
TODO Remove this legacy behavior once downstream teams have
had time to migrate.</p>
%}
        *)

        features:FeatureSet.t option;
        (**
{%html:
<p>Any features defined in the specific edition.
WARNING: This field should only be used by protobuf plugins or special
cases like the proto compiler. Other uses are discouraged and
developers should rely on the protoreflect APIs for their client language.</p>
%}
        *)

        uninterpreted_option:UninterpretedOption.t list;
        (**
{%html:
<p>The parser stores options it doesn't recognize here. See above.</p>
%}
        *)

        extensions':Runtime'.Extensions.t;
      }
      val make: ?allow_alias:bool -> ?deprecated:bool -> ?deprecated_legacy_json_field_conflicts:bool -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?allow_alias:bool -> ?deprecated:bool -> ?deprecated_legacy_json_field_conflicts:bool -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end

    and EnumValueOptions : sig
      type t = {
        deprecated:bool;
        (**
{%html:
<p>Is this enum value deprecated?
Depending on the target platform, this can emit Deprecated annotations
for the enum value, or it will be completely ignored; in the very least,
this is a formalization for deprecating enum values.</p>
%}
        *)

        features:FeatureSet.t option;
        (**
{%html:
<p>Any features defined in the specific edition.
WARNING: This field should only be used by protobuf plugins or special
cases like the proto compiler. Other uses are discouraged and
developers should rely on the protoreflect APIs for their client language.</p>
%}
        *)

        debug_redact:bool;
        (**
{%html:
<p>Indicate that fields annotated with this enum value should not be printed
out when using debug formats, e.g. when the field contains sensitive
credentials.</p>
%}
        *)

        feature_support:FieldOptions.FeatureSupport.t option;
        (**
{%html:
<p>Information about the support window of a feature value.</p>
%}
        *)

        uninterpreted_option:UninterpretedOption.t list;
        (**
{%html:
<p>The parser stores options it doesn't recognize here. See above.</p>
%}
        *)

        extensions':Runtime'.Extensions.t;
      }
      val make: ?deprecated:bool -> ?features:FeatureSet.t -> ?debug_redact:bool -> ?feature_support:FieldOptions.FeatureSupport.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?deprecated:bool -> ?features:FeatureSet.t -> ?debug_redact:bool -> ?feature_support:FieldOptions.FeatureSupport.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end

    and ServiceOptions : sig
      type t = {
        deprecated:bool;
        (**
{%html:
<p>Is this service deprecated?
Depending on the target platform, this can emit Deprecated annotations
for the service, or it will be completely ignored; in the very least,
this is a formalization for deprecating services.</p>
<p>Note:  Field numbers 1 through 32 are reserved for Google's internal RPC</p>
<pre><code> framework.  We apologize for hoarding these numbers to ourselves, but
 we were already using them long before we decided to release Protocol
 Buffers.
</code></pre>
%}
        *)

        features:FeatureSet.t option;
        (**
{%html:
<p>Any features defined in the specific edition.
WARNING: This field should only be used by protobuf plugins or special
cases like the proto compiler. Other uses are discouraged and
developers should rely on the protoreflect APIs for their client language.</p>
%}
        *)

        uninterpreted_option:UninterpretedOption.t list;
        (**
{%html:
<p>The parser stores options it doesn't recognize here. See above.</p>
%}
        *)

        extensions':Runtime'.Extensions.t;
      }
      val make: ?deprecated:bool -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?deprecated:bool -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end

    and MethodOptions : sig

      (**
{%html:
<p>Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
or neither? HTTP based RPC implementation may choose GET verb for safe
methods, and PUT verb for idempotent methods instead of the default POST.</p>
%}
      *)
      module rec IdempotencyLevel : sig
        type t =
          | IDEMPOTENCY_UNKNOWN
          | NO_SIDE_EFFECTS
          (**
{%html:
<p>implies idempotent</p>
%}
          *)

          | IDEMPOTENT
          (**
{%html:
<p>idempotent, but may have side effects</p>
%}
          *)


        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      type t = {
        deprecated:bool;
        (**
{%html:
<p>Is this method deprecated?
Depending on the target platform, this can emit Deprecated annotations
for the method, or it will be completely ignored; in the very least,
this is a formalization for deprecating methods.</p>
<p>Note:  Field numbers 1 through 32 are reserved for Google's internal RPC</p>
<pre><code> framework.  We apologize for hoarding these numbers to ourselves, but
 we were already using them long before we decided to release Protocol
 Buffers.
</code></pre>
%}
        *)

        idempotency_level:IdempotencyLevel.t;
        features:FeatureSet.t option;
        (**
{%html:
<p>Any features defined in the specific edition.
WARNING: This field should only be used by protobuf plugins or special
cases like the proto compiler. Other uses are discouraged and
developers should rely on the protoreflect APIs for their client language.</p>
%}
        *)

        uninterpreted_option:UninterpretedOption.t list;
        (**
{%html:
<p>The parser stores options it doesn't recognize here. See above.</p>
%}
        *)

        extensions':Runtime'.Extensions.t;
      }
      val make: ?deprecated:bool -> ?idempotency_level:IdempotencyLevel.t -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?deprecated:bool -> ?idempotency_level:IdempotencyLevel.t -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end


    (**
{%html:
<p>A message representing a option the parser does not recognize. This only
appears in options protos created by the compiler::Parser class.
DescriptorPool resolves these when building Descriptor objects. Therefore,
options protos in descriptor objects (e.g. returned by Descriptor::options(),
or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
in them.</p>
%}
    *)
    and UninterpretedOption : sig

      (**
{%html:
<p>The name of the uninterpreted option.  Each string represents a segment in
a dot-separated name.  is_extension is true iff a segment represents an
extension (denoted with parentheses in options specs in .proto files).
E.g.,{ [&quot;foo&quot;, false], [&quot;bar.baz&quot;, true], [&quot;moo&quot;, false] } represents
&quot;foo.(bar.baz).moo&quot;.</p>
%}
      *)
      module rec NamePart : sig
        type t = {
          name_part:string;
          is_extension:bool;
        }
        val make: name_part:string -> is_extension:bool -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = name_part:string -> is_extension:bool -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end

      type t = {
        name:NamePart.t list;
        identifier_value:string option;
        (**
{%html:
<p>The value of the uninterpreted option, in whatever type the tokenizer
identified it as during parsing. Exactly one of these should be set.</p>
%}
        *)

        positive_int_value:int option;
        negative_int_value:int option;
        double_value:float option;
        string_value:bytes option;
        aggregate_value:string option;
      }
      val make: ?name:NamePart.t list -> ?identifier_value:string -> ?positive_int_value:int -> ?negative_int_value:int -> ?double_value:float -> ?string_value:bytes -> ?aggregate_value:string -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?name:NamePart.t list -> ?identifier_value:string -> ?positive_int_value:int -> ?negative_int_value:int -> ?double_value:float -> ?string_value:bytes -> ?aggregate_value:string -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end


    (**
{%html:
<p>TODO Enums in C++ gencode (and potentially other languages) are
not well scoped.  This means that each of the feature enums below can clash
with each other.  The short names we've chosen maximize call-site
readability, but leave us very open to this scenario.  A future feature will
be designed and implemented to handle this, hopefully before we ever hit a
conflict here.</p>
<p>===================================================================
Features</p>
%}
    *)
    and FeatureSet : sig
      module rec FieldPresence : sig
        type t =
          | FIELD_PRESENCE_UNKNOWN
          | EXPLICIT
          | IMPLICIT
          | LEGACY_REQUIRED

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      and EnumType : sig
        type t =
          | ENUM_TYPE_UNKNOWN
          | OPEN
          | CLOSED

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      and RepeatedFieldEncoding : sig
        type t =
          | REPEATED_FIELD_ENCODING_UNKNOWN
          | PACKED
          | EXPANDED

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      and Utf8Validation : sig
        type t =
          | UTF8_VALIDATION_UNKNOWN
          | VERIFY
          | NONE

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      and MessageEncoding : sig
        type t =
          | MESSAGE_ENCODING_UNKNOWN
          | LENGTH_PREFIXED
          | DELIMITED

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      and JsonFormat : sig
        type t =
          | JSON_FORMAT_UNKNOWN
          | ALLOW
          | LEGACY_BEST_EFFORT

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      and EnforceNamingStyle : sig
        type t =
          | ENFORCE_NAMING_STYLE_UNKNOWN
          | STYLE2024
          | STYLE_LEGACY

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      and VisibilityFeature : sig
        module rec DefaultSymbolVisibility : sig
          type t =
            | DEFAULT_SYMBOL_VISIBILITY_UNKNOWN
            | EXPORT_ALL
            (**
{%html:
<p>Default pre-EDITION_2024, all UNSET visibility are export.</p>
%}
            *)

            | EXPORT_TOP_LEVEL
            (**
{%html:
<p>All top-level symbols default to export, nested default to local.</p>
%}
            *)

            | LOCAL_ALL
            (**
{%html:
<p>All symbols default to local.</p>
%}
            *)

            | STRICT
            (**
{%html:
<p>All symbols local by default. Nested types cannot be exported.
With special case caveat for message { enum {} reserved 1 to max; }
This is the recommended setting for new protos.</p>
%}
            *)


          val name: unit -> string
          (** Fully qualified protobuf name of this enum *)

          (**/**)
          val to_int: t -> int
          val from_int: int -> t Runtime'.Result.t
          val from_int_exn: int -> t
          val to_string: t -> string
          val from_string_exn: string -> t
          (**/**)
        end

        type t = unit
        val make: unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end

      type t = {
        field_presence:FieldPresence.t option;
        enum_type:EnumType.t option;
        repeated_field_encoding:RepeatedFieldEncoding.t option;
        utf8_validation:Utf8Validation.t option;
        message_encoding:MessageEncoding.t option;
        json_format:JsonFormat.t option;
        (**
{%html:
<p>for https://github.com/bufbuild/protobuf-es</p>
%}
        *)

        enforce_naming_style:EnforceNamingStyle.t option;
        default_symbol_visibility:VisibilityFeature.DefaultSymbolVisibility.t option;
        extensions':Runtime'.Extensions.t;
      }
      val make: ?field_presence:FieldPresence.t -> ?enum_type:EnumType.t -> ?repeated_field_encoding:RepeatedFieldEncoding.t -> ?utf8_validation:Utf8Validation.t -> ?message_encoding:MessageEncoding.t -> ?json_format:JsonFormat.t -> ?enforce_naming_style:EnforceNamingStyle.t -> ?default_symbol_visibility:VisibilityFeature.DefaultSymbolVisibility.t -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?field_presence:FieldPresence.t -> ?enum_type:EnumType.t -> ?repeated_field_encoding:RepeatedFieldEncoding.t -> ?utf8_validation:Utf8Validation.t -> ?message_encoding:MessageEncoding.t -> ?json_format:JsonFormat.t -> ?enforce_naming_style:EnforceNamingStyle.t -> ?default_symbol_visibility:VisibilityFeature.DefaultSymbolVisibility.t -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end


    (**
{%html:
<p>A compiled specification for the defaults of a set of features.  These
messages are generated from FeatureSet extensions and can be used to seed
feature resolution. The resolution with this object becomes a simple search
for the closest matching edition, followed by proto merges.</p>
%}
    *)
    and FeatureSetDefaults : sig

      (**
{%html:
<p>A map from every known edition with a unique set of defaults to its
defaults. Not all editions may be contained here.  For a given edition,
the defaults at the closest matching edition ordered at or before it should
be used.  This field must be in strict ascending order by edition.</p>
%}
      *)
      module rec FeatureSetEditionDefault : sig
        type t = {
          edition:Edition.t option;
          overridable_features:FeatureSet.t option;
          (**
{%html:
<p>Defaults of features that can be overridden in this edition.</p>
%}
          *)

          fixed_features:FeatureSet.t option;
          (**
{%html:
<p>Defaults of features that can't be overridden in this edition.</p>
%}
          *)

        }
        val make: ?edition:Edition.t -> ?overridable_features:FeatureSet.t -> ?fixed_features:FeatureSet.t -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?edition:Edition.t -> ?overridable_features:FeatureSet.t -> ?fixed_features:FeatureSet.t -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end

      type t = {
        defaults:FeatureSetEditionDefault.t list;
        minimum_edition:Edition.t option;
        (**
{%html:
<p>The minimum supported edition (inclusive) when this was constructed.
Editions before this will not have defaults.</p>
%}
        *)

        maximum_edition:Edition.t option;
        (**
{%html:
<p>The maximum known edition (inclusive) when this was constructed. Editions
after this will not have reliable defaults.</p>
%}
        *)

      }
      val make: ?defaults:FeatureSetEditionDefault.t list -> ?minimum_edition:Edition.t -> ?maximum_edition:Edition.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?defaults:FeatureSetEditionDefault.t list -> ?minimum_edition:Edition.t -> ?maximum_edition:Edition.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end


    (**
{%html:
<p>Encapsulates information about the original source file from which a
FileDescriptorProto was generated.</p>
<p>===================================================================
Optional source code info</p>
%}
    *)
    and SourceCodeInfo : sig
      module rec Location : sig
        type t = {
          path:int list;
          (**
{%html:
<p>Identifies which part of the FileDescriptorProto was defined at this
location.</p>
<p>Each element is a field number or an index.  They form a path from
the root FileDescriptorProto to the place where the definition appears.
For example, this path:</p>
<pre><code> [ 4, 3, 2, 7, 1 ]
</code></pre>
<p>refers to:</p>
<pre><code> file.message_type(3)  // 4, 3
     .field(7)         // 2, 7
     .name()           // 1
</code></pre>
<p>This is because FileDescriptorProto.message_type has field number 4:</p>
<pre><code> repeated DescriptorProto message_type = 4;
</code></pre>
<p>and DescriptorProto.field has field number 2:</p>
<pre><code> repeated FieldDescriptorProto field = 2;
</code></pre>
<p>and FieldDescriptorProto.name has field number 1:</p>
<pre><code> optional string name = 1;
</code></pre>
<p>Thus, the above path gives the location of a field name.  If we removed
the last element:</p>
<pre><code> [ 4, 3, 2, 7 ]
</code></pre>
<p>this path refers to the whole field declaration (from the beginning
of the label to the terminating semicolon).</p>
%}
          *)

          span:int list;
          (**
{%html:
<p>Always has exactly three or four elements: start line, start column,
end line (optional, otherwise assumed same as start line), end column.
These are packed into a single field for efficiency.  Note that line
and column numbers are zero-based -- typically you will want to add
1 to each before displaying to a user.</p>
%}
          *)

          leading_comments:string option;
          (**
{%html:
<p>If this SourceCodeInfo represents a complete declaration, these are any
comments appearing before and after the declaration which appear to be
attached to the declaration.</p>
<p>A series of line comments appearing on consecutive lines, with no other
tokens appearing on those lines, will be treated as a single comment.</p>
<p>leading_detached_comments will keep paragraphs of comments that appear
before (but not connected to) the current element. Each paragraph,
separated by empty lines, will be one comment element in the repeated
field.</p>
<p>Only the comment content is provided; comment markers (e.g. //) are
stripped out.  For block comments, leading whitespace and an asterisk
will be stripped from the beginning of each line other than the first.
Newlines are included in the output.</p>
<p>Examples:</p>
<pre><code> optional int32 foo = 1;  // Comment attached to foo.
</code></pre>
<p>Comment attached to bar.</p>
<pre><code> optional int32 bar = 2;

 optional string baz = 3;
</code></pre>
<p>Comment attached to baz.
Another line attached to baz.</p>
<p>Comment attached to moo.</p>
<p>Another line attached to moo.</p>
<pre><code> optional double moo = 4;
</code></pre>
<p>Detached comment for corge. This is not leading or trailing comments
to moo or corge because there are blank lines separating it from
both.</p>
<p>Detached comment for corge paragraph 2.</p>
<pre><code> optional string corge = 5;
 /* Block comment attached
  * to corge.  Leading asterisks
  * will be removed. */
 /* Block comment attached to
  * grault. */
 optional int32 grault = 6;
</code></pre>
<p>ignored detached comments.</p>
%}
          *)

          trailing_comments:string option;
          leading_detached_comments:string list;
        }
        val make: ?path:int list -> ?span:int list -> ?leading_comments:string -> ?trailing_comments:string -> ?leading_detached_comments:string list -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?path:int list -> ?span:int list -> ?leading_comments:string -> ?trailing_comments:string -> ?leading_detached_comments:string list -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end

      type t = {
        location:Location.t list;
        (**
{%html:
<p>A Location identifies a piece of source code in a .proto file which
corresponds to a particular definition.  This information is intended
to be useful to IDEs, code indexers, documentation generators, and similar
tools.</p>
<p>For example, say we have a file like:</p>
<pre><code> message Foo {
   optional string foo = 1;
 }
</code></pre>
<p>Let's look at just the field definition:</p>
<pre><code> optional string foo = 1;
 ^       ^^     ^^  ^  ^^^
 a       bc     de  f  ghi
</code></pre>
<p>We have the following locations:</p>
<pre><code> span   path               represents
 [a,i)  [ 4, 0, 2, 0 ]     The whole field definition.
 [a,b)  [ 4, 0, 2, 0, 4 ]  The label (optional).
 [c,d)  [ 4, 0, 2, 0, 5 ]  The type (string).
 [e,f)  [ 4, 0, 2, 0, 1 ]  The name (foo).
 [g,h)  [ 4, 0, 2, 0, 3 ]  The number (1).
</code></pre>
<p>Notes:</p>
<ul>
<li>A location may refer to a repeated field itself (i.e. not to any
particular index within it).  This is used whenever a set of elements are
logically enclosed in a single code segment.  For example, an entire
extend block (possibly containing multiple extension definitions) will
have an outer location whose path refers to the &quot;extensions&quot; repeated
field without an index.
</li>
<li>Multiple locations may have the same path.  This happens when a single
logical declaration is spread out across multiple places.  The most
obvious example is the &quot;extend&quot; block again -- there may be multiple
extend blocks in the same scope, each of which will have the same path.
</li>
<li>A location's span is not always a subset of its parent's span.  For
example, the &quot;extendee&quot; of an extension declaration appears at the
beginning of the &quot;extend&quot; block and is shared by all extensions within
the block.
</li>
<li>Just because a location's span is a subset of some other location's span
does not mean that it is a descendant.  For example, a &quot;group&quot; defines
both a type and a field in a single declaration.  Thus, the locations
corresponding to the type and field and their components will overlap.
</li>
<li>Code which tries to interpret locations should probably be designed to
ignore those that it doesn't understand, as more types of locations could
be recorded in the future.
</li>
</ul>
%}
        *)

        extensions':Runtime'.Extensions.t;
      }
      val make: ?location:Location.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?location:Location.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end


    (**
{%html:
<p>Describes the relationship between generated code and its original source
file. A GeneratedCodeInfo message is associated with only one generated
source file, but may contain references to different source .proto files.</p>
%}
    *)
    and GeneratedCodeInfo : sig
      module rec Annotation : sig

        (**
{%html:
<p>Represents the identified object's effect on the element in the original
.proto file.</p>
%}
        *)
        module rec Semantic : sig
          type t =
            | NONE
            (**
{%html:
<p>There is no effect or the effect is indescribable.</p>
%}
            *)

            | SET
            (**
{%html:
<p>The element is set or otherwise mutated.</p>
%}
            *)

            | ALIAS
            (**
{%html:
<p>An alias to the element is returned.</p>
%}
            *)


          val name: unit -> string
          (** Fully qualified protobuf name of this enum *)

          (**/**)
          val to_int: t -> int
          val from_int: int -> t Runtime'.Result.t
          val from_int_exn: int -> t
          val to_string: t -> string
          val from_string_exn: string -> t
          (**/**)
        end

        type t = {
          path:int list;
          (**
{%html:
<p>Identifies the element in the original source .proto file. This field
is formatted the same as SourceCodeInfo.Location.path.</p>
%}
          *)

          source_file:string option;
          (**
{%html:
<p>Identifies the filesystem path to the original source .proto.</p>
%}
          *)

          begin':int option;
          (**
{%html:
<p>Identifies the starting offset in bytes in the generated code
that relates to the identified object.</p>
%}
          *)

          end':int option;
          (**
{%html:
<p>Identifies the ending offset in bytes in the generated code that
relates to the identified object. The end offset should be one past
the last relevant byte (so the length of the text = end - begin).</p>
%}
          *)

          semantic:Semantic.t option;
        }
        val make: ?path:int list -> ?source_file:string -> ?begin':int -> ?end':int -> ?semantic:Semantic.t -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?path:int list -> ?source_file:string -> ?begin':int -> ?end':int -> ?semantic:Semantic.t -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end

      type t = (Annotation.t list)
      (**
{%html:
<p>An Annotation connects some span of text in generated code to an element
of its generating .proto file.</p>
%}
      *)

      val make: ?annotation:Annotation.t list -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?annotation:Annotation.t list -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end

  end
end = struct
  module rec Protobuf : sig

    (**
{%html:
<p>The full set of known editions.</p>
%}
    *)
    module rec Edition : sig
      type t =
        | EDITION_UNKNOWN
        (**
{%html:
<p>A placeholder for an unknown edition value.</p>
%}
        *)

        | EDITION_LEGACY
        (**
{%html:
<p>A placeholder edition for specifying default behaviors <em>before</em> a feature
was first introduced.  This is effectively an &quot;infinite past&quot;.</p>
%}
        *)

        | EDITION_PROTO2
        (**
{%html:
<p>Legacy syntax &quot;editions&quot;.  These pre-date editions, but behave much like
distinct editions.  These can't be used to specify the edition of proto
files, but feature definitions must supply proto2/proto3 defaults for
backwards compatibility.</p>
%}
        *)

        | EDITION_PROTO3
        | EDITION_2023
        (**
{%html:
<p>Editions that have been released.  The specific values are arbitrary and
should not be depended on, but they will always be time-ordered for easy
comparison.</p>
%}
        *)

        | EDITION_2024
        | EDITION_UNSTABLE
        (**
{%html:
<p>A placeholder edition for developing and testing unscheduled features.</p>
%}
        *)

        | EDITION_1_TEST_ONLY
        (**
{%html:
<p>Placeholder editions for testing feature resolution.  These should not be
used or relied on outside of tests.</p>
%}
        *)

        | EDITION_2_TEST_ONLY
        | EDITION_99997_TEST_ONLY
        | EDITION_99998_TEST_ONLY
        | EDITION_99999_TEST_ONLY
        | EDITION_MAX
        (**
{%html:
<p>Placeholder for specifying unbounded edition support.  This should only
ever be used by plugins that can expect to never require any changes to
support a new edition.</p>
%}
        *)


      val name: unit -> string
      (** Fully qualified protobuf name of this enum *)

      (**/**)
      val to_int: t -> int
      val from_int: int -> t Runtime'.Result.t
      val from_int_exn: int -> t
      val to_string: t -> string
      val from_string_exn: string -> t
      (**/**)
    end


    (**
{%html:
<p>Describes the 'visibility' of a symbol with respect to the proto import
system. Symbols can only be imported when the visibility rules do not prevent
it (ex: local symbols cannot be imported).  Visibility modifiers can only set
on <code>message</code> and <code>enum</code> as they are the only types available to be referenced
from other files.</p>
%}
    *)
    and SymbolVisibility : sig
      type t =
        | VISIBILITY_UNSET
        | VISIBILITY_LOCAL
        | VISIBILITY_EXPORT

      val name: unit -> string
      (** Fully qualified protobuf name of this enum *)

      (**/**)
      val to_int: t -> int
      val from_int: int -> t Runtime'.Result.t
      val from_int_exn: int -> t
      val to_string: t -> string
      val from_string_exn: string -> t
      (**/**)
    end


    (**
{%html:
<p>The protocol compiler can output a FileDescriptorSet containing the .proto
files it parses.</p>
%}
    *)
    and FileDescriptorSet : sig
      type t = {
        file:FileDescriptorProto.t list;
        extensions':Runtime'.Extensions.t;
      }
      val make: ?file:FileDescriptorProto.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?file:FileDescriptorProto.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end


    (**
{%html:
<p>Describes a complete .proto file.</p>
%}
    *)
    and FileDescriptorProto : sig
      type t = {
        name:string option;
        (**
{%html:
<p>file name, relative to root of source tree</p>
%}
        *)

        package:string option;
        (**
{%html:
<p>e.g. &quot;foo&quot;, &quot;foo.bar&quot;, etc.</p>
%}
        *)

        dependency:string list;
        (**
{%html:
<p>Names of files imported by this file.</p>
%}
        *)

        message_type:DescriptorProto.t list;
        (**
{%html:
<p>All top-level definitions in this file.</p>
%}
        *)

        enum_type:EnumDescriptorProto.t list;
        service:ServiceDescriptorProto.t list;
        extension:FieldDescriptorProto.t list;
        options:FileOptions.t option;
        source_code_info:SourceCodeInfo.t option;
        (**
{%html:
<p>This field contains optional information about the original source code.
You may safely remove this entire field without harming runtime
functionality of the descriptors -- the information is needed only by
development tools.</p>
%}
        *)

        public_dependency:int list;
        (**
{%html:
<p>Indexes of the public imported files in the dependency list above.</p>
%}
        *)

        weak_dependency:int list;
        (**
{%html:
<p>Indexes of the weak imported files in the dependency list.
For Google-internal migration only. Do not use.</p>
%}
        *)

        syntax:string option;
        (**
{%html:
<p>The syntax of the proto file.
The supported values are &quot;proto2&quot;, &quot;proto3&quot;, and &quot;editions&quot;.</p>
<p>If <code>edition</code> is present, this value must be &quot;editions&quot;.
WARNING: This field should only be used by protobuf plugins or special
cases like the proto compiler. Other uses are discouraged and
developers should rely on the protoreflect APIs for their client language.</p>
%}
        *)

        edition:Edition.t option;
        (**
{%html:
<p>The edition of the proto file.
WARNING: This field should only be used by protobuf plugins or special
cases like the proto compiler. Other uses are discouraged and
developers should rely on the protoreflect APIs for their client language.</p>
%}
        *)

        option_dependency:string list;
        (**
{%html:
<p>Names of files imported by this file purely for the purpose of providing
option extensions. These are excluded from the dependency list above.</p>
%}
        *)

      }
      val make: ?name:string -> ?package:string -> ?dependency:string list -> ?message_type:DescriptorProto.t list -> ?enum_type:EnumDescriptorProto.t list -> ?service:ServiceDescriptorProto.t list -> ?extension:FieldDescriptorProto.t list -> ?options:FileOptions.t -> ?source_code_info:SourceCodeInfo.t -> ?public_dependency:int list -> ?weak_dependency:int list -> ?syntax:string -> ?edition:Edition.t -> ?option_dependency:string list -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?name:string -> ?package:string -> ?dependency:string list -> ?message_type:DescriptorProto.t list -> ?enum_type:EnumDescriptorProto.t list -> ?service:ServiceDescriptorProto.t list -> ?extension:FieldDescriptorProto.t list -> ?options:FileOptions.t -> ?source_code_info:SourceCodeInfo.t -> ?public_dependency:int list -> ?weak_dependency:int list -> ?syntax:string -> ?edition:Edition.t -> ?option_dependency:string list -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end


    (**
{%html:
<p>Describes a message type.</p>
%}
    *)
    and DescriptorProto : sig
      module rec ExtensionRange : sig
        type t = {
          start:int option;
          (**
{%html:
<p>Inclusive.</p>
%}
          *)

          end':int option;
          (**
{%html:
<p>Exclusive.</p>
%}
          *)

          options:ExtensionRangeOptions.t option;
        }
        val make: ?start:int -> ?end':int -> ?options:ExtensionRangeOptions.t -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?start:int -> ?end':int -> ?options:ExtensionRangeOptions.t -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end


      (**
{%html:
<p>Range of reserved tag numbers. Reserved tag numbers may not be used by
fields or extension ranges in the same message. Reserved ranges may
not overlap.</p>
%}
      *)
      and ReservedRange : sig
        type t = {
          start:int option;
          (**
{%html:
<p>Inclusive.</p>
%}
          *)

          end':int option;
          (**
{%html:
<p>Exclusive.</p>
%}
          *)

        }
        val make: ?start:int -> ?end':int -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?start:int -> ?end':int -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end

      type t = {
        name:string option;
        field:FieldDescriptorProto.t list;
        nested_type:t list;
        enum_type:EnumDescriptorProto.t list;
        extension_range:ExtensionRange.t list;
        extension:FieldDescriptorProto.t list;
        options:MessageOptions.t option;
        oneof_decl:OneofDescriptorProto.t list;
        reserved_range:ReservedRange.t list;
        reserved_name:string list;
        (**
{%html:
<p>Reserved field names, which may not be used by fields in the same message.
A given name may only be reserved once.</p>
%}
        *)

        visibility:SymbolVisibility.t option;
        (**
{%html:
<p>Support for <code>export</code> and <code>local</code> keywords on enums.</p>
%}
        *)

      }
      val make: ?name:string -> ?field:FieldDescriptorProto.t list -> ?nested_type:t list -> ?enum_type:EnumDescriptorProto.t list -> ?extension_range:ExtensionRange.t list -> ?extension:FieldDescriptorProto.t list -> ?options:MessageOptions.t -> ?oneof_decl:OneofDescriptorProto.t list -> ?reserved_range:ReservedRange.t list -> ?reserved_name:string list -> ?visibility:SymbolVisibility.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?name:string -> ?field:FieldDescriptorProto.t list -> ?nested_type:t list -> ?enum_type:EnumDescriptorProto.t list -> ?extension_range:ExtensionRange.t list -> ?extension:FieldDescriptorProto.t list -> ?options:MessageOptions.t -> ?oneof_decl:OneofDescriptorProto.t list -> ?reserved_range:ReservedRange.t list -> ?reserved_name:string list -> ?visibility:SymbolVisibility.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end

    and ExtensionRangeOptions : sig

      (**
{%html:
<p>The verification state of the extension range.</p>
%}
      *)
      module rec VerificationState : sig
        type t =
          | DECLARATION
          (**
{%html:
<p>All the extensions of the range must be declared.</p>
%}
          *)

          | UNVERIFIED

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      and Declaration : sig
        type t = {
          number:int option;
          (**
{%html:
<p>The extension number declared within the extension range.</p>
%}
          *)

          full_name:string option;
          (**
{%html:
<p>The fully-qualified name of the extension field. There must be a leading
dot in front of the full name.</p>
%}
          *)

          type':string option;
          (**
{%html:
<p>The fully-qualified type name of the extension field. Unlike
Metadata.type, Declaration.type must have a leading dot for messages
and enums.</p>
%}
          *)

          reserved:bool option;
          (**
{%html:
<p>If true, indicates that the number is reserved in the extension range,
and any extension field with the number will fail to compile. Set this
when a declared extension field is deleted.</p>
%}
          *)

          repeated:bool option;
          (**
{%html:
<p>If true, indicates that the extension must be defined as repeated.
Otherwise the extension must be defined as optional.</p>
%}
          *)

        }
        val make: ?number:int -> ?full_name:string -> ?type':string -> ?reserved:bool -> ?repeated:bool -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?number:int -> ?full_name:string -> ?type':string -> ?reserved:bool -> ?repeated:bool -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end

      type t = {
        declaration:Declaration.t list;
        (**
{%html:
<p>For external users: DO NOT USE. We are in the process of open sourcing
extension declaration and executing internal cleanups before it can be
used externally.</p>
%}
        *)

        verification:VerificationState.t;
        (**
{%html:
<p>The verification state of the range.
TODO: flip the default to DECLARATION once all empty ranges
are marked as UNVERIFIED.</p>
%}
        *)

        features:FeatureSet.t option;
        (**
{%html:
<p>Any features defined in the specific edition.</p>
%}
        *)

        uninterpreted_option:UninterpretedOption.t list;
        (**
{%html:
<p>The parser stores options it doesn't recognize here. See above.</p>
%}
        *)

        extensions':Runtime'.Extensions.t;
      }
      val make: ?declaration:Declaration.t list -> ?verification:VerificationState.t -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?declaration:Declaration.t list -> ?verification:VerificationState.t -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end


    (**
{%html:
<p>Describes a field within a message.</p>
%}
    *)
    and FieldDescriptorProto : sig
      module rec Type : sig
        type t =
          | TYPE_DOUBLE
          (**
{%html:
<p>0 is reserved for errors.
Order is weird for historical reasons.</p>
%}
          *)

          | TYPE_FLOAT
          | TYPE_INT64
          (**
{%html:
<p>Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT64 if
negative values are likely.</p>
%}
          *)

          | TYPE_UINT64
          | TYPE_INT32
          (**
{%html:
<p>Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT32 if
negative values are likely.</p>
%}
          *)

          | TYPE_FIXED64
          | TYPE_FIXED32
          | TYPE_BOOL
          | TYPE_STRING
          | TYPE_GROUP
          (**
{%html:
<p>Tag-delimited aggregate.
Group type is deprecated and not supported after google.protobuf. However, Proto3
implementations should still be able to parse the group wire format and
treat group fields as unknown fields.  In Editions, the group wire format
can be enabled via the <code>message_encoding</code> feature.</p>
%}
          *)

          | TYPE_MESSAGE
          (**
{%html:
<p>Length-delimited aggregate.</p>
%}
          *)

          | TYPE_BYTES
          (**
{%html:
<p>New in version 2.</p>
%}
          *)

          | TYPE_UINT32
          | TYPE_ENUM
          | TYPE_SFIXED32
          | TYPE_SFIXED64
          | TYPE_SINT32
          (**
{%html:
<p>Uses ZigZag encoding.</p>
%}
          *)

          | TYPE_SINT64
          (**
{%html:
<p>Uses ZigZag encoding.</p>
%}
          *)


        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      and Label : sig
        type t =
          | LABEL_OPTIONAL
          (**
{%html:
<p>0 is reserved for errors</p>
%}
          *)

          | LABEL_REPEATED
          | LABEL_REQUIRED
          (**
{%html:
<p>The required label is only allowed in google.protobuf.  In proto3 and Editions
it's explicitly prohibited.  In Editions, the <code>field_presence</code> feature
can be used to get this behavior.</p>
%}
          *)


        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      type t = {
        name:string option;
        extendee:string option;
        (**
{%html:
<p>For extensions, this is the name of the type being extended.  It is
resolved in the same manner as type_name.</p>
%}
        *)

        number:int option;
        label:Label.t option;
        type':Type.t option;
        (**
{%html:
<p>If type_name is set, this need not be set.  If both this and type_name
are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.</p>
%}
        *)

        type_name:string option;
        (**
{%html:
<p>For message and enum types, this is the name of the type.  If the name
starts with a '.', it is fully-qualified.  Otherwise, C++-like scoping
rules are used to find the type (i.e. first the nested types within this
message are searched, then within the parent, on up to the root
namespace).</p>
%}
        *)

        default_value:string option;
        (**
{%html:
<p>For numeric types, contains the original text representation of the value.
For booleans, &quot;true&quot; or &quot;false&quot;.
For strings, contains the default text contents (not escaped in any way).
For bytes, contains the C escaped value.  All bytes &gt;= 128 are escaped.</p>
%}
        *)

        options:FieldOptions.t option;
        oneof_index:int option;
        (**
{%html:
<p>If set, gives the index of a oneof in the containing type's oneof_decl
list.  This field is a member of that oneof.</p>
%}
        *)

        json_name:string option;
        (**
{%html:
<p>JSON name of this field. The value is set by protocol compiler. If the
user has set a &quot;json_name&quot; option on this field, that option's value
will be used. Otherwise, it's deduced from the field's name by converting
it to camelCase.</p>
%}
        *)

        proto3_optional:bool option;
        (**
{%html:
<p>If true, this is a proto3 &quot;optional&quot;. When a proto3 field is optional, it
tracks presence regardless of field type.</p>
<p>When proto3_optional is true, this field must belong to a oneof to signal
to old proto3 clients that presence is tracked for this field. This oneof
is known as a &quot;synthetic&quot; oneof, and this field must be its sole member
(each proto3 optional field gets its own synthetic oneof). Synthetic oneofs
exist in the descriptor only, and do not generate any API. Synthetic oneofs
must be ordered after all &quot;real&quot; oneofs.</p>
<p>For message fields, proto3_optional doesn't create any semantic change,
since non-repeated message fields always track presence. However it still
indicates the semantic detail of whether the user wrote &quot;optional&quot; or not.
This can be useful for round-tripping the .proto file. For consistency we
give message fields a synthetic oneof also, even though it is not required
to track presence. This is especially important because the parser can't
tell if a field is a message or an enum, so it must always create a
synthetic oneof.</p>
<p>Proto2 optional fields do not set this flag, because they already indicate
optional with <code>LABEL_OPTIONAL</code>.</p>
%}
        *)

      }
      val make: ?name:string -> ?extendee:string -> ?number:int -> ?label:Label.t -> ?type':Type.t -> ?type_name:string -> ?default_value:string -> ?options:FieldOptions.t -> ?oneof_index:int -> ?json_name:string -> ?proto3_optional:bool -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?name:string -> ?extendee:string -> ?number:int -> ?label:Label.t -> ?type':Type.t -> ?type_name:string -> ?default_value:string -> ?options:FieldOptions.t -> ?oneof_index:int -> ?json_name:string -> ?proto3_optional:bool -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end


    (**
{%html:
<p>Describes a oneof.</p>
%}
    *)
    and OneofDescriptorProto : sig
      type t = {
        name:string option;
        options:OneofOptions.t option;
      }
      val make: ?name:string -> ?options:OneofOptions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?name:string -> ?options:OneofOptions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end


    (**
{%html:
<p>Describes an enum type.</p>
%}
    *)
    and EnumDescriptorProto : sig

      (**
{%html:
<p>Range of reserved numeric values. Reserved values may not be used by
entries in the same enum. Reserved ranges may not overlap.</p>
<p>Note that this is distinct from DescriptorProto.ReservedRange in that it
is inclusive such that it can appropriately represent the entire int32
domain.</p>
%}
      *)
      module rec EnumReservedRange : sig
        type t = {
          start:int option;
          (**
{%html:
<p>Inclusive.</p>
%}
          *)

          end':int option;
          (**
{%html:
<p>Inclusive.</p>
%}
          *)

        }
        val make: ?start:int -> ?end':int -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?start:int -> ?end':int -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end

      type t = {
        name:string option;
        value:EnumValueDescriptorProto.t list;
        options:EnumOptions.t option;
        reserved_range:EnumReservedRange.t list;
        (**
{%html:
<p>Range of reserved numeric values. Reserved numeric values may not be used
by enum values in the same enum declaration. Reserved ranges may not
overlap.</p>
%}
        *)

        reserved_name:string list;
        (**
{%html:
<p>Reserved enum value names, which may not be reused. A given name may only
be reserved once.</p>
%}
        *)

        visibility:SymbolVisibility.t option;
        (**
{%html:
<p>Support for <code>export</code> and <code>local</code> keywords on enums.</p>
%}
        *)

      }
      val make: ?name:string -> ?value:EnumValueDescriptorProto.t list -> ?options:EnumOptions.t -> ?reserved_range:EnumReservedRange.t list -> ?reserved_name:string list -> ?visibility:SymbolVisibility.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?name:string -> ?value:EnumValueDescriptorProto.t list -> ?options:EnumOptions.t -> ?reserved_range:EnumReservedRange.t list -> ?reserved_name:string list -> ?visibility:SymbolVisibility.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end


    (**
{%html:
<p>Describes a value within an enum.</p>
%}
    *)
    and EnumValueDescriptorProto : sig
      type t = {
        name:string option;
        number:int option;
        options:EnumValueOptions.t option;
      }
      val make: ?name:string -> ?number:int -> ?options:EnumValueOptions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?name:string -> ?number:int -> ?options:EnumValueOptions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end


    (**
{%html:
<p>Describes a service.</p>
%}
    *)
    and ServiceDescriptorProto : sig
      type t = {
        name:string option;
        method':MethodDescriptorProto.t list;
        options:ServiceOptions.t option;
      }
      val make: ?name:string -> ?method':MethodDescriptorProto.t list -> ?options:ServiceOptions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?name:string -> ?method':MethodDescriptorProto.t list -> ?options:ServiceOptions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end


    (**
{%html:
<p>Describes a method of a service.</p>
%}
    *)
    and MethodDescriptorProto : sig
      type t = {
        name:string option;
        input_type:string option;
        (**
{%html:
<p>Input and output type names.  These are resolved in the same way as
FieldDescriptorProto.type_name, but must refer to a message type.</p>
%}
        *)

        output_type:string option;
        options:MethodOptions.t option;
        client_streaming:bool;
        (**
{%html:
<p>Identifies if client streams multiple client messages</p>
%}
        *)

        server_streaming:bool;
        (**
{%html:
<p>Identifies if server streams multiple server messages</p>
%}
        *)

      }
      val make: ?name:string -> ?input_type:string -> ?output_type:string -> ?options:MethodOptions.t -> ?client_streaming:bool -> ?server_streaming:bool -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?name:string -> ?input_type:string -> ?output_type:string -> ?options:MethodOptions.t -> ?client_streaming:bool -> ?server_streaming:bool -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end


    (**
{%html:
<p>===================================================================
Options</p>
<p>Each of the definitions above may have &quot;options&quot; attached.  These are
just annotations which may cause code to be generated slightly differently
or may contain hints for code that manipulates protocol messages.</p>
<p>Clients may define custom options as extensions of the *Options messages.
These extensions may not yet be known at parsing time, so the parser cannot
store the values in them.  Instead it stores them in a field in the *Options
message called uninterpreted_option. This field must have the same name
across all *Options messages. We then use this field to populate the
extensions when we build a descriptor, at which point all protos have been
parsed and so all extensions are known.</p>
<p>Extension numbers for custom options may be chosen as follows:</p>
<ul>
<li>
<p>For options which will only be used within a single application or</p>
<p>organization, or for experimental options, use field numbers 50000
through 99999.  It is up to you to ensure that you do not use the
same number for multiple options.</p>
</li>
<li>
<p>For options which will be published and used publicly by multiple</p>
<p>independent entities, e-mail protobuf-global-extension-registry@google.com
to reserve extension numbers. Simply provide your project name (e.g.
Objective-C plugin) and your project website (if available) -- there's no
need to explain how you intend to use them. Usually you only need one
extension number. You can declare multiple options with only one extension
number by putting them in a sub-message. See the Custom Options section of
the docs for examples:
https://developers.google.com/protocol-buffers/docs/proto#options
If this turns out to be popular, a web service will be set up
to automatically assign option numbers.</p>
</li>
</ul>
%}
    *)
    and FileOptions : sig

      (**
{%html:
<p>Generated classes can be optimized for speed or code size.</p>
%}
      *)
      module rec OptimizeMode : sig
        type t =
          | SPEED
          (**
{%html:
<p>Generate complete code for parsing, serialization,</p>
%}
          *)

          | CODE_SIZE
          (**
{%html:
<p>etc.</p>
<p>Use ReflectionOps to implement these methods.</p>
%}
          *)

          | LITE_RUNTIME
          (**
{%html:
<p>Generate code using MessageLite and the lite runtime.</p>
%}
          *)


        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      type t = {
        java_package:string option;
        (**
{%html:
<p>Sets the Java package where classes generated from this .proto will be
placed.  By default, the proto package is used, but this is often
inappropriate because proto packages do not normally start with backwards
domain names.</p>
%}
        *)

        java_outer_classname:string option;
        (**
{%html:
<p>Controls the name of the wrapper Java class generated for the .proto file.
That class will always contain the .proto file's getDescriptor() method as
well as any top-level extensions defined in the .proto file.
If java_multiple_files is disabled, then all the other classes from the
.proto file will be nested inside the single wrapper outer class.</p>
%}
        *)

        optimize_for:OptimizeMode.t;
        (**
{%html:
<p>Clients can define custom options in extensions of this message.
See the documentation for the &quot;Options&quot; section above.</p>
%}
        *)

        java_multiple_files:bool;
        (**
{%html:
<p>If enabled, then the Java code generator will generate a separate .java
file for each top-level message, enum, and service defined in the .proto
file.  Thus, these types will <em>not</em> be nested inside the wrapper class
named by java_outer_classname.  However, the wrapper class will still be
generated to contain the file's getDescriptor() method as well as any
top-level extensions defined in the file.</p>
%}
        *)

        go_package:string option;
        (**
{%html:
<p>Sets the Go package where structs generated from this .proto will be
placed. If omitted, the Go package will be derived from the following:</p>
<ul>
<li>The basename of the package import path, if provided.
</li>
<li>Otherwise, the package statement in the .proto file, if present.
</li>
<li>Otherwise, the basename of the .proto file, without extension.
</li>
</ul>
%}
        *)

        cc_generic_services:bool;
        (**
{%html:
<p>Should generic services be generated in each language?  &quot;Generic&quot; services
are not specific to any particular RPC system.  They are generated by the
main code generators in each language (without additional plugins).
Generic services were the only kind of service generation supported by
early versions of google.protobuf.</p>
<p>Generic services are now considered deprecated in favor of using plugins
that generate code specific to your particular RPC system.  Therefore,
these default to false.  Old code which depends on generic services should
explicitly set them to true.</p>
%}
        *)

        java_generic_services:bool;
        py_generic_services:bool;
        (**
{%html:
<p>removed php_generic_services</p>
%}
        *)

        java_generate_equals_and_hash:bool option[@ocaml.alert protobuf "Marked as deprecated in the .proto file"];
        (**
{%html:
<p>This option does nothing.</p>
%}
        *)

        deprecated:bool;
        (**
{%html:
<p>Is this file deprecated?
Depending on the target platform, this can emit Deprecated annotations
for everything in the file, or it will be completely ignored; in the very
least, this is a formalization for deprecating files.</p>
%}
        *)

        java_string_check_utf8:bool;
        (**
{%html:
<p>A proto2 file can set this to true to opt in to UTF-8 checking for Java,
which will throw an exception if invalid UTF-8 is parsed from the wire or
assigned to a string field.</p>
<p>TODO: clarify exactly what kinds of field types this option
applies to, and update these docs accordingly.</p>
<p>Proto3 files already perform these checks. Setting the option explicitly to
false has no effect: it cannot be used to opt proto3 files out of UTF-8
checks.</p>
%}
        *)

        cc_enable_arenas:bool;
        (**
{%html:
<p>Enables the use of arenas for the proto messages in this file. This applies
only to generated classes for C++.</p>
%}
        *)

        objc_class_prefix:string option;
        (**
{%html:
<p>Sets the objective c class prefix which is prepended to all objective c
generated classes from this .proto. There is no default.</p>
%}
        *)

        csharp_namespace:string option;
        (**
{%html:
<p>Namespace for generated classes; defaults to the package.</p>
%}
        *)

        swift_prefix:string option;
        (**
{%html:
<p>By default Swift generators will take the proto package and CamelCase it
replacing '.' with underscore and use that to prefix the types/symbols
defined. When this options is provided, they will use this value instead
to prefix the types/symbols defined.</p>
%}
        *)

        php_class_prefix:string option;
        (**
{%html:
<p>Sets the php class prefix which is prepended to all php generated classes
from this .proto. Default is empty.</p>
%}
        *)

        php_namespace:string option;
        (**
{%html:
<p>Use this option to change the namespace of php generated classes. Default
is empty. When this option is empty, the package name will be used for
determining the namespace.</p>
%}
        *)

        php_metadata_namespace:string option;
        (**
{%html:
<p>Use this option to change the namespace of php generated metadata classes.
Default is empty. When this option is empty, the proto file name will be
used for determining the namespace.</p>
%}
        *)

        ruby_package:string option;
        (**
{%html:
<p>Use this option to change the package of ruby generated classes. Default
is empty. When this option is not set, the package name will be used for
determining the ruby package.</p>
%}
        *)

        features:FeatureSet.t option;
        (**
{%html:
<p>Any features defined in the specific edition.
WARNING: This field should only be used by protobuf plugins or special
cases like the proto compiler. Other uses are discouraged and
developers should rely on the protoreflect APIs for their client language.</p>
%}
        *)

        uninterpreted_option:UninterpretedOption.t list;
        (**
{%html:
<p>The parser stores options it doesn't recognize here.
See the documentation for the &quot;Options&quot; section above.</p>
%}
        *)

        extensions':Runtime'.Extensions.t;
      }
      val make: ?java_package:string -> ?java_outer_classname:string -> ?optimize_for:OptimizeMode.t -> ?java_multiple_files:bool -> ?go_package:string -> ?cc_generic_services:bool -> ?java_generic_services:bool -> ?py_generic_services:bool -> ?java_generate_equals_and_hash:bool -> ?deprecated:bool -> ?java_string_check_utf8:bool -> ?cc_enable_arenas:bool -> ?objc_class_prefix:string -> ?csharp_namespace:string -> ?swift_prefix:string -> ?php_class_prefix:string -> ?php_namespace:string -> ?php_metadata_namespace:string -> ?ruby_package:string -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?java_package:string -> ?java_outer_classname:string -> ?optimize_for:OptimizeMode.t -> ?java_multiple_files:bool -> ?go_package:string -> ?cc_generic_services:bool -> ?java_generic_services:bool -> ?py_generic_services:bool -> ?java_generate_equals_and_hash:bool -> ?deprecated:bool -> ?java_string_check_utf8:bool -> ?cc_enable_arenas:bool -> ?objc_class_prefix:string -> ?csharp_namespace:string -> ?swift_prefix:string -> ?php_class_prefix:string -> ?php_namespace:string -> ?php_metadata_namespace:string -> ?ruby_package:string -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end

    and MessageOptions : sig
      type t = {
        message_set_wire_format:bool;
        (**
{%html:
<p>Set true to use the old proto1 MessageSet wire format for extensions.
This is provided for backwards-compatibility with the MessageSet wire
format.  You should not use this for any other reason:  It's less
efficient, has fewer features, and is more complicated.</p>
<p>The message must be defined exactly as follows:</p>
<pre><code> message Foo {
   option message_set_wire_format = true;
   extensions 4 to max;
 }
</code></pre>
<p>Note that the message cannot have any defined fields; MessageSets only
have extensions.</p>
<p>All extensions of your type must be singular messages; e.g. they cannot
be int32s, enums, or repeated messages.</p>
<p>Because this is an option, the above two restrictions are not enforced by
the protocol compiler.</p>
%}
        *)

        no_standard_descriptor_accessor:bool;
        (**
{%html:
<p>Disables the generation of the standard &quot;descriptor()&quot; accessor, which can
conflict with a field of the same name.  This is meant to make migration
from proto1 easier; new code should avoid fields named &quot;descriptor&quot;.</p>
%}
        *)

        deprecated:bool;
        (**
{%html:
<p>Is this message deprecated?
Depending on the target platform, this can emit Deprecated annotations
for the message, or it will be completely ignored; in the very least,
this is a formalization for deprecating messages.</p>
%}
        *)

        map_entry:bool option;
        (**
{%html:
<p>Whether the message is an automatically generated map entry type for the
maps field.</p>
<p>For maps fields:</p>
<pre><code> map&lt;KeyType, ValueType&gt; map_field = 1;
</code></pre>
<p>The parsed descriptor looks like:</p>
<pre><code> message MapFieldEntry {
     option map_entry = true;
     optional KeyType key = 1;
     optional ValueType value = 2;
 }
 repeated MapFieldEntry map_field = 1;
</code></pre>
<p>Implementations may choose not to generate the map_entry=true message, but
use a native map in the target language to hold the keys and values.
The reflection APIs in such implementations still need to work as
if the field is a repeated message field.</p>
<p>NOTE: Do not set the option in .proto files. Always use the maps syntax
instead. The option should only be implicitly set by the proto compiler
parser.</p>
%}
        *)

        deprecated_legacy_json_field_conflicts:bool option[@ocaml.alert protobuf "Marked as deprecated in the .proto file"];
        (**
{%html:
<p>Enable the legacy handling of JSON field name conflicts.  This lowercases
and strips underscored from the fields before comparison in proto3 only.
The new behavior takes <code>json_name</code> into account and applies to proto2 as
well.</p>
<p>This should only be used as a temporary measure against broken builds due
to the change in behavior for JSON field name conflicts.</p>
<p>TODO This is legacy behavior we plan to remove once downstream
teams have had time to migrate.</p>
%}
        *)

        features:FeatureSet.t option;
        (**
{%html:
<p>Clients can define custom options in extensions of this message. See above.</p>
%}
        *)

        uninterpreted_option:UninterpretedOption.t list;
        (**
{%html:
<p>The parser stores options it doesn't recognize here. See above.</p>
%}
        *)

        extensions':Runtime'.Extensions.t;
      }
      val make: ?message_set_wire_format:bool -> ?no_standard_descriptor_accessor:bool -> ?deprecated:bool -> ?map_entry:bool -> ?deprecated_legacy_json_field_conflicts:bool -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?message_set_wire_format:bool -> ?no_standard_descriptor_accessor:bool -> ?deprecated:bool -> ?map_entry:bool -> ?deprecated_legacy_json_field_conflicts:bool -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end

    and FieldOptions : sig
      module rec CType : sig
        type t =
          | STRING
          (**
{%html:
<p>Default mode.</p>
%}
          *)

          | CORD
          (**
{%html:
<p>The option [ctype=CORD] may be applied to a non-repeated field of type
&quot;bytes&quot;. It indicates that in C++, the data should be stored in a Cord
instead of a string.  For very large strings, this may reduce memory
fragmentation. It may also allow better performance when parsing from a
Cord, or when parsing with aliasing enabled, as the parsed Cord may then
alias the original buffer.</p>
%}
          *)

          | STRING_PIECE

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      and JSType : sig
        type t =
          | JS_NORMAL
          (**
{%html:
<p>Use the default type.</p>
%}
          *)

          | JS_STRING
          (**
{%html:
<p>Use JavaScript strings.</p>
%}
          *)

          | JS_NUMBER
          (**
{%html:
<p>Use JavaScript numbers.</p>
%}
          *)


        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end


      (**
{%html:
<p>If set to RETENTION_SOURCE, the option will be omitted from the binary.</p>
%}
      *)
      and OptionRetention : sig
        type t =
          | RETENTION_UNKNOWN
          | RETENTION_RUNTIME
          | RETENTION_SOURCE

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end


      (**
{%html:
<p>This indicates the types of entities that the field may apply to when used
as an option. If it is unset, then the field may be freely used as an
option on any kind of entity.</p>
%}
      *)
      and OptionTargetType : sig
        type t =
          | TARGET_TYPE_UNKNOWN
          | TARGET_TYPE_FILE
          | TARGET_TYPE_EXTENSION_RANGE
          | TARGET_TYPE_MESSAGE
          | TARGET_TYPE_FIELD
          | TARGET_TYPE_ONEOF
          | TARGET_TYPE_ENUM
          | TARGET_TYPE_ENUM_ENTRY
          | TARGET_TYPE_SERVICE
          | TARGET_TYPE_METHOD

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      and EditionDefault : sig
        type t = {
          value:string option;
          (**
{%html:
<p>Textproto value.</p>
%}
          *)

          edition:Edition.t option;
        }
        val make: ?value:string -> ?edition:Edition.t -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?value:string -> ?edition:Edition.t -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end


      (**
{%html:
<p>Information about the support window of a feature.</p>
%}
      *)
      and FeatureSupport : sig
        type t = {
          edition_introduced:Edition.t option;
          (**
{%html:
<p>The edition that this feature was first available in.  In editions
earlier than this one, the default assigned to EDITION_LEGACY will be
used, and proto files will not be able to override it.</p>
%}
          *)

          edition_deprecated:Edition.t option;
          (**
{%html:
<p>The edition this feature becomes deprecated in.  Using this after this
edition may trigger warnings.</p>
%}
          *)

          deprecation_warning:string option;
          (**
{%html:
<p>The deprecation warning text if this feature is used after the edition it
was marked deprecated in.</p>
%}
          *)

          edition_removed:Edition.t option;
          (**
{%html:
<p>The edition this feature is no longer available in.  In editions after
this one, the last default assigned will be used, and proto files will
not be able to override it.</p>
%}
          *)

          removal_error:string option;
          (**
{%html:
<p>The removal error text if this feature is used after the edition it was
removed in.</p>
%}
          *)

        }
        val make: ?edition_introduced:Edition.t -> ?edition_deprecated:Edition.t -> ?deprecation_warning:string -> ?edition_removed:Edition.t -> ?removal_error:string -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?edition_introduced:Edition.t -> ?edition_deprecated:Edition.t -> ?deprecation_warning:string -> ?edition_removed:Edition.t -> ?removal_error:string -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end

      type t = {
        ctype:CType.t;
        (**
{%html:
<p>NOTE: ctype is deprecated. Use <code>features.(pb.cpp).string_type</code> instead.
The ctype option instructs the C++ code generator to use a different
representation of the field than it normally would.  See the specific
options below.  This option is only implemented to support use of
[ctype=CORD] and [ctype=STRING] (the default) on non-repeated fields of
type &quot;bytes&quot; in the open source release.
TODO: make ctype actually deprecated.</p>
%}
        *)

        packed:bool option;
        (**
{%html:
<p>The packed option can be enabled for repeated primitive fields to enable
a more efficient representation on the wire. Rather than repeatedly
writing the tag and type for each element, the entire array is encoded as
a single length-delimited blob. In proto3, only explicit setting it to
false will avoid using packed encoding.  This option is prohibited in
Editions, but the <code>repeated_field_encoding</code> feature can be used to control
the behavior.</p>
%}
        *)

        deprecated:bool;
        (**
{%html:
<p>Clients can define custom options in extensions of this message. See above.</p>
%}
        *)

        lazy':bool;
        (**
{%html:
<p>Should this field be parsed lazily?  Lazy applies only to message-type
fields.  It means that when the outer message is initially parsed, the
inner message's contents will not be parsed but instead stored in encoded
form.  The inner message will actually be parsed when it is first accessed.</p>
<p>This is only a hint.  Implementations are free to choose whether to use
eager or lazy parsing regardless of the value of this option.  However,
setting this option true suggests that the protocol author believes that
using lazy parsing on this field is worth the additional bookkeeping
overhead typically needed to implement it.</p>
<p>This option does not affect the public interface of any generated code;
all method signatures remain the same.  Furthermore, thread-safety of the
interface is not affected by this option; const methods remain safe to
call from multiple threads concurrently, while non-const methods continue
to require exclusive access.</p>
<p>Note that lazy message fields are still eagerly verified to check
ill-formed wireformat or missing required fields. Calling IsInitialized()
on the outer message would fail if the inner message has missing required
fields. Failed verification would result in parsing failure (except when
uninitialized messages are acceptable).</p>
%}
        *)

        jstype:JSType.t;
        (**
{%html:
<p>The jstype option determines the JavaScript type used for values of the
field.  The option is permitted only for 64 bit integral and fixed types
(int64, uint64, sint64, fixed64, sfixed64).  A field with jstype JS_STRING
is represented as JavaScript string, which avoids loss of precision that
can happen when a large value is converted to a floating point JavaScript.
Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
use the JavaScript &quot;number&quot; type.  The behavior of the default option
JS_NORMAL is implementation dependent.</p>
<p>This option is an enum to permit additional types to be added, e.g.
goog.math.Integer.</p>
%}
        *)

        weak:bool[@ocaml.alert protobuf "Marked as deprecated in the .proto file"];
        (**
{%html:
<p>DEPRECATED. DO NOT USE!
For Google-internal migration only. Do not use.</p>
%}
        *)

        unverified_lazy:bool;
        (**
{%html:
<p>unverified_lazy does no correctness checks on the byte stream. This should
only be used where lazy with verification is prohibitive for performance
reasons.</p>
%}
        *)

        debug_redact:bool;
        (**
{%html:
<p>Indicate that the field value should not be printed out when using debug
formats, e.g. when the field contains sensitive credentials.</p>
%}
        *)

        retention:OptionRetention.t option;
        targets:OptionTargetType.t list;
        (**
{%html:
<p>reserve target, target_obsolete_do_not_use</p>
%}
        *)

        edition_defaults:EditionDefault.t list;
        features:FeatureSet.t option;
        (**
{%html:
<p>Any features defined in the specific edition.
WARNING: This field should only be used by protobuf plugins or special
cases like the proto compiler. Other uses are discouraged and
developers should rely on the protoreflect APIs for their client language.</p>
%}
        *)

        feature_support:FeatureSupport.t option;
        uninterpreted_option:UninterpretedOption.t list;
        (**
{%html:
<p>The parser stores options it doesn't recognize here. See above.</p>
%}
        *)

        extensions':Runtime'.Extensions.t;
      }
      val make: ?ctype:CType.t -> ?packed:bool -> ?deprecated:bool -> ?lazy':bool -> ?jstype:JSType.t -> ?weak:bool -> ?unverified_lazy:bool -> ?debug_redact:bool -> ?retention:OptionRetention.t -> ?targets:OptionTargetType.t list -> ?edition_defaults:EditionDefault.t list -> ?features:FeatureSet.t -> ?feature_support:FeatureSupport.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?ctype:CType.t -> ?packed:bool -> ?deprecated:bool -> ?lazy':bool -> ?jstype:JSType.t -> ?weak:bool -> ?unverified_lazy:bool -> ?debug_redact:bool -> ?retention:OptionRetention.t -> ?targets:OptionTargetType.t list -> ?edition_defaults:EditionDefault.t list -> ?features:FeatureSet.t -> ?feature_support:FeatureSupport.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end

    and OneofOptions : sig
      type t = {
        features:FeatureSet.t option;
        (**
{%html:
<p>Any features defined in the specific edition.
WARNING: This field should only be used by protobuf plugins or special
cases like the proto compiler. Other uses are discouraged and
developers should rely on the protoreflect APIs for their client language.</p>
%}
        *)

        uninterpreted_option:UninterpretedOption.t list;
        (**
{%html:
<p>The parser stores options it doesn't recognize here. See above.</p>
%}
        *)

        extensions':Runtime'.Extensions.t;
      }
      val make: ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end

    and EnumOptions : sig
      type t = {
        allow_alias:bool option;
        (**
{%html:
<p>Set this option to true to allow mapping different tag names to the same
value.</p>
%}
        *)

        deprecated:bool;
        (**
{%html:
<p>Is this enum deprecated?
Depending on the target platform, this can emit Deprecated annotations
for the enum, or it will be completely ignored; in the very least, this
is a formalization for deprecating enums.</p>
%}
        *)

        deprecated_legacy_json_field_conflicts:bool option[@ocaml.alert protobuf "Marked as deprecated in the .proto file"];
        (**
{%html:
<p>Enable the legacy handling of JSON field name conflicts.  This lowercases
and strips underscored from the fields before comparison in proto3 only.
The new behavior takes <code>json_name</code> into account and applies to proto2 as
well.
TODO Remove this legacy behavior once downstream teams have
had time to migrate.</p>
%}
        *)

        features:FeatureSet.t option;
        (**
{%html:
<p>Any features defined in the specific edition.
WARNING: This field should only be used by protobuf plugins or special
cases like the proto compiler. Other uses are discouraged and
developers should rely on the protoreflect APIs for their client language.</p>
%}
        *)

        uninterpreted_option:UninterpretedOption.t list;
        (**
{%html:
<p>The parser stores options it doesn't recognize here. See above.</p>
%}
        *)

        extensions':Runtime'.Extensions.t;
      }
      val make: ?allow_alias:bool -> ?deprecated:bool -> ?deprecated_legacy_json_field_conflicts:bool -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?allow_alias:bool -> ?deprecated:bool -> ?deprecated_legacy_json_field_conflicts:bool -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end

    and EnumValueOptions : sig
      type t = {
        deprecated:bool;
        (**
{%html:
<p>Is this enum value deprecated?
Depending on the target platform, this can emit Deprecated annotations
for the enum value, or it will be completely ignored; in the very least,
this is a formalization for deprecating enum values.</p>
%}
        *)

        features:FeatureSet.t option;
        (**
{%html:
<p>Any features defined in the specific edition.
WARNING: This field should only be used by protobuf plugins or special
cases like the proto compiler. Other uses are discouraged and
developers should rely on the protoreflect APIs for their client language.</p>
%}
        *)

        debug_redact:bool;
        (**
{%html:
<p>Indicate that fields annotated with this enum value should not be printed
out when using debug formats, e.g. when the field contains sensitive
credentials.</p>
%}
        *)

        feature_support:FieldOptions.FeatureSupport.t option;
        (**
{%html:
<p>Information about the support window of a feature value.</p>
%}
        *)

        uninterpreted_option:UninterpretedOption.t list;
        (**
{%html:
<p>The parser stores options it doesn't recognize here. See above.</p>
%}
        *)

        extensions':Runtime'.Extensions.t;
      }
      val make: ?deprecated:bool -> ?features:FeatureSet.t -> ?debug_redact:bool -> ?feature_support:FieldOptions.FeatureSupport.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?deprecated:bool -> ?features:FeatureSet.t -> ?debug_redact:bool -> ?feature_support:FieldOptions.FeatureSupport.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end

    and ServiceOptions : sig
      type t = {
        deprecated:bool;
        (**
{%html:
<p>Is this service deprecated?
Depending on the target platform, this can emit Deprecated annotations
for the service, or it will be completely ignored; in the very least,
this is a formalization for deprecating services.</p>
<p>Note:  Field numbers 1 through 32 are reserved for Google's internal RPC</p>
<pre><code> framework.  We apologize for hoarding these numbers to ourselves, but
 we were already using them long before we decided to release Protocol
 Buffers.
</code></pre>
%}
        *)

        features:FeatureSet.t option;
        (**
{%html:
<p>Any features defined in the specific edition.
WARNING: This field should only be used by protobuf plugins or special
cases like the proto compiler. Other uses are discouraged and
developers should rely on the protoreflect APIs for their client language.</p>
%}
        *)

        uninterpreted_option:UninterpretedOption.t list;
        (**
{%html:
<p>The parser stores options it doesn't recognize here. See above.</p>
%}
        *)

        extensions':Runtime'.Extensions.t;
      }
      val make: ?deprecated:bool -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?deprecated:bool -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end

    and MethodOptions : sig

      (**
{%html:
<p>Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
or neither? HTTP based RPC implementation may choose GET verb for safe
methods, and PUT verb for idempotent methods instead of the default POST.</p>
%}
      *)
      module rec IdempotencyLevel : sig
        type t =
          | IDEMPOTENCY_UNKNOWN
          | NO_SIDE_EFFECTS
          (**
{%html:
<p>implies idempotent</p>
%}
          *)

          | IDEMPOTENT
          (**
{%html:
<p>idempotent, but may have side effects</p>
%}
          *)


        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      type t = {
        deprecated:bool;
        (**
{%html:
<p>Is this method deprecated?
Depending on the target platform, this can emit Deprecated annotations
for the method, or it will be completely ignored; in the very least,
this is a formalization for deprecating methods.</p>
<p>Note:  Field numbers 1 through 32 are reserved for Google's internal RPC</p>
<pre><code> framework.  We apologize for hoarding these numbers to ourselves, but
 we were already using them long before we decided to release Protocol
 Buffers.
</code></pre>
%}
        *)

        idempotency_level:IdempotencyLevel.t;
        features:FeatureSet.t option;
        (**
{%html:
<p>Any features defined in the specific edition.
WARNING: This field should only be used by protobuf plugins or special
cases like the proto compiler. Other uses are discouraged and
developers should rely on the protoreflect APIs for their client language.</p>
%}
        *)

        uninterpreted_option:UninterpretedOption.t list;
        (**
{%html:
<p>The parser stores options it doesn't recognize here. See above.</p>
%}
        *)

        extensions':Runtime'.Extensions.t;
      }
      val make: ?deprecated:bool -> ?idempotency_level:IdempotencyLevel.t -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?deprecated:bool -> ?idempotency_level:IdempotencyLevel.t -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end


    (**
{%html:
<p>A message representing a option the parser does not recognize. This only
appears in options protos created by the compiler::Parser class.
DescriptorPool resolves these when building Descriptor objects. Therefore,
options protos in descriptor objects (e.g. returned by Descriptor::options(),
or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
in them.</p>
%}
    *)
    and UninterpretedOption : sig

      (**
{%html:
<p>The name of the uninterpreted option.  Each string represents a segment in
a dot-separated name.  is_extension is true iff a segment represents an
extension (denoted with parentheses in options specs in .proto files).
E.g.,{ [&quot;foo&quot;, false], [&quot;bar.baz&quot;, true], [&quot;moo&quot;, false] } represents
&quot;foo.(bar.baz).moo&quot;.</p>
%}
      *)
      module rec NamePart : sig
        type t = {
          name_part:string;
          is_extension:bool;
        }
        val make: name_part:string -> is_extension:bool -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = name_part:string -> is_extension:bool -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end

      type t = {
        name:NamePart.t list;
        identifier_value:string option;
        (**
{%html:
<p>The value of the uninterpreted option, in whatever type the tokenizer
identified it as during parsing. Exactly one of these should be set.</p>
%}
        *)

        positive_int_value:int option;
        negative_int_value:int option;
        double_value:float option;
        string_value:bytes option;
        aggregate_value:string option;
      }
      val make: ?name:NamePart.t list -> ?identifier_value:string -> ?positive_int_value:int -> ?negative_int_value:int -> ?double_value:float -> ?string_value:bytes -> ?aggregate_value:string -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?name:NamePart.t list -> ?identifier_value:string -> ?positive_int_value:int -> ?negative_int_value:int -> ?double_value:float -> ?string_value:bytes -> ?aggregate_value:string -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end


    (**
{%html:
<p>TODO Enums in C++ gencode (and potentially other languages) are
not well scoped.  This means that each of the feature enums below can clash
with each other.  The short names we've chosen maximize call-site
readability, but leave us very open to this scenario.  A future feature will
be designed and implemented to handle this, hopefully before we ever hit a
conflict here.</p>
<p>===================================================================
Features</p>
%}
    *)
    and FeatureSet : sig
      module rec FieldPresence : sig
        type t =
          | FIELD_PRESENCE_UNKNOWN
          | EXPLICIT
          | IMPLICIT
          | LEGACY_REQUIRED

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      and EnumType : sig
        type t =
          | ENUM_TYPE_UNKNOWN
          | OPEN
          | CLOSED

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      and RepeatedFieldEncoding : sig
        type t =
          | REPEATED_FIELD_ENCODING_UNKNOWN
          | PACKED
          | EXPANDED

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      and Utf8Validation : sig
        type t =
          | UTF8_VALIDATION_UNKNOWN
          | VERIFY
          | NONE

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      and MessageEncoding : sig
        type t =
          | MESSAGE_ENCODING_UNKNOWN
          | LENGTH_PREFIXED
          | DELIMITED

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      and JsonFormat : sig
        type t =
          | JSON_FORMAT_UNKNOWN
          | ALLOW
          | LEGACY_BEST_EFFORT

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      and EnforceNamingStyle : sig
        type t =
          | ENFORCE_NAMING_STYLE_UNKNOWN
          | STYLE2024
          | STYLE_LEGACY

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      and VisibilityFeature : sig
        module rec DefaultSymbolVisibility : sig
          type t =
            | DEFAULT_SYMBOL_VISIBILITY_UNKNOWN
            | EXPORT_ALL
            (**
{%html:
<p>Default pre-EDITION_2024, all UNSET visibility are export.</p>
%}
            *)

            | EXPORT_TOP_LEVEL
            (**
{%html:
<p>All top-level symbols default to export, nested default to local.</p>
%}
            *)

            | LOCAL_ALL
            (**
{%html:
<p>All symbols default to local.</p>
%}
            *)

            | STRICT
            (**
{%html:
<p>All symbols local by default. Nested types cannot be exported.
With special case caveat for message { enum {} reserved 1 to max; }
This is the recommended setting for new protos.</p>
%}
            *)


          val name: unit -> string
          (** Fully qualified protobuf name of this enum *)

          (**/**)
          val to_int: t -> int
          val from_int: int -> t Runtime'.Result.t
          val from_int_exn: int -> t
          val to_string: t -> string
          val from_string_exn: string -> t
          (**/**)
        end

        type t = unit
        val make: unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end

      type t = {
        field_presence:FieldPresence.t option;
        enum_type:EnumType.t option;
        repeated_field_encoding:RepeatedFieldEncoding.t option;
        utf8_validation:Utf8Validation.t option;
        message_encoding:MessageEncoding.t option;
        json_format:JsonFormat.t option;
        (**
{%html:
<p>for https://github.com/bufbuild/protobuf-es</p>
%}
        *)

        enforce_naming_style:EnforceNamingStyle.t option;
        default_symbol_visibility:VisibilityFeature.DefaultSymbolVisibility.t option;
        extensions':Runtime'.Extensions.t;
      }
      val make: ?field_presence:FieldPresence.t -> ?enum_type:EnumType.t -> ?repeated_field_encoding:RepeatedFieldEncoding.t -> ?utf8_validation:Utf8Validation.t -> ?message_encoding:MessageEncoding.t -> ?json_format:JsonFormat.t -> ?enforce_naming_style:EnforceNamingStyle.t -> ?default_symbol_visibility:VisibilityFeature.DefaultSymbolVisibility.t -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?field_presence:FieldPresence.t -> ?enum_type:EnumType.t -> ?repeated_field_encoding:RepeatedFieldEncoding.t -> ?utf8_validation:Utf8Validation.t -> ?message_encoding:MessageEncoding.t -> ?json_format:JsonFormat.t -> ?enforce_naming_style:EnforceNamingStyle.t -> ?default_symbol_visibility:VisibilityFeature.DefaultSymbolVisibility.t -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end


    (**
{%html:
<p>A compiled specification for the defaults of a set of features.  These
messages are generated from FeatureSet extensions and can be used to seed
feature resolution. The resolution with this object becomes a simple search
for the closest matching edition, followed by proto merges.</p>
%}
    *)
    and FeatureSetDefaults : sig

      (**
{%html:
<p>A map from every known edition with a unique set of defaults to its
defaults. Not all editions may be contained here.  For a given edition,
the defaults at the closest matching edition ordered at or before it should
be used.  This field must be in strict ascending order by edition.</p>
%}
      *)
      module rec FeatureSetEditionDefault : sig
        type t = {
          edition:Edition.t option;
          overridable_features:FeatureSet.t option;
          (**
{%html:
<p>Defaults of features that can be overridden in this edition.</p>
%}
          *)

          fixed_features:FeatureSet.t option;
          (**
{%html:
<p>Defaults of features that can't be overridden in this edition.</p>
%}
          *)

        }
        val make: ?edition:Edition.t -> ?overridable_features:FeatureSet.t -> ?fixed_features:FeatureSet.t -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?edition:Edition.t -> ?overridable_features:FeatureSet.t -> ?fixed_features:FeatureSet.t -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end

      type t = {
        defaults:FeatureSetEditionDefault.t list;
        minimum_edition:Edition.t option;
        (**
{%html:
<p>The minimum supported edition (inclusive) when this was constructed.
Editions before this will not have defaults.</p>
%}
        *)

        maximum_edition:Edition.t option;
        (**
{%html:
<p>The maximum known edition (inclusive) when this was constructed. Editions
after this will not have reliable defaults.</p>
%}
        *)

      }
      val make: ?defaults:FeatureSetEditionDefault.t list -> ?minimum_edition:Edition.t -> ?maximum_edition:Edition.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?defaults:FeatureSetEditionDefault.t list -> ?minimum_edition:Edition.t -> ?maximum_edition:Edition.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end


    (**
{%html:
<p>Encapsulates information about the original source file from which a
FileDescriptorProto was generated.</p>
<p>===================================================================
Optional source code info</p>
%}
    *)
    and SourceCodeInfo : sig
      module rec Location : sig
        type t = {
          path:int list;
          (**
{%html:
<p>Identifies which part of the FileDescriptorProto was defined at this
location.</p>
<p>Each element is a field number or an index.  They form a path from
the root FileDescriptorProto to the place where the definition appears.
For example, this path:</p>
<pre><code> [ 4, 3, 2, 7, 1 ]
</code></pre>
<p>refers to:</p>
<pre><code> file.message_type(3)  // 4, 3
     .field(7)         // 2, 7
     .name()           // 1
</code></pre>
<p>This is because FileDescriptorProto.message_type has field number 4:</p>
<pre><code> repeated DescriptorProto message_type = 4;
</code></pre>
<p>and DescriptorProto.field has field number 2:</p>
<pre><code> repeated FieldDescriptorProto field = 2;
</code></pre>
<p>and FieldDescriptorProto.name has field number 1:</p>
<pre><code> optional string name = 1;
</code></pre>
<p>Thus, the above path gives the location of a field name.  If we removed
the last element:</p>
<pre><code> [ 4, 3, 2, 7 ]
</code></pre>
<p>this path refers to the whole field declaration (from the beginning
of the label to the terminating semicolon).</p>
%}
          *)

          span:int list;
          (**
{%html:
<p>Always has exactly three or four elements: start line, start column,
end line (optional, otherwise assumed same as start line), end column.
These are packed into a single field for efficiency.  Note that line
and column numbers are zero-based -- typically you will want to add
1 to each before displaying to a user.</p>
%}
          *)

          leading_comments:string option;
          (**
{%html:
<p>If this SourceCodeInfo represents a complete declaration, these are any
comments appearing before and after the declaration which appear to be
attached to the declaration.</p>
<p>A series of line comments appearing on consecutive lines, with no other
tokens appearing on those lines, will be treated as a single comment.</p>
<p>leading_detached_comments will keep paragraphs of comments that appear
before (but not connected to) the current element. Each paragraph,
separated by empty lines, will be one comment element in the repeated
field.</p>
<p>Only the comment content is provided; comment markers (e.g. //) are
stripped out.  For block comments, leading whitespace and an asterisk
will be stripped from the beginning of each line other than the first.
Newlines are included in the output.</p>
<p>Examples:</p>
<pre><code> optional int32 foo = 1;  // Comment attached to foo.
</code></pre>
<p>Comment attached to bar.</p>
<pre><code> optional int32 bar = 2;

 optional string baz = 3;
</code></pre>
<p>Comment attached to baz.
Another line attached to baz.</p>
<p>Comment attached to moo.</p>
<p>Another line attached to moo.</p>
<pre><code> optional double moo = 4;
</code></pre>
<p>Detached comment for corge. This is not leading or trailing comments
to moo or corge because there are blank lines separating it from
both.</p>
<p>Detached comment for corge paragraph 2.</p>
<pre><code> optional string corge = 5;
 /* Block comment attached
  * to corge.  Leading asterisks
  * will be removed. */
 /* Block comment attached to
  * grault. */
 optional int32 grault = 6;
</code></pre>
<p>ignored detached comments.</p>
%}
          *)

          trailing_comments:string option;
          leading_detached_comments:string list;
        }
        val make: ?path:int list -> ?span:int list -> ?leading_comments:string -> ?trailing_comments:string -> ?leading_detached_comments:string list -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?path:int list -> ?span:int list -> ?leading_comments:string -> ?trailing_comments:string -> ?leading_detached_comments:string list -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end

      type t = {
        location:Location.t list;
        (**
{%html:
<p>A Location identifies a piece of source code in a .proto file which
corresponds to a particular definition.  This information is intended
to be useful to IDEs, code indexers, documentation generators, and similar
tools.</p>
<p>For example, say we have a file like:</p>
<pre><code> message Foo {
   optional string foo = 1;
 }
</code></pre>
<p>Let's look at just the field definition:</p>
<pre><code> optional string foo = 1;
 ^       ^^     ^^  ^  ^^^
 a       bc     de  f  ghi
</code></pre>
<p>We have the following locations:</p>
<pre><code> span   path               represents
 [a,i)  [ 4, 0, 2, 0 ]     The whole field definition.
 [a,b)  [ 4, 0, 2, 0, 4 ]  The label (optional).
 [c,d)  [ 4, 0, 2, 0, 5 ]  The type (string).
 [e,f)  [ 4, 0, 2, 0, 1 ]  The name (foo).
 [g,h)  [ 4, 0, 2, 0, 3 ]  The number (1).
</code></pre>
<p>Notes:</p>
<ul>
<li>A location may refer to a repeated field itself (i.e. not to any
particular index within it).  This is used whenever a set of elements are
logically enclosed in a single code segment.  For example, an entire
extend block (possibly containing multiple extension definitions) will
have an outer location whose path refers to the &quot;extensions&quot; repeated
field without an index.
</li>
<li>Multiple locations may have the same path.  This happens when a single
logical declaration is spread out across multiple places.  The most
obvious example is the &quot;extend&quot; block again -- there may be multiple
extend blocks in the same scope, each of which will have the same path.
</li>
<li>A location's span is not always a subset of its parent's span.  For
example, the &quot;extendee&quot; of an extension declaration appears at the
beginning of the &quot;extend&quot; block and is shared by all extensions within
the block.
</li>
<li>Just because a location's span is a subset of some other location's span
does not mean that it is a descendant.  For example, a &quot;group&quot; defines
both a type and a field in a single declaration.  Thus, the locations
corresponding to the type and field and their components will overlap.
</li>
<li>Code which tries to interpret locations should probably be designed to
ignore those that it doesn't understand, as more types of locations could
be recorded in the future.
</li>
</ul>
%}
        *)

        extensions':Runtime'.Extensions.t;
      }
      val make: ?location:Location.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?location:Location.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end


    (**
{%html:
<p>Describes the relationship between generated code and its original source
file. A GeneratedCodeInfo message is associated with only one generated
source file, but may contain references to different source .proto files.</p>
%}
    *)
    and GeneratedCodeInfo : sig
      module rec Annotation : sig

        (**
{%html:
<p>Represents the identified object's effect on the element in the original
.proto file.</p>
%}
        *)
        module rec Semantic : sig
          type t =
            | NONE
            (**
{%html:
<p>There is no effect or the effect is indescribable.</p>
%}
            *)

            | SET
            (**
{%html:
<p>The element is set or otherwise mutated.</p>
%}
            *)

            | ALIAS
            (**
{%html:
<p>An alias to the element is returned.</p>
%}
            *)


          val name: unit -> string
          (** Fully qualified protobuf name of this enum *)

          (**/**)
          val to_int: t -> int
          val from_int: int -> t Runtime'.Result.t
          val from_int_exn: int -> t
          val to_string: t -> string
          val from_string_exn: string -> t
          (**/**)
        end

        type t = {
          path:int list;
          (**
{%html:
<p>Identifies the element in the original source .proto file. This field
is formatted the same as SourceCodeInfo.Location.path.</p>
%}
          *)

          source_file:string option;
          (**
{%html:
<p>Identifies the filesystem path to the original source .proto.</p>
%}
          *)

          begin':int option;
          (**
{%html:
<p>Identifies the starting offset in bytes in the generated code
that relates to the identified object.</p>
%}
          *)

          end':int option;
          (**
{%html:
<p>Identifies the ending offset in bytes in the generated code that
relates to the identified object. The end offset should be one past
the last relevant byte (so the length of the text = end - begin).</p>
%}
          *)

          semantic:Semantic.t option;
        }
        val make: ?path:int list -> ?source_file:string -> ?begin':int -> ?end':int -> ?semantic:Semantic.t -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?path:int list -> ?source_file:string -> ?begin':int -> ?end':int -> ?semantic:Semantic.t -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end

      type t = (Annotation.t list)
      (**
{%html:
<p>An Annotation connects some span of text in generated code to an element
of its generating .proto file.</p>
%}
      *)

      val make: ?annotation:Annotation.t list -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?annotation:Annotation.t list -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end

  end = struct
    module rec Edition : sig
      type t =
        | EDITION_UNKNOWN
        (**
{%html:
<p>A placeholder for an unknown edition value.</p>
%}
        *)

        | EDITION_LEGACY
        (**
{%html:
<p>A placeholder edition for specifying default behaviors <em>before</em> a feature
was first introduced.  This is effectively an &quot;infinite past&quot;.</p>
%}
        *)

        | EDITION_PROTO2
        (**
{%html:
<p>Legacy syntax &quot;editions&quot;.  These pre-date editions, but behave much like
distinct editions.  These can't be used to specify the edition of proto
files, but feature definitions must supply proto2/proto3 defaults for
backwards compatibility.</p>
%}
        *)

        | EDITION_PROTO3
        | EDITION_2023
        (**
{%html:
<p>Editions that have been released.  The specific values are arbitrary and
should not be depended on, but they will always be time-ordered for easy
comparison.</p>
%}
        *)

        | EDITION_2024
        | EDITION_UNSTABLE
        (**
{%html:
<p>A placeholder edition for developing and testing unscheduled features.</p>
%}
        *)

        | EDITION_1_TEST_ONLY
        (**
{%html:
<p>Placeholder editions for testing feature resolution.  These should not be
used or relied on outside of tests.</p>
%}
        *)

        | EDITION_2_TEST_ONLY
        | EDITION_99997_TEST_ONLY
        | EDITION_99998_TEST_ONLY
        | EDITION_99999_TEST_ONLY
        | EDITION_MAX
        (**
{%html:
<p>Placeholder for specifying unbounded edition support.  This should only
ever be used by plugins that can expect to never require any changes to
support a new edition.</p>
%}
        *)


      val name: unit -> string
      (** Fully qualified protobuf name of this enum *)

      (**/**)
      val to_int: t -> int
      val from_int: int -> t Runtime'.Result.t
      val from_int_exn: int -> t
      val to_string: t -> string
      val from_string_exn: string -> t
      (**/**)
    end = struct
      module This'_ = Edition
      type t =
        | EDITION_UNKNOWN
        (**
{%html:
<p>A placeholder for an unknown edition value.</p>
%}
        *)

        | EDITION_LEGACY
        (**
{%html:
<p>A placeholder edition for specifying default behaviors <em>before</em> a feature
was first introduced.  This is effectively an &quot;infinite past&quot;.</p>
%}
        *)

        | EDITION_PROTO2
        (**
{%html:
<p>Legacy syntax &quot;editions&quot;.  These pre-date editions, but behave much like
distinct editions.  These can't be used to specify the edition of proto
files, but feature definitions must supply proto2/proto3 defaults for
backwards compatibility.</p>
%}
        *)

        | EDITION_PROTO3
        | EDITION_2023
        (**
{%html:
<p>Editions that have been released.  The specific values are arbitrary and
should not be depended on, but they will always be time-ordered for easy
comparison.</p>
%}
        *)

        | EDITION_2024
        | EDITION_UNSTABLE
        (**
{%html:
<p>A placeholder edition for developing and testing unscheduled features.</p>
%}
        *)

        | EDITION_1_TEST_ONLY
        (**
{%html:
<p>Placeholder editions for testing feature resolution.  These should not be
used or relied on outside of tests.</p>
%}
        *)

        | EDITION_2_TEST_ONLY
        | EDITION_99997_TEST_ONLY
        | EDITION_99998_TEST_ONLY
        | EDITION_99999_TEST_ONLY
        | EDITION_MAX
        (**
{%html:
<p>Placeholder for specifying unbounded edition support.  This should only
ever be used by plugins that can expect to never require any changes to
support a new edition.</p>
%}
        *)


      let name () = ".google.protobuf.Edition"
      let to_int = function
        | EDITION_UNKNOWN -> 0
        | EDITION_LEGACY -> 900
        | EDITION_PROTO2 -> 998
        | EDITION_PROTO3 -> 999
        | EDITION_2023 -> 1000
        | EDITION_2024 -> 1001
        | EDITION_UNSTABLE -> 9999
        | EDITION_1_TEST_ONLY -> 1
        | EDITION_2_TEST_ONLY -> 2
        | EDITION_99997_TEST_ONLY -> 99997
        | EDITION_99998_TEST_ONLY -> 99998
        | EDITION_99999_TEST_ONLY -> 99999
        | EDITION_MAX -> 2147483647
      let from_int_exn = function
        | 0 -> EDITION_UNKNOWN
        | 900 -> EDITION_LEGACY
        | 998 -> EDITION_PROTO2
        | 999 -> EDITION_PROTO3
        | 1000 -> EDITION_2023
        | 1001 -> EDITION_2024
        | 9999 -> EDITION_UNSTABLE
        | 1 -> EDITION_1_TEST_ONLY
        | 2 -> EDITION_2_TEST_ONLY
        | 99997 -> EDITION_99997_TEST_ONLY
        | 99998 -> EDITION_99998_TEST_ONLY
        | 99999 -> EDITION_99999_TEST_ONLY
        | 2147483647 -> EDITION_MAX
        | n -> Runtime'.Result.raise (`Unknown_enum_value n)
      let from_int e = Runtime'.Result.catch (fun () -> from_int_exn e)
      let to_string = function
        | EDITION_UNKNOWN -> "EDITION_UNKNOWN"
        | EDITION_LEGACY -> "EDITION_LEGACY"
        | EDITION_PROTO2 -> "EDITION_PROTO2"
        | EDITION_PROTO3 -> "EDITION_PROTO3"
        | EDITION_2023 -> "EDITION_2023"
        | EDITION_2024 -> "EDITION_2024"
        | EDITION_UNSTABLE -> "EDITION_UNSTABLE"
        | EDITION_1_TEST_ONLY -> "EDITION_1_TEST_ONLY"
        | EDITION_2_TEST_ONLY -> "EDITION_2_TEST_ONLY"
        | EDITION_99997_TEST_ONLY -> "EDITION_99997_TEST_ONLY"
        | EDITION_99998_TEST_ONLY -> "EDITION_99998_TEST_ONLY"
        | EDITION_99999_TEST_ONLY -> "EDITION_99999_TEST_ONLY"
        | EDITION_MAX -> "EDITION_MAX"
      let from_string_exn = function
        | "EDITION_UNKNOWN" -> EDITION_UNKNOWN
        | "EDITION_LEGACY" -> EDITION_LEGACY
        | "EDITION_PROTO2" -> EDITION_PROTO2
        | "EDITION_PROTO3" -> EDITION_PROTO3
        | "EDITION_2023" -> EDITION_2023
        | "EDITION_2024" -> EDITION_2024
        | "EDITION_UNSTABLE" -> EDITION_UNSTABLE
        | "EDITION_1_TEST_ONLY" -> EDITION_1_TEST_ONLY
        | "EDITION_2_TEST_ONLY" -> EDITION_2_TEST_ONLY
        | "EDITION_99997_TEST_ONLY" -> EDITION_99997_TEST_ONLY
        | "EDITION_99998_TEST_ONLY" -> EDITION_99998_TEST_ONLY
        | "EDITION_99999_TEST_ONLY" -> EDITION_99999_TEST_ONLY
        | "EDITION_MAX" -> EDITION_MAX
        | s -> Runtime'.Result.raise (`Unknown_enum_name s)

    end

    and SymbolVisibility : sig
      type t =
        | VISIBILITY_UNSET
        | VISIBILITY_LOCAL
        | VISIBILITY_EXPORT

      val name: unit -> string
      (** Fully qualified protobuf name of this enum *)

      (**/**)
      val to_int: t -> int
      val from_int: int -> t Runtime'.Result.t
      val from_int_exn: int -> t
      val to_string: t -> string
      val from_string_exn: string -> t
      (**/**)
    end = struct
      module This'_ = SymbolVisibility
      type t =
        | VISIBILITY_UNSET
        | VISIBILITY_LOCAL
        | VISIBILITY_EXPORT

      let name () = ".google.protobuf.SymbolVisibility"
      let to_int = function
        | VISIBILITY_UNSET -> 0
        | VISIBILITY_LOCAL -> 1
        | VISIBILITY_EXPORT -> 2
      let from_int_exn = function
        | 0 -> VISIBILITY_UNSET
        | 1 -> VISIBILITY_LOCAL
        | 2 -> VISIBILITY_EXPORT
        | n -> Runtime'.Result.raise (`Unknown_enum_value n)
      let from_int e = Runtime'.Result.catch (fun () -> from_int_exn e)
      let to_string = function
        | VISIBILITY_UNSET -> "VISIBILITY_UNSET"
        | VISIBILITY_LOCAL -> "VISIBILITY_LOCAL"
        | VISIBILITY_EXPORT -> "VISIBILITY_EXPORT"
      let from_string_exn = function
        | "VISIBILITY_UNSET" -> VISIBILITY_UNSET
        | "VISIBILITY_LOCAL" -> VISIBILITY_LOCAL
        | "VISIBILITY_EXPORT" -> VISIBILITY_EXPORT
        | s -> Runtime'.Result.raise (`Unknown_enum_name s)

    end

    and FileDescriptorSet : sig
      type t = {
        file:FileDescriptorProto.t list;
        extensions':Runtime'.Extensions.t;
      }
      val make: ?file:FileDescriptorProto.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?file:FileDescriptorProto.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end = struct
      module This'_ = FileDescriptorSet
      let name () = ".google.protobuf.FileDescriptorSet"
      type t = {
        file:FileDescriptorProto.t list;
        extensions':Runtime'.Extensions.t;
      }
      type make_t = ?file:FileDescriptorProto.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      let make ?(file = []) ?(extensions' = Runtime'.Extensions.default) () = { file; extensions' }
      let merge =
      let merge_file = Runtime'.Merge.merge Runtime'.Spec.( repeated ((1, "file", "file"), (message (module FileDescriptorProto)), not_packed) ) in
      fun t1 t2 -> {
      	file = (merge_file t1.file t2.file);
      	extensions' = (List.append t1.extensions' t2.extensions');
       }
      let spec () = Runtime'.Spec.( repeated ((1, "file", "file"), (message (module FileDescriptorProto)), not_packed) ^:: nil_ext [ (536000000, 536000001) ] )
      let to_proto' =
        let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
        fun writer { file; extensions' } -> serialize writer file extensions'

      let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
      let from_proto_exn =
        let constructor file extensions' = { file; extensions' } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
      let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
      let to_json options =
        let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
        fun { file; extensions' } -> serialize file extensions'
      let from_json_exn =
        let constructor file extensions' = { file; extensions' } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
      let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
    end

    and FileDescriptorProto : sig
      type t = {
        name:string option;
        (**
{%html:
<p>file name, relative to root of source tree</p>
%}
        *)

        package:string option;
        (**
{%html:
<p>e.g. &quot;foo&quot;, &quot;foo.bar&quot;, etc.</p>
%}
        *)

        dependency:string list;
        (**
{%html:
<p>Names of files imported by this file.</p>
%}
        *)

        message_type:DescriptorProto.t list;
        (**
{%html:
<p>All top-level definitions in this file.</p>
%}
        *)

        enum_type:EnumDescriptorProto.t list;
        service:ServiceDescriptorProto.t list;
        extension:FieldDescriptorProto.t list;
        options:FileOptions.t option;
        source_code_info:SourceCodeInfo.t option;
        (**
{%html:
<p>This field contains optional information about the original source code.
You may safely remove this entire field without harming runtime
functionality of the descriptors -- the information is needed only by
development tools.</p>
%}
        *)

        public_dependency:int list;
        (**
{%html:
<p>Indexes of the public imported files in the dependency list above.</p>
%}
        *)

        weak_dependency:int list;
        (**
{%html:
<p>Indexes of the weak imported files in the dependency list.
For Google-internal migration only. Do not use.</p>
%}
        *)

        syntax:string option;
        (**
{%html:
<p>The syntax of the proto file.
The supported values are &quot;proto2&quot;, &quot;proto3&quot;, and &quot;editions&quot;.</p>
<p>If <code>edition</code> is present, this value must be &quot;editions&quot;.
WARNING: This field should only be used by protobuf plugins or special
cases like the proto compiler. Other uses are discouraged and
developers should rely on the protoreflect APIs for their client language.</p>
%}
        *)

        edition:Edition.t option;
        (**
{%html:
<p>The edition of the proto file.
WARNING: This field should only be used by protobuf plugins or special
cases like the proto compiler. Other uses are discouraged and
developers should rely on the protoreflect APIs for their client language.</p>
%}
        *)

        option_dependency:string list;
        (**
{%html:
<p>Names of files imported by this file purely for the purpose of providing
option extensions. These are excluded from the dependency list above.</p>
%}
        *)

      }
      val make: ?name:string -> ?package:string -> ?dependency:string list -> ?message_type:DescriptorProto.t list -> ?enum_type:EnumDescriptorProto.t list -> ?service:ServiceDescriptorProto.t list -> ?extension:FieldDescriptorProto.t list -> ?options:FileOptions.t -> ?source_code_info:SourceCodeInfo.t -> ?public_dependency:int list -> ?weak_dependency:int list -> ?syntax:string -> ?edition:Edition.t -> ?option_dependency:string list -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?name:string -> ?package:string -> ?dependency:string list -> ?message_type:DescriptorProto.t list -> ?enum_type:EnumDescriptorProto.t list -> ?service:ServiceDescriptorProto.t list -> ?extension:FieldDescriptorProto.t list -> ?options:FileOptions.t -> ?source_code_info:SourceCodeInfo.t -> ?public_dependency:int list -> ?weak_dependency:int list -> ?syntax:string -> ?edition:Edition.t -> ?option_dependency:string list -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end = struct
      module This'_ = FileDescriptorProto
      let name () = ".google.protobuf.FileDescriptorProto"
      type t = {
        name:string option;
        package:string option;
        dependency:string list;
        message_type:DescriptorProto.t list;
        enum_type:EnumDescriptorProto.t list;
        service:ServiceDescriptorProto.t list;
        extension:FieldDescriptorProto.t list;
        options:FileOptions.t option;
        source_code_info:SourceCodeInfo.t option;
        public_dependency:int list;
        weak_dependency:int list;
        syntax:string option;
        edition:Edition.t option;
        option_dependency:string list;
      }
      type make_t = ?name:string -> ?package:string -> ?dependency:string list -> ?message_type:DescriptorProto.t list -> ?enum_type:EnumDescriptorProto.t list -> ?service:ServiceDescriptorProto.t list -> ?extension:FieldDescriptorProto.t list -> ?options:FileOptions.t -> ?source_code_info:SourceCodeInfo.t -> ?public_dependency:int list -> ?weak_dependency:int list -> ?syntax:string -> ?edition:Edition.t -> ?option_dependency:string list -> unit -> t
      let make ?name ?package ?(dependency = []) ?(message_type = []) ?(enum_type = []) ?(service = []) ?(extension = []) ?options ?source_code_info ?(public_dependency = []) ?(weak_dependency = []) ?syntax ?edition ?(option_dependency = []) () = { name; package; dependency; message_type; enum_type; service; extension; options; source_code_info; public_dependency; weak_dependency; syntax; edition; option_dependency }
      let merge =
      let merge_name = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((1, "name", "name"), string) ) in
      let merge_package = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((2, "package", "package"), string) ) in
      let merge_dependency = Runtime'.Merge.merge Runtime'.Spec.( repeated ((3, "dependency", "dependency"), string, not_packed) ) in
      let merge_message_type = Runtime'.Merge.merge Runtime'.Spec.( repeated ((4, "message_type", "messageType"), (message (module DescriptorProto)), not_packed) ) in
      let merge_enum_type = Runtime'.Merge.merge Runtime'.Spec.( repeated ((5, "enum_type", "enumType"), (message (module EnumDescriptorProto)), not_packed) ) in
      let merge_service = Runtime'.Merge.merge Runtime'.Spec.( repeated ((6, "service", "service"), (message (module ServiceDescriptorProto)), not_packed) ) in
      let merge_extension = Runtime'.Merge.merge Runtime'.Spec.( repeated ((7, "extension", "extension"), (message (module FieldDescriptorProto)), not_packed) ) in
      let merge_options = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((8, "options", "options"), (message (module FileOptions))) ) in
      let merge_source_code_info = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((9, "source_code_info", "sourceCodeInfo"), (message (module SourceCodeInfo))) ) in
      let merge_public_dependency = Runtime'.Merge.merge Runtime'.Spec.( repeated ((10, "public_dependency", "publicDependency"), int32_int, not_packed) ) in
      let merge_weak_dependency = Runtime'.Merge.merge Runtime'.Spec.( repeated ((11, "weak_dependency", "weakDependency"), int32_int, not_packed) ) in
      let merge_syntax = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((12, "syntax", "syntax"), string) ) in
      let merge_edition = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((14, "edition", "edition"), (enum (module Edition))) ) in
      let merge_option_dependency = Runtime'.Merge.merge Runtime'.Spec.( repeated ((15, "option_dependency", "optionDependency"), string, not_packed) ) in
      fun t1 t2 -> {
      	name = (merge_name t1.name t2.name);
      	package = (merge_package t1.package t2.package);
      	dependency = (merge_dependency t1.dependency t2.dependency);
      	message_type = (merge_message_type t1.message_type t2.message_type);
      	enum_type = (merge_enum_type t1.enum_type t2.enum_type);
      	service = (merge_service t1.service t2.service);
      	extension = (merge_extension t1.extension t2.extension);
      	options = (merge_options t1.options t2.options);
      	source_code_info = (merge_source_code_info t1.source_code_info t2.source_code_info);
      	public_dependency = (merge_public_dependency t1.public_dependency t2.public_dependency);
      	weak_dependency = (merge_weak_dependency t1.weak_dependency t2.weak_dependency);
      	syntax = (merge_syntax t1.syntax t2.syntax);
      	edition = (merge_edition t1.edition t2.edition);
      	option_dependency = (merge_option_dependency t1.option_dependency t2.option_dependency);
       }
      let spec () = Runtime'.Spec.( basic_opt ((1, "name", "name"), string) ^:: basic_opt ((2, "package", "package"), string) ^:: repeated ((3, "dependency", "dependency"), string, not_packed) ^:: repeated ((4, "message_type", "messageType"), (message (module DescriptorProto)), not_packed) ^:: repeated ((5, "enum_type", "enumType"), (message (module EnumDescriptorProto)), not_packed) ^:: repeated ((6, "service", "service"), (message (module ServiceDescriptorProto)), not_packed) ^:: repeated ((7, "extension", "extension"), (message (module FieldDescriptorProto)), not_packed) ^:: basic_opt ((8, "options", "options"), (message (module FileOptions))) ^:: basic_opt ((9, "source_code_info", "sourceCodeInfo"), (message (module SourceCodeInfo))) ^:: repeated ((10, "public_dependency", "publicDependency"), int32_int, not_packed) ^:: repeated ((11, "weak_dependency", "weakDependency"), int32_int, not_packed) ^:: basic_opt ((12, "syntax", "syntax"), string) ^:: basic_opt ((14, "edition", "edition"), (enum (module Edition))) ^:: repeated ((15, "option_dependency", "optionDependency"), string, not_packed) ^:: nil )
      let to_proto' =
        let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
        fun writer { name; package; dependency; message_type; enum_type; service; extension; options; source_code_info; public_dependency; weak_dependency; syntax; edition; option_dependency } -> serialize writer name package dependency message_type enum_type service extension options source_code_info public_dependency weak_dependency syntax edition option_dependency

      let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
      let from_proto_exn =
        let constructor name package dependency message_type enum_type service extension options source_code_info public_dependency weak_dependency syntax edition option_dependency = { name; package; dependency; message_type; enum_type; service; extension; options; source_code_info; public_dependency; weak_dependency; syntax; edition; option_dependency } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
      let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
      let to_json options =
        let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
        fun { name; package; dependency; message_type; enum_type; service; extension; options; source_code_info; public_dependency; weak_dependency; syntax; edition; option_dependency } -> serialize name package dependency message_type enum_type service extension options source_code_info public_dependency weak_dependency syntax edition option_dependency
      let from_json_exn =
        let constructor name package dependency message_type enum_type service extension options source_code_info public_dependency weak_dependency syntax edition option_dependency = { name; package; dependency; message_type; enum_type; service; extension; options; source_code_info; public_dependency; weak_dependency; syntax; edition; option_dependency } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
      let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
    end

    and DescriptorProto : sig
      module rec ExtensionRange : sig
        type t = {
          start:int option;
          (**
{%html:
<p>Inclusive.</p>
%}
          *)

          end':int option;
          (**
{%html:
<p>Exclusive.</p>
%}
          *)

          options:ExtensionRangeOptions.t option;
        }
        val make: ?start:int -> ?end':int -> ?options:ExtensionRangeOptions.t -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?start:int -> ?end':int -> ?options:ExtensionRangeOptions.t -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end


      (**
{%html:
<p>Range of reserved tag numbers. Reserved tag numbers may not be used by
fields or extension ranges in the same message. Reserved ranges may
not overlap.</p>
%}
      *)
      and ReservedRange : sig
        type t = {
          start:int option;
          (**
{%html:
<p>Inclusive.</p>
%}
          *)

          end':int option;
          (**
{%html:
<p>Exclusive.</p>
%}
          *)

        }
        val make: ?start:int -> ?end':int -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?start:int -> ?end':int -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end

      type t = {
        name:string option;
        field:FieldDescriptorProto.t list;
        nested_type:t list;
        enum_type:EnumDescriptorProto.t list;
        extension_range:ExtensionRange.t list;
        extension:FieldDescriptorProto.t list;
        options:MessageOptions.t option;
        oneof_decl:OneofDescriptorProto.t list;
        reserved_range:ReservedRange.t list;
        reserved_name:string list;
        (**
{%html:
<p>Reserved field names, which may not be used by fields in the same message.
A given name may only be reserved once.</p>
%}
        *)

        visibility:SymbolVisibility.t option;
        (**
{%html:
<p>Support for <code>export</code> and <code>local</code> keywords on enums.</p>
%}
        *)

      }
      val make: ?name:string -> ?field:FieldDescriptorProto.t list -> ?nested_type:t list -> ?enum_type:EnumDescriptorProto.t list -> ?extension_range:ExtensionRange.t list -> ?extension:FieldDescriptorProto.t list -> ?options:MessageOptions.t -> ?oneof_decl:OneofDescriptorProto.t list -> ?reserved_range:ReservedRange.t list -> ?reserved_name:string list -> ?visibility:SymbolVisibility.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?name:string -> ?field:FieldDescriptorProto.t list -> ?nested_type:t list -> ?enum_type:EnumDescriptorProto.t list -> ?extension_range:ExtensionRange.t list -> ?extension:FieldDescriptorProto.t list -> ?options:MessageOptions.t -> ?oneof_decl:OneofDescriptorProto.t list -> ?reserved_range:ReservedRange.t list -> ?reserved_name:string list -> ?visibility:SymbolVisibility.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end = struct
      module This'_ = DescriptorProto
      module rec ExtensionRange : sig
        type t = {
          start:int option;
          (**
{%html:
<p>Inclusive.</p>
%}
          *)

          end':int option;
          (**
{%html:
<p>Exclusive.</p>
%}
          *)

          options:ExtensionRangeOptions.t option;
        }
        val make: ?start:int -> ?end':int -> ?options:ExtensionRangeOptions.t -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?start:int -> ?end':int -> ?options:ExtensionRangeOptions.t -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end = struct
        module This'_ = ExtensionRange
        let name () = ".google.protobuf.DescriptorProto.ExtensionRange"
        type t = {
          start:int option;
          end':int option;
          options:ExtensionRangeOptions.t option;
        }
        type make_t = ?start:int -> ?end':int -> ?options:ExtensionRangeOptions.t -> unit -> t
        let make ?start ?end' ?options () = { start; end'; options }
        let merge =
        let merge_start = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((1, "start", "start"), int32_int) ) in
        let merge_end' = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((2, "end", "end"), int32_int) ) in
        let merge_options = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((3, "options", "options"), (message (module ExtensionRangeOptions))) ) in
        fun t1 t2 -> {
        	start = (merge_start t1.start t2.start);
        	end' = (merge_end' t1.end' t2.end');
        	options = (merge_options t1.options t2.options);
         }
        let spec () = Runtime'.Spec.( basic_opt ((1, "start", "start"), int32_int) ^:: basic_opt ((2, "end", "end"), int32_int) ^:: basic_opt ((3, "options", "options"), (message (module ExtensionRangeOptions))) ^:: nil )
        let to_proto' =
          let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
          fun writer { start; end'; options } -> serialize writer start end' options

        let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
        let from_proto_exn =
          let constructor start end' options = { start; end'; options } in
          Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
        let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
        let to_json options =
          let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
          fun { start; end'; options } -> serialize start end' options
        let from_json_exn =
          let constructor start end' options = { start; end'; options } in
          Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
        let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
      end

      and ReservedRange : sig
        type t = {
          start:int option;
          (**
{%html:
<p>Inclusive.</p>
%}
          *)

          end':int option;
          (**
{%html:
<p>Exclusive.</p>
%}
          *)

        }
        val make: ?start:int -> ?end':int -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?start:int -> ?end':int -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end = struct
        module This'_ = ReservedRange
        let name () = ".google.protobuf.DescriptorProto.ReservedRange"
        type t = {
          start:int option;
          end':int option;
        }
        type make_t = ?start:int -> ?end':int -> unit -> t
        let make ?start ?end' () = { start; end' }
        let merge =
        let merge_start = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((1, "start", "start"), int32_int) ) in
        let merge_end' = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((2, "end", "end"), int32_int) ) in
        fun t1 t2 -> {
        	start = (merge_start t1.start t2.start);
        	end' = (merge_end' t1.end' t2.end');
         }
        let spec () = Runtime'.Spec.( basic_opt ((1, "start", "start"), int32_int) ^:: basic_opt ((2, "end", "end"), int32_int) ^:: nil )
        let to_proto' =
          let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
          fun writer { start; end' } -> serialize writer start end'

        let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
        let from_proto_exn =
          let constructor start end' = { start; end' } in
          Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
        let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
        let to_json options =
          let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
          fun { start; end' } -> serialize start end'
        let from_json_exn =
          let constructor start end' = { start; end' } in
          Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
        let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
      end

      let name () = ".google.protobuf.DescriptorProto"
      type t = {
        name:string option;
        field:FieldDescriptorProto.t list;
        nested_type:t list;
        enum_type:EnumDescriptorProto.t list;
        extension_range:ExtensionRange.t list;
        extension:FieldDescriptorProto.t list;
        options:MessageOptions.t option;
        oneof_decl:OneofDescriptorProto.t list;
        reserved_range:ReservedRange.t list;
        reserved_name:string list;
        visibility:SymbolVisibility.t option;
      }
      type make_t = ?name:string -> ?field:FieldDescriptorProto.t list -> ?nested_type:t list -> ?enum_type:EnumDescriptorProto.t list -> ?extension_range:ExtensionRange.t list -> ?extension:FieldDescriptorProto.t list -> ?options:MessageOptions.t -> ?oneof_decl:OneofDescriptorProto.t list -> ?reserved_range:ReservedRange.t list -> ?reserved_name:string list -> ?visibility:SymbolVisibility.t -> unit -> t
      let make ?name ?(field = []) ?(nested_type = []) ?(enum_type = []) ?(extension_range = []) ?(extension = []) ?options ?(oneof_decl = []) ?(reserved_range = []) ?(reserved_name = []) ?visibility () = { name; field; nested_type; enum_type; extension_range; extension; options; oneof_decl; reserved_range; reserved_name; visibility }
      let merge =
      let merge_name = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((1, "name", "name"), string) ) in
      let merge_field = Runtime'.Merge.merge Runtime'.Spec.( repeated ((2, "field", "field"), (message (module FieldDescriptorProto)), not_packed) ) in
      let merge_nested_type = Runtime'.Merge.merge Runtime'.Spec.( repeated ((3, "nested_type", "nestedType"), (message (module This'_)), not_packed) ) in
      let merge_enum_type = Runtime'.Merge.merge Runtime'.Spec.( repeated ((4, "enum_type", "enumType"), (message (module EnumDescriptorProto)), not_packed) ) in
      let merge_extension_range = Runtime'.Merge.merge Runtime'.Spec.( repeated ((5, "extension_range", "extensionRange"), (message (module ExtensionRange)), not_packed) ) in
      let merge_extension = Runtime'.Merge.merge Runtime'.Spec.( repeated ((6, "extension", "extension"), (message (module FieldDescriptorProto)), not_packed) ) in
      let merge_options = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((7, "options", "options"), (message (module MessageOptions))) ) in
      let merge_oneof_decl = Runtime'.Merge.merge Runtime'.Spec.( repeated ((8, "oneof_decl", "oneofDecl"), (message (module OneofDescriptorProto)), not_packed) ) in
      let merge_reserved_range = Runtime'.Merge.merge Runtime'.Spec.( repeated ((9, "reserved_range", "reservedRange"), (message (module ReservedRange)), not_packed) ) in
      let merge_reserved_name = Runtime'.Merge.merge Runtime'.Spec.( repeated ((10, "reserved_name", "reservedName"), string, not_packed) ) in
      let merge_visibility = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((11, "visibility", "visibility"), (enum (module SymbolVisibility))) ) in
      fun t1 t2 -> {
      	name = (merge_name t1.name t2.name);
      	field = (merge_field t1.field t2.field);
      	nested_type = (merge_nested_type t1.nested_type t2.nested_type);
      	enum_type = (merge_enum_type t1.enum_type t2.enum_type);
      	extension_range = (merge_extension_range t1.extension_range t2.extension_range);
      	extension = (merge_extension t1.extension t2.extension);
      	options = (merge_options t1.options t2.options);
      	oneof_decl = (merge_oneof_decl t1.oneof_decl t2.oneof_decl);
      	reserved_range = (merge_reserved_range t1.reserved_range t2.reserved_range);
      	reserved_name = (merge_reserved_name t1.reserved_name t2.reserved_name);
      	visibility = (merge_visibility t1.visibility t2.visibility);
       }
      let spec () = Runtime'.Spec.( basic_opt ((1, "name", "name"), string) ^:: repeated ((2, "field", "field"), (message (module FieldDescriptorProto)), not_packed) ^:: repeated ((3, "nested_type", "nestedType"), (message (module This'_)), not_packed) ^:: repeated ((4, "enum_type", "enumType"), (message (module EnumDescriptorProto)), not_packed) ^:: repeated ((5, "extension_range", "extensionRange"), (message (module ExtensionRange)), not_packed) ^:: repeated ((6, "extension", "extension"), (message (module FieldDescriptorProto)), not_packed) ^:: basic_opt ((7, "options", "options"), (message (module MessageOptions))) ^:: repeated ((8, "oneof_decl", "oneofDecl"), (message (module OneofDescriptorProto)), not_packed) ^:: repeated ((9, "reserved_range", "reservedRange"), (message (module ReservedRange)), not_packed) ^:: repeated ((10, "reserved_name", "reservedName"), string, not_packed) ^:: basic_opt ((11, "visibility", "visibility"), (enum (module SymbolVisibility))) ^:: nil )
      let to_proto' =
        let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
        fun writer { name; field; nested_type; enum_type; extension_range; extension; options; oneof_decl; reserved_range; reserved_name; visibility } -> serialize writer name field nested_type enum_type extension_range extension options oneof_decl reserved_range reserved_name visibility

      let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
      let from_proto_exn =
        let constructor name field nested_type enum_type extension_range extension options oneof_decl reserved_range reserved_name visibility = { name; field; nested_type; enum_type; extension_range; extension; options; oneof_decl; reserved_range; reserved_name; visibility } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
      let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
      let to_json options =
        let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
        fun { name; field; nested_type; enum_type; extension_range; extension; options; oneof_decl; reserved_range; reserved_name; visibility } -> serialize name field nested_type enum_type extension_range extension options oneof_decl reserved_range reserved_name visibility
      let from_json_exn =
        let constructor name field nested_type enum_type extension_range extension options oneof_decl reserved_range reserved_name visibility = { name; field; nested_type; enum_type; extension_range; extension; options; oneof_decl; reserved_range; reserved_name; visibility } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
      let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
    end

    and ExtensionRangeOptions : sig

      (**
{%html:
<p>The verification state of the extension range.</p>
%}
      *)
      module rec VerificationState : sig
        type t =
          | DECLARATION
          (**
{%html:
<p>All the extensions of the range must be declared.</p>
%}
          *)

          | UNVERIFIED

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      and Declaration : sig
        type t = {
          number:int option;
          (**
{%html:
<p>The extension number declared within the extension range.</p>
%}
          *)

          full_name:string option;
          (**
{%html:
<p>The fully-qualified name of the extension field. There must be a leading
dot in front of the full name.</p>
%}
          *)

          type':string option;
          (**
{%html:
<p>The fully-qualified type name of the extension field. Unlike
Metadata.type, Declaration.type must have a leading dot for messages
and enums.</p>
%}
          *)

          reserved:bool option;
          (**
{%html:
<p>If true, indicates that the number is reserved in the extension range,
and any extension field with the number will fail to compile. Set this
when a declared extension field is deleted.</p>
%}
          *)

          repeated:bool option;
          (**
{%html:
<p>If true, indicates that the extension must be defined as repeated.
Otherwise the extension must be defined as optional.</p>
%}
          *)

        }
        val make: ?number:int -> ?full_name:string -> ?type':string -> ?reserved:bool -> ?repeated:bool -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?number:int -> ?full_name:string -> ?type':string -> ?reserved:bool -> ?repeated:bool -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end

      type t = {
        declaration:Declaration.t list;
        (**
{%html:
<p>For external users: DO NOT USE. We are in the process of open sourcing
extension declaration and executing internal cleanups before it can be
used externally.</p>
%}
        *)

        verification:VerificationState.t;
        (**
{%html:
<p>The verification state of the range.
TODO: flip the default to DECLARATION once all empty ranges
are marked as UNVERIFIED.</p>
%}
        *)

        features:FeatureSet.t option;
        (**
{%html:
<p>Any features defined in the specific edition.</p>
%}
        *)

        uninterpreted_option:UninterpretedOption.t list;
        (**
{%html:
<p>The parser stores options it doesn't recognize here. See above.</p>
%}
        *)

        extensions':Runtime'.Extensions.t;
      }
      val make: ?declaration:Declaration.t list -> ?verification:VerificationState.t -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?declaration:Declaration.t list -> ?verification:VerificationState.t -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end = struct
      module This'_ = ExtensionRangeOptions
      module rec VerificationState : sig
        type t =
          | DECLARATION
          (**
{%html:
<p>All the extensions of the range must be declared.</p>
%}
          *)

          | UNVERIFIED

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end = struct
        module This'_ = VerificationState
        type t =
          | DECLARATION
          (**
{%html:
<p>All the extensions of the range must be declared.</p>
%}
          *)

          | UNVERIFIED

        let name () = ".google.protobuf.ExtensionRangeOptions.VerificationState"
        let to_int = function
          | DECLARATION -> 0
          | UNVERIFIED -> 1
        let from_int_exn = function
          | 0 -> DECLARATION
          | 1 -> UNVERIFIED
          | n -> Runtime'.Result.raise (`Unknown_enum_value n)
        let from_int e = Runtime'.Result.catch (fun () -> from_int_exn e)
        let to_string = function
          | DECLARATION -> "DECLARATION"
          | UNVERIFIED -> "UNVERIFIED"
        let from_string_exn = function
          | "DECLARATION" -> DECLARATION
          | "UNVERIFIED" -> UNVERIFIED
          | s -> Runtime'.Result.raise (`Unknown_enum_name s)

      end

      and Declaration : sig
        type t = {
          number:int option;
          (**
{%html:
<p>The extension number declared within the extension range.</p>
%}
          *)

          full_name:string option;
          (**
{%html:
<p>The fully-qualified name of the extension field. There must be a leading
dot in front of the full name.</p>
%}
          *)

          type':string option;
          (**
{%html:
<p>The fully-qualified type name of the extension field. Unlike
Metadata.type, Declaration.type must have a leading dot for messages
and enums.</p>
%}
          *)

          reserved:bool option;
          (**
{%html:
<p>If true, indicates that the number is reserved in the extension range,
and any extension field with the number will fail to compile. Set this
when a declared extension field is deleted.</p>
%}
          *)

          repeated:bool option;
          (**
{%html:
<p>If true, indicates that the extension must be defined as repeated.
Otherwise the extension must be defined as optional.</p>
%}
          *)

        }
        val make: ?number:int -> ?full_name:string -> ?type':string -> ?reserved:bool -> ?repeated:bool -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?number:int -> ?full_name:string -> ?type':string -> ?reserved:bool -> ?repeated:bool -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end = struct
        module This'_ = Declaration
        let name () = ".google.protobuf.ExtensionRangeOptions.Declaration"
        type t = {
          number:int option;
          full_name:string option;
          type':string option;
          reserved:bool option;
          repeated:bool option;
        }
        type make_t = ?number:int -> ?full_name:string -> ?type':string -> ?reserved:bool -> ?repeated:bool -> unit -> t
        let make ?number ?full_name ?type' ?reserved ?repeated () = { number; full_name; type'; reserved; repeated }
        let merge =
        let merge_number = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((1, "number", "number"), int32_int) ) in
        let merge_full_name = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((2, "full_name", "fullName"), string) ) in
        let merge_type' = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((3, "type", "type"), string) ) in
        let merge_reserved = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((5, "reserved", "reserved"), bool) ) in
        let merge_repeated = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((6, "repeated", "repeated"), bool) ) in
        fun t1 t2 -> {
        	number = (merge_number t1.number t2.number);
        	full_name = (merge_full_name t1.full_name t2.full_name);
        	type' = (merge_type' t1.type' t2.type');
        	reserved = (merge_reserved t1.reserved t2.reserved);
        	repeated = (merge_repeated t1.repeated t2.repeated);
         }
        let spec () = Runtime'.Spec.( basic_opt ((1, "number", "number"), int32_int) ^:: basic_opt ((2, "full_name", "fullName"), string) ^:: basic_opt ((3, "type", "type"), string) ^:: basic_opt ((5, "reserved", "reserved"), bool) ^:: basic_opt ((6, "repeated", "repeated"), bool) ^:: nil )
        let to_proto' =
          let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
          fun writer { number; full_name; type'; reserved; repeated } -> serialize writer number full_name type' reserved repeated

        let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
        let from_proto_exn =
          let constructor number full_name type' reserved repeated = { number; full_name; type'; reserved; repeated } in
          Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
        let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
        let to_json options =
          let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
          fun { number; full_name; type'; reserved; repeated } -> serialize number full_name type' reserved repeated
        let from_json_exn =
          let constructor number full_name type' reserved repeated = { number; full_name; type'; reserved; repeated } in
          Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
        let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
      end

      let name () = ".google.protobuf.ExtensionRangeOptions"
      type t = {
        declaration:Declaration.t list;
        verification:VerificationState.t;
        features:FeatureSet.t option;
        uninterpreted_option:UninterpretedOption.t list;
        extensions':Runtime'.Extensions.t;
      }
      type make_t = ?declaration:Declaration.t list -> ?verification:VerificationState.t -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      let make ?(declaration = []) ?(verification = VerificationState.UNVERIFIED) ?features ?(uninterpreted_option = []) ?(extensions' = Runtime'.Extensions.default) () = { declaration; verification; features; uninterpreted_option; extensions' }
      let merge =
      let merge_declaration = Runtime'.Merge.merge Runtime'.Spec.( repeated ((2, "declaration", "declaration"), (message (module Declaration)), not_packed) ) in
      let merge_verification = Runtime'.Merge.merge Runtime'.Spec.( basic ((3, "verification", "verification"), (enum (module VerificationState)), (VerificationState.UNVERIFIED)) ) in
      let merge_features = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((50, "features", "features"), (message (module FeatureSet))) ) in
      let merge_uninterpreted_option = Runtime'.Merge.merge Runtime'.Spec.( repeated ((999, "uninterpreted_option", "uninterpretedOption"), (message (module UninterpretedOption)), not_packed) ) in
      fun t1 t2 -> {
      	declaration = (merge_declaration t1.declaration t2.declaration);
      	verification = (merge_verification t1.verification t2.verification);
      	features = (merge_features t1.features t2.features);
      	uninterpreted_option = (merge_uninterpreted_option t1.uninterpreted_option t2.uninterpreted_option);
      	extensions' = (List.append t1.extensions' t2.extensions');
       }
      let spec () = Runtime'.Spec.( repeated ((2, "declaration", "declaration"), (message (module Declaration)), not_packed) ^:: basic ((3, "verification", "verification"), (enum (module VerificationState)), (VerificationState.UNVERIFIED)) ^:: basic_opt ((50, "features", "features"), (message (module FeatureSet))) ^:: repeated ((999, "uninterpreted_option", "uninterpretedOption"), (message (module UninterpretedOption)), not_packed) ^:: nil_ext [ (1000, 536870912) ] )
      let to_proto' =
        let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
        fun writer { declaration; verification; features; uninterpreted_option; extensions' } -> serialize writer declaration verification features uninterpreted_option extensions'

      let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
      let from_proto_exn =
        let constructor declaration verification features uninterpreted_option extensions' = { declaration; verification; features; uninterpreted_option; extensions' } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
      let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
      let to_json options =
        let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
        fun { declaration; verification; features; uninterpreted_option; extensions' } -> serialize declaration verification features uninterpreted_option extensions'
      let from_json_exn =
        let constructor declaration verification features uninterpreted_option extensions' = { declaration; verification; features; uninterpreted_option; extensions' } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
      let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
    end

    and FieldDescriptorProto : sig
      module rec Type : sig
        type t =
          | TYPE_DOUBLE
          (**
{%html:
<p>0 is reserved for errors.
Order is weird for historical reasons.</p>
%}
          *)

          | TYPE_FLOAT
          | TYPE_INT64
          (**
{%html:
<p>Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT64 if
negative values are likely.</p>
%}
          *)

          | TYPE_UINT64
          | TYPE_INT32
          (**
{%html:
<p>Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT32 if
negative values are likely.</p>
%}
          *)

          | TYPE_FIXED64
          | TYPE_FIXED32
          | TYPE_BOOL
          | TYPE_STRING
          | TYPE_GROUP
          (**
{%html:
<p>Tag-delimited aggregate.
Group type is deprecated and not supported after google.protobuf. However, Proto3
implementations should still be able to parse the group wire format and
treat group fields as unknown fields.  In Editions, the group wire format
can be enabled via the <code>message_encoding</code> feature.</p>
%}
          *)

          | TYPE_MESSAGE
          (**
{%html:
<p>Length-delimited aggregate.</p>
%}
          *)

          | TYPE_BYTES
          (**
{%html:
<p>New in version 2.</p>
%}
          *)

          | TYPE_UINT32
          | TYPE_ENUM
          | TYPE_SFIXED32
          | TYPE_SFIXED64
          | TYPE_SINT32
          (**
{%html:
<p>Uses ZigZag encoding.</p>
%}
          *)

          | TYPE_SINT64
          (**
{%html:
<p>Uses ZigZag encoding.</p>
%}
          *)


        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      and Label : sig
        type t =
          | LABEL_OPTIONAL
          (**
{%html:
<p>0 is reserved for errors</p>
%}
          *)

          | LABEL_REPEATED
          | LABEL_REQUIRED
          (**
{%html:
<p>The required label is only allowed in google.protobuf.  In proto3 and Editions
it's explicitly prohibited.  In Editions, the <code>field_presence</code> feature
can be used to get this behavior.</p>
%}
          *)


        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      type t = {
        name:string option;
        extendee:string option;
        (**
{%html:
<p>For extensions, this is the name of the type being extended.  It is
resolved in the same manner as type_name.</p>
%}
        *)

        number:int option;
        label:Label.t option;
        type':Type.t option;
        (**
{%html:
<p>If type_name is set, this need not be set.  If both this and type_name
are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.</p>
%}
        *)

        type_name:string option;
        (**
{%html:
<p>For message and enum types, this is the name of the type.  If the name
starts with a '.', it is fully-qualified.  Otherwise, C++-like scoping
rules are used to find the type (i.e. first the nested types within this
message are searched, then within the parent, on up to the root
namespace).</p>
%}
        *)

        default_value:string option;
        (**
{%html:
<p>For numeric types, contains the original text representation of the value.
For booleans, &quot;true&quot; or &quot;false&quot;.
For strings, contains the default text contents (not escaped in any way).
For bytes, contains the C escaped value.  All bytes &gt;= 128 are escaped.</p>
%}
        *)

        options:FieldOptions.t option;
        oneof_index:int option;
        (**
{%html:
<p>If set, gives the index of a oneof in the containing type's oneof_decl
list.  This field is a member of that oneof.</p>
%}
        *)

        json_name:string option;
        (**
{%html:
<p>JSON name of this field. The value is set by protocol compiler. If the
user has set a &quot;json_name&quot; option on this field, that option's value
will be used. Otherwise, it's deduced from the field's name by converting
it to camelCase.</p>
%}
        *)

        proto3_optional:bool option;
        (**
{%html:
<p>If true, this is a proto3 &quot;optional&quot;. When a proto3 field is optional, it
tracks presence regardless of field type.</p>
<p>When proto3_optional is true, this field must belong to a oneof to signal
to old proto3 clients that presence is tracked for this field. This oneof
is known as a &quot;synthetic&quot; oneof, and this field must be its sole member
(each proto3 optional field gets its own synthetic oneof). Synthetic oneofs
exist in the descriptor only, and do not generate any API. Synthetic oneofs
must be ordered after all &quot;real&quot; oneofs.</p>
<p>For message fields, proto3_optional doesn't create any semantic change,
since non-repeated message fields always track presence. However it still
indicates the semantic detail of whether the user wrote &quot;optional&quot; or not.
This can be useful for round-tripping the .proto file. For consistency we
give message fields a synthetic oneof also, even though it is not required
to track presence. This is especially important because the parser can't
tell if a field is a message or an enum, so it must always create a
synthetic oneof.</p>
<p>Proto2 optional fields do not set this flag, because they already indicate
optional with <code>LABEL_OPTIONAL</code>.</p>
%}
        *)

      }
      val make: ?name:string -> ?extendee:string -> ?number:int -> ?label:Label.t -> ?type':Type.t -> ?type_name:string -> ?default_value:string -> ?options:FieldOptions.t -> ?oneof_index:int -> ?json_name:string -> ?proto3_optional:bool -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?name:string -> ?extendee:string -> ?number:int -> ?label:Label.t -> ?type':Type.t -> ?type_name:string -> ?default_value:string -> ?options:FieldOptions.t -> ?oneof_index:int -> ?json_name:string -> ?proto3_optional:bool -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end = struct
      module This'_ = FieldDescriptorProto
      module rec Type : sig
        type t =
          | TYPE_DOUBLE
          (**
{%html:
<p>0 is reserved for errors.
Order is weird for historical reasons.</p>
%}
          *)

          | TYPE_FLOAT
          | TYPE_INT64
          (**
{%html:
<p>Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT64 if
negative values are likely.</p>
%}
          *)

          | TYPE_UINT64
          | TYPE_INT32
          (**
{%html:
<p>Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT32 if
negative values are likely.</p>
%}
          *)

          | TYPE_FIXED64
          | TYPE_FIXED32
          | TYPE_BOOL
          | TYPE_STRING
          | TYPE_GROUP
          (**
{%html:
<p>Tag-delimited aggregate.
Group type is deprecated and not supported after google.protobuf. However, Proto3
implementations should still be able to parse the group wire format and
treat group fields as unknown fields.  In Editions, the group wire format
can be enabled via the <code>message_encoding</code> feature.</p>
%}
          *)

          | TYPE_MESSAGE
          (**
{%html:
<p>Length-delimited aggregate.</p>
%}
          *)

          | TYPE_BYTES
          (**
{%html:
<p>New in version 2.</p>
%}
          *)

          | TYPE_UINT32
          | TYPE_ENUM
          | TYPE_SFIXED32
          | TYPE_SFIXED64
          | TYPE_SINT32
          (**
{%html:
<p>Uses ZigZag encoding.</p>
%}
          *)

          | TYPE_SINT64
          (**
{%html:
<p>Uses ZigZag encoding.</p>
%}
          *)


        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end = struct
        module This'_ = Type
        type t =
          | TYPE_DOUBLE
          (**
{%html:
<p>0 is reserved for errors.
Order is weird for historical reasons.</p>
%}
          *)

          | TYPE_FLOAT
          | TYPE_INT64
          (**
{%html:
<p>Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT64 if
negative values are likely.</p>
%}
          *)

          | TYPE_UINT64
          | TYPE_INT32
          (**
{%html:
<p>Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT32 if
negative values are likely.</p>
%}
          *)

          | TYPE_FIXED64
          | TYPE_FIXED32
          | TYPE_BOOL
          | TYPE_STRING
          | TYPE_GROUP
          (**
{%html:
<p>Tag-delimited aggregate.
Group type is deprecated and not supported after google.protobuf. However, Proto3
implementations should still be able to parse the group wire format and
treat group fields as unknown fields.  In Editions, the group wire format
can be enabled via the <code>message_encoding</code> feature.</p>
%}
          *)

          | TYPE_MESSAGE
          (**
{%html:
<p>Length-delimited aggregate.</p>
%}
          *)

          | TYPE_BYTES
          (**
{%html:
<p>New in version 2.</p>
%}
          *)

          | TYPE_UINT32
          | TYPE_ENUM
          | TYPE_SFIXED32
          | TYPE_SFIXED64
          | TYPE_SINT32
          (**
{%html:
<p>Uses ZigZag encoding.</p>
%}
          *)

          | TYPE_SINT64
          (**
{%html:
<p>Uses ZigZag encoding.</p>
%}
          *)


        let name () = ".google.protobuf.FieldDescriptorProto.Type"
        let to_int = function
          | TYPE_DOUBLE -> 1
          | TYPE_FLOAT -> 2
          | TYPE_INT64 -> 3
          | TYPE_UINT64 -> 4
          | TYPE_INT32 -> 5
          | TYPE_FIXED64 -> 6
          | TYPE_FIXED32 -> 7
          | TYPE_BOOL -> 8
          | TYPE_STRING -> 9
          | TYPE_GROUP -> 10
          | TYPE_MESSAGE -> 11
          | TYPE_BYTES -> 12
          | TYPE_UINT32 -> 13
          | TYPE_ENUM -> 14
          | TYPE_SFIXED32 -> 15
          | TYPE_SFIXED64 -> 16
          | TYPE_SINT32 -> 17
          | TYPE_SINT64 -> 18
        let from_int_exn = function
          | 1 -> TYPE_DOUBLE
          | 2 -> TYPE_FLOAT
          | 3 -> TYPE_INT64
          | 4 -> TYPE_UINT64
          | 5 -> TYPE_INT32
          | 6 -> TYPE_FIXED64
          | 7 -> TYPE_FIXED32
          | 8 -> TYPE_BOOL
          | 9 -> TYPE_STRING
          | 10 -> TYPE_GROUP
          | 11 -> TYPE_MESSAGE
          | 12 -> TYPE_BYTES
          | 13 -> TYPE_UINT32
          | 14 -> TYPE_ENUM
          | 15 -> TYPE_SFIXED32
          | 16 -> TYPE_SFIXED64
          | 17 -> TYPE_SINT32
          | 18 -> TYPE_SINT64
          | n -> Runtime'.Result.raise (`Unknown_enum_value n)
        let from_int e = Runtime'.Result.catch (fun () -> from_int_exn e)
        let to_string = function
          | TYPE_DOUBLE -> "TYPE_DOUBLE"
          | TYPE_FLOAT -> "TYPE_FLOAT"
          | TYPE_INT64 -> "TYPE_INT64"
          | TYPE_UINT64 -> "TYPE_UINT64"
          | TYPE_INT32 -> "TYPE_INT32"
          | TYPE_FIXED64 -> "TYPE_FIXED64"
          | TYPE_FIXED32 -> "TYPE_FIXED32"
          | TYPE_BOOL -> "TYPE_BOOL"
          | TYPE_STRING -> "TYPE_STRING"
          | TYPE_GROUP -> "TYPE_GROUP"
          | TYPE_MESSAGE -> "TYPE_MESSAGE"
          | TYPE_BYTES -> "TYPE_BYTES"
          | TYPE_UINT32 -> "TYPE_UINT32"
          | TYPE_ENUM -> "TYPE_ENUM"
          | TYPE_SFIXED32 -> "TYPE_SFIXED32"
          | TYPE_SFIXED64 -> "TYPE_SFIXED64"
          | TYPE_SINT32 -> "TYPE_SINT32"
          | TYPE_SINT64 -> "TYPE_SINT64"
        let from_string_exn = function
          | "TYPE_DOUBLE" -> TYPE_DOUBLE
          | "TYPE_FLOAT" -> TYPE_FLOAT
          | "TYPE_INT64" -> TYPE_INT64
          | "TYPE_UINT64" -> TYPE_UINT64
          | "TYPE_INT32" -> TYPE_INT32
          | "TYPE_FIXED64" -> TYPE_FIXED64
          | "TYPE_FIXED32" -> TYPE_FIXED32
          | "TYPE_BOOL" -> TYPE_BOOL
          | "TYPE_STRING" -> TYPE_STRING
          | "TYPE_GROUP" -> TYPE_GROUP
          | "TYPE_MESSAGE" -> TYPE_MESSAGE
          | "TYPE_BYTES" -> TYPE_BYTES
          | "TYPE_UINT32" -> TYPE_UINT32
          | "TYPE_ENUM" -> TYPE_ENUM
          | "TYPE_SFIXED32" -> TYPE_SFIXED32
          | "TYPE_SFIXED64" -> TYPE_SFIXED64
          | "TYPE_SINT32" -> TYPE_SINT32
          | "TYPE_SINT64" -> TYPE_SINT64
          | s -> Runtime'.Result.raise (`Unknown_enum_name s)

      end

      and Label : sig
        type t =
          | LABEL_OPTIONAL
          (**
{%html:
<p>0 is reserved for errors</p>
%}
          *)

          | LABEL_REPEATED
          | LABEL_REQUIRED
          (**
{%html:
<p>The required label is only allowed in google.protobuf.  In proto3 and Editions
it's explicitly prohibited.  In Editions, the <code>field_presence</code> feature
can be used to get this behavior.</p>
%}
          *)


        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end = struct
        module This'_ = Label
        type t =
          | LABEL_OPTIONAL
          (**
{%html:
<p>0 is reserved for errors</p>
%}
          *)

          | LABEL_REPEATED
          | LABEL_REQUIRED
          (**
{%html:
<p>The required label is only allowed in google.protobuf.  In proto3 and Editions
it's explicitly prohibited.  In Editions, the <code>field_presence</code> feature
can be used to get this behavior.</p>
%}
          *)


        let name () = ".google.protobuf.FieldDescriptorProto.Label"
        let to_int = function
          | LABEL_OPTIONAL -> 1
          | LABEL_REPEATED -> 3
          | LABEL_REQUIRED -> 2
        let from_int_exn = function
          | 1 -> LABEL_OPTIONAL
          | 3 -> LABEL_REPEATED
          | 2 -> LABEL_REQUIRED
          | n -> Runtime'.Result.raise (`Unknown_enum_value n)
        let from_int e = Runtime'.Result.catch (fun () -> from_int_exn e)
        let to_string = function
          | LABEL_OPTIONAL -> "LABEL_OPTIONAL"
          | LABEL_REPEATED -> "LABEL_REPEATED"
          | LABEL_REQUIRED -> "LABEL_REQUIRED"
        let from_string_exn = function
          | "LABEL_OPTIONAL" -> LABEL_OPTIONAL
          | "LABEL_REPEATED" -> LABEL_REPEATED
          | "LABEL_REQUIRED" -> LABEL_REQUIRED
          | s -> Runtime'.Result.raise (`Unknown_enum_name s)

      end

      let name () = ".google.protobuf.FieldDescriptorProto"
      type t = {
        name:string option;
        extendee:string option;
        number:int option;
        label:Label.t option;
        type':Type.t option;
        type_name:string option;
        default_value:string option;
        options:FieldOptions.t option;
        oneof_index:int option;
        json_name:string option;
        proto3_optional:bool option;
      }
      type make_t = ?name:string -> ?extendee:string -> ?number:int -> ?label:Label.t -> ?type':Type.t -> ?type_name:string -> ?default_value:string -> ?options:FieldOptions.t -> ?oneof_index:int -> ?json_name:string -> ?proto3_optional:bool -> unit -> t
      let make ?name ?extendee ?number ?label ?type' ?type_name ?default_value ?options ?oneof_index ?json_name ?proto3_optional () = { name; extendee; number; label; type'; type_name; default_value; options; oneof_index; json_name; proto3_optional }
      let merge =
      let merge_name = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((1, "name", "name"), string) ) in
      let merge_extendee = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((2, "extendee", "extendee"), string) ) in
      let merge_number = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((3, "number", "number"), int32_int) ) in
      let merge_label = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((4, "label", "label"), (enum (module Label))) ) in
      let merge_type' = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((5, "type", "type"), (enum (module Type))) ) in
      let merge_type_name = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((6, "type_name", "typeName"), string) ) in
      let merge_default_value = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((7, "default_value", "defaultValue"), string) ) in
      let merge_options = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((8, "options", "options"), (message (module FieldOptions))) ) in
      let merge_oneof_index = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((9, "oneof_index", "oneofIndex"), int32_int) ) in
      let merge_json_name = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((10, "json_name", "jsonName"), string) ) in
      let merge_proto3_optional = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((17, "proto3_optional", "proto3Optional"), bool) ) in
      fun t1 t2 -> {
      	name = (merge_name t1.name t2.name);
      	extendee = (merge_extendee t1.extendee t2.extendee);
      	number = (merge_number t1.number t2.number);
      	label = (merge_label t1.label t2.label);
      	type' = (merge_type' t1.type' t2.type');
      	type_name = (merge_type_name t1.type_name t2.type_name);
      	default_value = (merge_default_value t1.default_value t2.default_value);
      	options = (merge_options t1.options t2.options);
      	oneof_index = (merge_oneof_index t1.oneof_index t2.oneof_index);
      	json_name = (merge_json_name t1.json_name t2.json_name);
      	proto3_optional = (merge_proto3_optional t1.proto3_optional t2.proto3_optional);
       }
      let spec () = Runtime'.Spec.( basic_opt ((1, "name", "name"), string) ^:: basic_opt ((2, "extendee", "extendee"), string) ^:: basic_opt ((3, "number", "number"), int32_int) ^:: basic_opt ((4, "label", "label"), (enum (module Label))) ^:: basic_opt ((5, "type", "type"), (enum (module Type))) ^:: basic_opt ((6, "type_name", "typeName"), string) ^:: basic_opt ((7, "default_value", "defaultValue"), string) ^:: basic_opt ((8, "options", "options"), (message (module FieldOptions))) ^:: basic_opt ((9, "oneof_index", "oneofIndex"), int32_int) ^:: basic_opt ((10, "json_name", "jsonName"), string) ^:: basic_opt ((17, "proto3_optional", "proto3Optional"), bool) ^:: nil )
      let to_proto' =
        let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
        fun writer { name; extendee; number; label; type'; type_name; default_value; options; oneof_index; json_name; proto3_optional } -> serialize writer name extendee number label type' type_name default_value options oneof_index json_name proto3_optional

      let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
      let from_proto_exn =
        let constructor name extendee number label type' type_name default_value options oneof_index json_name proto3_optional = { name; extendee; number; label; type'; type_name; default_value; options; oneof_index; json_name; proto3_optional } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
      let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
      let to_json options =
        let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
        fun { name; extendee; number; label; type'; type_name; default_value; options; oneof_index; json_name; proto3_optional } -> serialize name extendee number label type' type_name default_value options oneof_index json_name proto3_optional
      let from_json_exn =
        let constructor name extendee number label type' type_name default_value options oneof_index json_name proto3_optional = { name; extendee; number; label; type'; type_name; default_value; options; oneof_index; json_name; proto3_optional } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
      let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
    end

    and OneofDescriptorProto : sig
      type t = {
        name:string option;
        options:OneofOptions.t option;
      }
      val make: ?name:string -> ?options:OneofOptions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?name:string -> ?options:OneofOptions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end = struct
      module This'_ = OneofDescriptorProto
      let name () = ".google.protobuf.OneofDescriptorProto"
      type t = {
        name:string option;
        options:OneofOptions.t option;
      }
      type make_t = ?name:string -> ?options:OneofOptions.t -> unit -> t
      let make ?name ?options () = { name; options }
      let merge =
      let merge_name = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((1, "name", "name"), string) ) in
      let merge_options = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((2, "options", "options"), (message (module OneofOptions))) ) in
      fun t1 t2 -> {
      	name = (merge_name t1.name t2.name);
      	options = (merge_options t1.options t2.options);
       }
      let spec () = Runtime'.Spec.( basic_opt ((1, "name", "name"), string) ^:: basic_opt ((2, "options", "options"), (message (module OneofOptions))) ^:: nil )
      let to_proto' =
        let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
        fun writer { name; options } -> serialize writer name options

      let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
      let from_proto_exn =
        let constructor name options = { name; options } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
      let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
      let to_json options =
        let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
        fun { name; options } -> serialize name options
      let from_json_exn =
        let constructor name options = { name; options } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
      let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
    end

    and EnumDescriptorProto : sig

      (**
{%html:
<p>Range of reserved numeric values. Reserved values may not be used by
entries in the same enum. Reserved ranges may not overlap.</p>
<p>Note that this is distinct from DescriptorProto.ReservedRange in that it
is inclusive such that it can appropriately represent the entire int32
domain.</p>
%}
      *)
      module rec EnumReservedRange : sig
        type t = {
          start:int option;
          (**
{%html:
<p>Inclusive.</p>
%}
          *)

          end':int option;
          (**
{%html:
<p>Inclusive.</p>
%}
          *)

        }
        val make: ?start:int -> ?end':int -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?start:int -> ?end':int -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end

      type t = {
        name:string option;
        value:EnumValueDescriptorProto.t list;
        options:EnumOptions.t option;
        reserved_range:EnumReservedRange.t list;
        (**
{%html:
<p>Range of reserved numeric values. Reserved numeric values may not be used
by enum values in the same enum declaration. Reserved ranges may not
overlap.</p>
%}
        *)

        reserved_name:string list;
        (**
{%html:
<p>Reserved enum value names, which may not be reused. A given name may only
be reserved once.</p>
%}
        *)

        visibility:SymbolVisibility.t option;
        (**
{%html:
<p>Support for <code>export</code> and <code>local</code> keywords on enums.</p>
%}
        *)

      }
      val make: ?name:string -> ?value:EnumValueDescriptorProto.t list -> ?options:EnumOptions.t -> ?reserved_range:EnumReservedRange.t list -> ?reserved_name:string list -> ?visibility:SymbolVisibility.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?name:string -> ?value:EnumValueDescriptorProto.t list -> ?options:EnumOptions.t -> ?reserved_range:EnumReservedRange.t list -> ?reserved_name:string list -> ?visibility:SymbolVisibility.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end = struct
      module This'_ = EnumDescriptorProto
      module rec EnumReservedRange : sig
        type t = {
          start:int option;
          (**
{%html:
<p>Inclusive.</p>
%}
          *)

          end':int option;
          (**
{%html:
<p>Inclusive.</p>
%}
          *)

        }
        val make: ?start:int -> ?end':int -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?start:int -> ?end':int -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end = struct
        module This'_ = EnumReservedRange
        let name () = ".google.protobuf.EnumDescriptorProto.EnumReservedRange"
        type t = {
          start:int option;
          end':int option;
        }
        type make_t = ?start:int -> ?end':int -> unit -> t
        let make ?start ?end' () = { start; end' }
        let merge =
        let merge_start = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((1, "start", "start"), int32_int) ) in
        let merge_end' = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((2, "end", "end"), int32_int) ) in
        fun t1 t2 -> {
        	start = (merge_start t1.start t2.start);
        	end' = (merge_end' t1.end' t2.end');
         }
        let spec () = Runtime'.Spec.( basic_opt ((1, "start", "start"), int32_int) ^:: basic_opt ((2, "end", "end"), int32_int) ^:: nil )
        let to_proto' =
          let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
          fun writer { start; end' } -> serialize writer start end'

        let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
        let from_proto_exn =
          let constructor start end' = { start; end' } in
          Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
        let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
        let to_json options =
          let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
          fun { start; end' } -> serialize start end'
        let from_json_exn =
          let constructor start end' = { start; end' } in
          Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
        let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
      end

      let name () = ".google.protobuf.EnumDescriptorProto"
      type t = {
        name:string option;
        value:EnumValueDescriptorProto.t list;
        options:EnumOptions.t option;
        reserved_range:EnumReservedRange.t list;
        reserved_name:string list;
        visibility:SymbolVisibility.t option;
      }
      type make_t = ?name:string -> ?value:EnumValueDescriptorProto.t list -> ?options:EnumOptions.t -> ?reserved_range:EnumReservedRange.t list -> ?reserved_name:string list -> ?visibility:SymbolVisibility.t -> unit -> t
      let make ?name ?(value = []) ?options ?(reserved_range = []) ?(reserved_name = []) ?visibility () = { name; value; options; reserved_range; reserved_name; visibility }
      let merge =
      let merge_name = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((1, "name", "name"), string) ) in
      let merge_value = Runtime'.Merge.merge Runtime'.Spec.( repeated ((2, "value", "value"), (message (module EnumValueDescriptorProto)), not_packed) ) in
      let merge_options = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((3, "options", "options"), (message (module EnumOptions))) ) in
      let merge_reserved_range = Runtime'.Merge.merge Runtime'.Spec.( repeated ((4, "reserved_range", "reservedRange"), (message (module EnumReservedRange)), not_packed) ) in
      let merge_reserved_name = Runtime'.Merge.merge Runtime'.Spec.( repeated ((5, "reserved_name", "reservedName"), string, not_packed) ) in
      let merge_visibility = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((6, "visibility", "visibility"), (enum (module SymbolVisibility))) ) in
      fun t1 t2 -> {
      	name = (merge_name t1.name t2.name);
      	value = (merge_value t1.value t2.value);
      	options = (merge_options t1.options t2.options);
      	reserved_range = (merge_reserved_range t1.reserved_range t2.reserved_range);
      	reserved_name = (merge_reserved_name t1.reserved_name t2.reserved_name);
      	visibility = (merge_visibility t1.visibility t2.visibility);
       }
      let spec () = Runtime'.Spec.( basic_opt ((1, "name", "name"), string) ^:: repeated ((2, "value", "value"), (message (module EnumValueDescriptorProto)), not_packed) ^:: basic_opt ((3, "options", "options"), (message (module EnumOptions))) ^:: repeated ((4, "reserved_range", "reservedRange"), (message (module EnumReservedRange)), not_packed) ^:: repeated ((5, "reserved_name", "reservedName"), string, not_packed) ^:: basic_opt ((6, "visibility", "visibility"), (enum (module SymbolVisibility))) ^:: nil )
      let to_proto' =
        let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
        fun writer { name; value; options; reserved_range; reserved_name; visibility } -> serialize writer name value options reserved_range reserved_name visibility

      let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
      let from_proto_exn =
        let constructor name value options reserved_range reserved_name visibility = { name; value; options; reserved_range; reserved_name; visibility } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
      let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
      let to_json options =
        let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
        fun { name; value; options; reserved_range; reserved_name; visibility } -> serialize name value options reserved_range reserved_name visibility
      let from_json_exn =
        let constructor name value options reserved_range reserved_name visibility = { name; value; options; reserved_range; reserved_name; visibility } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
      let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
    end

    and EnumValueDescriptorProto : sig
      type t = {
        name:string option;
        number:int option;
        options:EnumValueOptions.t option;
      }
      val make: ?name:string -> ?number:int -> ?options:EnumValueOptions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?name:string -> ?number:int -> ?options:EnumValueOptions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end = struct
      module This'_ = EnumValueDescriptorProto
      let name () = ".google.protobuf.EnumValueDescriptorProto"
      type t = {
        name:string option;
        number:int option;
        options:EnumValueOptions.t option;
      }
      type make_t = ?name:string -> ?number:int -> ?options:EnumValueOptions.t -> unit -> t
      let make ?name ?number ?options () = { name; number; options }
      let merge =
      let merge_name = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((1, "name", "name"), string) ) in
      let merge_number = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((2, "number", "number"), int32_int) ) in
      let merge_options = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((3, "options", "options"), (message (module EnumValueOptions))) ) in
      fun t1 t2 -> {
      	name = (merge_name t1.name t2.name);
      	number = (merge_number t1.number t2.number);
      	options = (merge_options t1.options t2.options);
       }
      let spec () = Runtime'.Spec.( basic_opt ((1, "name", "name"), string) ^:: basic_opt ((2, "number", "number"), int32_int) ^:: basic_opt ((3, "options", "options"), (message (module EnumValueOptions))) ^:: nil )
      let to_proto' =
        let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
        fun writer { name; number; options } -> serialize writer name number options

      let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
      let from_proto_exn =
        let constructor name number options = { name; number; options } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
      let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
      let to_json options =
        let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
        fun { name; number; options } -> serialize name number options
      let from_json_exn =
        let constructor name number options = { name; number; options } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
      let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
    end

    and ServiceDescriptorProto : sig
      type t = {
        name:string option;
        method':MethodDescriptorProto.t list;
        options:ServiceOptions.t option;
      }
      val make: ?name:string -> ?method':MethodDescriptorProto.t list -> ?options:ServiceOptions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?name:string -> ?method':MethodDescriptorProto.t list -> ?options:ServiceOptions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end = struct
      module This'_ = ServiceDescriptorProto
      let name () = ".google.protobuf.ServiceDescriptorProto"
      type t = {
        name:string option;
        method':MethodDescriptorProto.t list;
        options:ServiceOptions.t option;
      }
      type make_t = ?name:string -> ?method':MethodDescriptorProto.t list -> ?options:ServiceOptions.t -> unit -> t
      let make ?name ?(method' = []) ?options () = { name; method'; options }
      let merge =
      let merge_name = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((1, "name", "name"), string) ) in
      let merge_method' = Runtime'.Merge.merge Runtime'.Spec.( repeated ((2, "method", "method"), (message (module MethodDescriptorProto)), not_packed) ) in
      let merge_options = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((3, "options", "options"), (message (module ServiceOptions))) ) in
      fun t1 t2 -> {
      	name = (merge_name t1.name t2.name);
      	method' = (merge_method' t1.method' t2.method');
      	options = (merge_options t1.options t2.options);
       }
      let spec () = Runtime'.Spec.( basic_opt ((1, "name", "name"), string) ^:: repeated ((2, "method", "method"), (message (module MethodDescriptorProto)), not_packed) ^:: basic_opt ((3, "options", "options"), (message (module ServiceOptions))) ^:: nil )
      let to_proto' =
        let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
        fun writer { name; method'; options } -> serialize writer name method' options

      let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
      let from_proto_exn =
        let constructor name method' options = { name; method'; options } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
      let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
      let to_json options =
        let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
        fun { name; method'; options } -> serialize name method' options
      let from_json_exn =
        let constructor name method' options = { name; method'; options } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
      let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
    end

    and MethodDescriptorProto : sig
      type t = {
        name:string option;
        input_type:string option;
        (**
{%html:
<p>Input and output type names.  These are resolved in the same way as
FieldDescriptorProto.type_name, but must refer to a message type.</p>
%}
        *)

        output_type:string option;
        options:MethodOptions.t option;
        client_streaming:bool;
        (**
{%html:
<p>Identifies if client streams multiple client messages</p>
%}
        *)

        server_streaming:bool;
        (**
{%html:
<p>Identifies if server streams multiple server messages</p>
%}
        *)

      }
      val make: ?name:string -> ?input_type:string -> ?output_type:string -> ?options:MethodOptions.t -> ?client_streaming:bool -> ?server_streaming:bool -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?name:string -> ?input_type:string -> ?output_type:string -> ?options:MethodOptions.t -> ?client_streaming:bool -> ?server_streaming:bool -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end = struct
      module This'_ = MethodDescriptorProto
      let name () = ".google.protobuf.MethodDescriptorProto"
      type t = {
        name:string option;
        input_type:string option;
        output_type:string option;
        options:MethodOptions.t option;
        client_streaming:bool;
        server_streaming:bool;
      }
      type make_t = ?name:string -> ?input_type:string -> ?output_type:string -> ?options:MethodOptions.t -> ?client_streaming:bool -> ?server_streaming:bool -> unit -> t
      let make ?name ?input_type ?output_type ?options ?(client_streaming = false) ?(server_streaming = false) () = { name; input_type; output_type; options; client_streaming; server_streaming }
      let merge =
      let merge_name = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((1, "name", "name"), string) ) in
      let merge_input_type = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((2, "input_type", "inputType"), string) ) in
      let merge_output_type = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((3, "output_type", "outputType"), string) ) in
      let merge_options = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((4, "options", "options"), (message (module MethodOptions))) ) in
      let merge_client_streaming = Runtime'.Merge.merge Runtime'.Spec.( basic ((5, "client_streaming", "clientStreaming"), bool, (false)) ) in
      let merge_server_streaming = Runtime'.Merge.merge Runtime'.Spec.( basic ((6, "server_streaming", "serverStreaming"), bool, (false)) ) in
      fun t1 t2 -> {
      	name = (merge_name t1.name t2.name);
      	input_type = (merge_input_type t1.input_type t2.input_type);
      	output_type = (merge_output_type t1.output_type t2.output_type);
      	options = (merge_options t1.options t2.options);
      	client_streaming = (merge_client_streaming t1.client_streaming t2.client_streaming);
      	server_streaming = (merge_server_streaming t1.server_streaming t2.server_streaming);
       }
      let spec () = Runtime'.Spec.( basic_opt ((1, "name", "name"), string) ^:: basic_opt ((2, "input_type", "inputType"), string) ^:: basic_opt ((3, "output_type", "outputType"), string) ^:: basic_opt ((4, "options", "options"), (message (module MethodOptions))) ^:: basic ((5, "client_streaming", "clientStreaming"), bool, (false)) ^:: basic ((6, "server_streaming", "serverStreaming"), bool, (false)) ^:: nil )
      let to_proto' =
        let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
        fun writer { name; input_type; output_type; options; client_streaming; server_streaming } -> serialize writer name input_type output_type options client_streaming server_streaming

      let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
      let from_proto_exn =
        let constructor name input_type output_type options client_streaming server_streaming = { name; input_type; output_type; options; client_streaming; server_streaming } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
      let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
      let to_json options =
        let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
        fun { name; input_type; output_type; options; client_streaming; server_streaming } -> serialize name input_type output_type options client_streaming server_streaming
      let from_json_exn =
        let constructor name input_type output_type options client_streaming server_streaming = { name; input_type; output_type; options; client_streaming; server_streaming } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
      let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
    end

    and FileOptions : sig

      (**
{%html:
<p>Generated classes can be optimized for speed or code size.</p>
%}
      *)
      module rec OptimizeMode : sig
        type t =
          | SPEED
          (**
{%html:
<p>Generate complete code for parsing, serialization,</p>
%}
          *)

          | CODE_SIZE
          (**
{%html:
<p>etc.</p>
<p>Use ReflectionOps to implement these methods.</p>
%}
          *)

          | LITE_RUNTIME
          (**
{%html:
<p>Generate code using MessageLite and the lite runtime.</p>
%}
          *)


        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      type t = {
        java_package:string option;
        (**
{%html:
<p>Sets the Java package where classes generated from this .proto will be
placed.  By default, the proto package is used, but this is often
inappropriate because proto packages do not normally start with backwards
domain names.</p>
%}
        *)

        java_outer_classname:string option;
        (**
{%html:
<p>Controls the name of the wrapper Java class generated for the .proto file.
That class will always contain the .proto file's getDescriptor() method as
well as any top-level extensions defined in the .proto file.
If java_multiple_files is disabled, then all the other classes from the
.proto file will be nested inside the single wrapper outer class.</p>
%}
        *)

        optimize_for:OptimizeMode.t;
        (**
{%html:
<p>Clients can define custom options in extensions of this message.
See the documentation for the &quot;Options&quot; section above.</p>
%}
        *)

        java_multiple_files:bool;
        (**
{%html:
<p>If enabled, then the Java code generator will generate a separate .java
file for each top-level message, enum, and service defined in the .proto
file.  Thus, these types will <em>not</em> be nested inside the wrapper class
named by java_outer_classname.  However, the wrapper class will still be
generated to contain the file's getDescriptor() method as well as any
top-level extensions defined in the file.</p>
%}
        *)

        go_package:string option;
        (**
{%html:
<p>Sets the Go package where structs generated from this .proto will be
placed. If omitted, the Go package will be derived from the following:</p>
<ul>
<li>The basename of the package import path, if provided.
</li>
<li>Otherwise, the package statement in the .proto file, if present.
</li>
<li>Otherwise, the basename of the .proto file, without extension.
</li>
</ul>
%}
        *)

        cc_generic_services:bool;
        (**
{%html:
<p>Should generic services be generated in each language?  &quot;Generic&quot; services
are not specific to any particular RPC system.  They are generated by the
main code generators in each language (without additional plugins).
Generic services were the only kind of service generation supported by
early versions of google.protobuf.</p>
<p>Generic services are now considered deprecated in favor of using plugins
that generate code specific to your particular RPC system.  Therefore,
these default to false.  Old code which depends on generic services should
explicitly set them to true.</p>
%}
        *)

        java_generic_services:bool;
        py_generic_services:bool;
        (**
{%html:
<p>removed php_generic_services</p>
%}
        *)

        java_generate_equals_and_hash:bool option[@ocaml.alert protobuf "Marked as deprecated in the .proto file"];
        (**
{%html:
<p>This option does nothing.</p>
%}
        *)

        deprecated:bool;
        (**
{%html:
<p>Is this file deprecated?
Depending on the target platform, this can emit Deprecated annotations
for everything in the file, or it will be completely ignored; in the very
least, this is a formalization for deprecating files.</p>
%}
        *)

        java_string_check_utf8:bool;
        (**
{%html:
<p>A proto2 file can set this to true to opt in to UTF-8 checking for Java,
which will throw an exception if invalid UTF-8 is parsed from the wire or
assigned to a string field.</p>
<p>TODO: clarify exactly what kinds of field types this option
applies to, and update these docs accordingly.</p>
<p>Proto3 files already perform these checks. Setting the option explicitly to
false has no effect: it cannot be used to opt proto3 files out of UTF-8
checks.</p>
%}
        *)

        cc_enable_arenas:bool;
        (**
{%html:
<p>Enables the use of arenas for the proto messages in this file. This applies
only to generated classes for C++.</p>
%}
        *)

        objc_class_prefix:string option;
        (**
{%html:
<p>Sets the objective c class prefix which is prepended to all objective c
generated classes from this .proto. There is no default.</p>
%}
        *)

        csharp_namespace:string option;
        (**
{%html:
<p>Namespace for generated classes; defaults to the package.</p>
%}
        *)

        swift_prefix:string option;
        (**
{%html:
<p>By default Swift generators will take the proto package and CamelCase it
replacing '.' with underscore and use that to prefix the types/symbols
defined. When this options is provided, they will use this value instead
to prefix the types/symbols defined.</p>
%}
        *)

        php_class_prefix:string option;
        (**
{%html:
<p>Sets the php class prefix which is prepended to all php generated classes
from this .proto. Default is empty.</p>
%}
        *)

        php_namespace:string option;
        (**
{%html:
<p>Use this option to change the namespace of php generated classes. Default
is empty. When this option is empty, the package name will be used for
determining the namespace.</p>
%}
        *)

        php_metadata_namespace:string option;
        (**
{%html:
<p>Use this option to change the namespace of php generated metadata classes.
Default is empty. When this option is empty, the proto file name will be
used for determining the namespace.</p>
%}
        *)

        ruby_package:string option;
        (**
{%html:
<p>Use this option to change the package of ruby generated classes. Default
is empty. When this option is not set, the package name will be used for
determining the ruby package.</p>
%}
        *)

        features:FeatureSet.t option;
        (**
{%html:
<p>Any features defined in the specific edition.
WARNING: This field should only be used by protobuf plugins or special
cases like the proto compiler. Other uses are discouraged and
developers should rely on the protoreflect APIs for their client language.</p>
%}
        *)

        uninterpreted_option:UninterpretedOption.t list;
        (**
{%html:
<p>The parser stores options it doesn't recognize here.
See the documentation for the &quot;Options&quot; section above.</p>
%}
        *)

        extensions':Runtime'.Extensions.t;
      }
      val make: ?java_package:string -> ?java_outer_classname:string -> ?optimize_for:OptimizeMode.t -> ?java_multiple_files:bool -> ?go_package:string -> ?cc_generic_services:bool -> ?java_generic_services:bool -> ?py_generic_services:bool -> ?java_generate_equals_and_hash:bool -> ?deprecated:bool -> ?java_string_check_utf8:bool -> ?cc_enable_arenas:bool -> ?objc_class_prefix:string -> ?csharp_namespace:string -> ?swift_prefix:string -> ?php_class_prefix:string -> ?php_namespace:string -> ?php_metadata_namespace:string -> ?ruby_package:string -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?java_package:string -> ?java_outer_classname:string -> ?optimize_for:OptimizeMode.t -> ?java_multiple_files:bool -> ?go_package:string -> ?cc_generic_services:bool -> ?java_generic_services:bool -> ?py_generic_services:bool -> ?java_generate_equals_and_hash:bool -> ?deprecated:bool -> ?java_string_check_utf8:bool -> ?cc_enable_arenas:bool -> ?objc_class_prefix:string -> ?csharp_namespace:string -> ?swift_prefix:string -> ?php_class_prefix:string -> ?php_namespace:string -> ?php_metadata_namespace:string -> ?ruby_package:string -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end = struct
      module This'_ = FileOptions
      module rec OptimizeMode : sig
        type t =
          | SPEED
          (**
{%html:
<p>Generate complete code for parsing, serialization,</p>
%}
          *)

          | CODE_SIZE
          (**
{%html:
<p>etc.</p>
<p>Use ReflectionOps to implement these methods.</p>
%}
          *)

          | LITE_RUNTIME
          (**
{%html:
<p>Generate code using MessageLite and the lite runtime.</p>
%}
          *)


        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end = struct
        module This'_ = OptimizeMode
        type t =
          | SPEED
          (**
{%html:
<p>Generate complete code for parsing, serialization,</p>
%}
          *)

          | CODE_SIZE
          (**
{%html:
<p>etc.</p>
<p>Use ReflectionOps to implement these methods.</p>
%}
          *)

          | LITE_RUNTIME
          (**
{%html:
<p>Generate code using MessageLite and the lite runtime.</p>
%}
          *)


        let name () = ".google.protobuf.FileOptions.OptimizeMode"
        let to_int = function
          | SPEED -> 1
          | CODE_SIZE -> 2
          | LITE_RUNTIME -> 3
        let from_int_exn = function
          | 1 -> SPEED
          | 2 -> CODE_SIZE
          | 3 -> LITE_RUNTIME
          | n -> Runtime'.Result.raise (`Unknown_enum_value n)
        let from_int e = Runtime'.Result.catch (fun () -> from_int_exn e)
        let to_string = function
          | SPEED -> "SPEED"
          | CODE_SIZE -> "CODE_SIZE"
          | LITE_RUNTIME -> "LITE_RUNTIME"
        let from_string_exn = function
          | "SPEED" -> SPEED
          | "CODE_SIZE" -> CODE_SIZE
          | "LITE_RUNTIME" -> LITE_RUNTIME
          | s -> Runtime'.Result.raise (`Unknown_enum_name s)

      end

      let name () = ".google.protobuf.FileOptions"
      type t = {
        java_package:string option;
        java_outer_classname:string option;
        optimize_for:OptimizeMode.t;
        java_multiple_files:bool;
        go_package:string option;
        cc_generic_services:bool;
        java_generic_services:bool;
        py_generic_services:bool;
        java_generate_equals_and_hash:bool option;
        deprecated:bool;
        java_string_check_utf8:bool;
        cc_enable_arenas:bool;
        objc_class_prefix:string option;
        csharp_namespace:string option;
        swift_prefix:string option;
        php_class_prefix:string option;
        php_namespace:string option;
        php_metadata_namespace:string option;
        ruby_package:string option;
        features:FeatureSet.t option;
        uninterpreted_option:UninterpretedOption.t list;
        extensions':Runtime'.Extensions.t;
      }
      type make_t = ?java_package:string -> ?java_outer_classname:string -> ?optimize_for:OptimizeMode.t -> ?java_multiple_files:bool -> ?go_package:string -> ?cc_generic_services:bool -> ?java_generic_services:bool -> ?py_generic_services:bool -> ?java_generate_equals_and_hash:bool -> ?deprecated:bool -> ?java_string_check_utf8:bool -> ?cc_enable_arenas:bool -> ?objc_class_prefix:string -> ?csharp_namespace:string -> ?swift_prefix:string -> ?php_class_prefix:string -> ?php_namespace:string -> ?php_metadata_namespace:string -> ?ruby_package:string -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      let make ?java_package ?java_outer_classname ?(optimize_for = OptimizeMode.SPEED) ?(java_multiple_files = false) ?go_package ?(cc_generic_services = false) ?(java_generic_services = false) ?(py_generic_services = false) ?java_generate_equals_and_hash ?(deprecated = false) ?(java_string_check_utf8 = false) ?(cc_enable_arenas = true) ?objc_class_prefix ?csharp_namespace ?swift_prefix ?php_class_prefix ?php_namespace ?php_metadata_namespace ?ruby_package ?features ?(uninterpreted_option = []) ?(extensions' = Runtime'.Extensions.default) () = { java_package; java_outer_classname; optimize_for; java_multiple_files; go_package; cc_generic_services; java_generic_services; py_generic_services; java_generate_equals_and_hash; deprecated; java_string_check_utf8; cc_enable_arenas; objc_class_prefix; csharp_namespace; swift_prefix; php_class_prefix; php_namespace; php_metadata_namespace; ruby_package; features; uninterpreted_option; extensions' }
      let merge =
      let merge_java_package = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((1, "java_package", "javaPackage"), string) ) in
      let merge_java_outer_classname = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((8, "java_outer_classname", "javaOuterClassname"), string) ) in
      let merge_optimize_for = Runtime'.Merge.merge Runtime'.Spec.( basic ((9, "optimize_for", "optimizeFor"), (enum (module OptimizeMode)), (OptimizeMode.SPEED)) ) in
      let merge_java_multiple_files = Runtime'.Merge.merge Runtime'.Spec.( basic ((10, "java_multiple_files", "javaMultipleFiles"), bool, (false)) ) in
      let merge_go_package = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((11, "go_package", "goPackage"), string) ) in
      let merge_cc_generic_services = Runtime'.Merge.merge Runtime'.Spec.( basic ((16, "cc_generic_services", "ccGenericServices"), bool, (false)) ) in
      let merge_java_generic_services = Runtime'.Merge.merge Runtime'.Spec.( basic ((17, "java_generic_services", "javaGenericServices"), bool, (false)) ) in
      let merge_py_generic_services = Runtime'.Merge.merge Runtime'.Spec.( basic ((18, "py_generic_services", "pyGenericServices"), bool, (false)) ) in
      let merge_java_generate_equals_and_hash = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((20, "java_generate_equals_and_hash", "javaGenerateEqualsAndHash"), bool) ) in
      let merge_deprecated = Runtime'.Merge.merge Runtime'.Spec.( basic ((23, "deprecated", "deprecated"), bool, (false)) ) in
      let merge_java_string_check_utf8 = Runtime'.Merge.merge Runtime'.Spec.( basic ((27, "java_string_check_utf8", "javaStringCheckUtf8"), bool, (false)) ) in
      let merge_cc_enable_arenas = Runtime'.Merge.merge Runtime'.Spec.( basic ((31, "cc_enable_arenas", "ccEnableArenas"), bool, (true)) ) in
      let merge_objc_class_prefix = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((36, "objc_class_prefix", "objcClassPrefix"), string) ) in
      let merge_csharp_namespace = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((37, "csharp_namespace", "csharpNamespace"), string) ) in
      let merge_swift_prefix = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((39, "swift_prefix", "swiftPrefix"), string) ) in
      let merge_php_class_prefix = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((40, "php_class_prefix", "phpClassPrefix"), string) ) in
      let merge_php_namespace = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((41, "php_namespace", "phpNamespace"), string) ) in
      let merge_php_metadata_namespace = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((44, "php_metadata_namespace", "phpMetadataNamespace"), string) ) in
      let merge_ruby_package = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((45, "ruby_package", "rubyPackage"), string) ) in
      let merge_features = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((50, "features", "features"), (message (module FeatureSet))) ) in
      let merge_uninterpreted_option = Runtime'.Merge.merge Runtime'.Spec.( repeated ((999, "uninterpreted_option", "uninterpretedOption"), (message (module UninterpretedOption)), not_packed) ) in
      fun t1 t2 -> {
      	java_package = (merge_java_package t1.java_package t2.java_package);
      	java_outer_classname = (merge_java_outer_classname t1.java_outer_classname t2.java_outer_classname);
      	optimize_for = (merge_optimize_for t1.optimize_for t2.optimize_for);
      	java_multiple_files = (merge_java_multiple_files t1.java_multiple_files t2.java_multiple_files);
      	go_package = (merge_go_package t1.go_package t2.go_package);
      	cc_generic_services = (merge_cc_generic_services t1.cc_generic_services t2.cc_generic_services);
      	java_generic_services = (merge_java_generic_services t1.java_generic_services t2.java_generic_services);
      	py_generic_services = (merge_py_generic_services t1.py_generic_services t2.py_generic_services);
      	java_generate_equals_and_hash = (merge_java_generate_equals_and_hash t1.java_generate_equals_and_hash t2.java_generate_equals_and_hash);
      	deprecated = (merge_deprecated t1.deprecated t2.deprecated);
      	java_string_check_utf8 = (merge_java_string_check_utf8 t1.java_string_check_utf8 t2.java_string_check_utf8);
      	cc_enable_arenas = (merge_cc_enable_arenas t1.cc_enable_arenas t2.cc_enable_arenas);
      	objc_class_prefix = (merge_objc_class_prefix t1.objc_class_prefix t2.objc_class_prefix);
      	csharp_namespace = (merge_csharp_namespace t1.csharp_namespace t2.csharp_namespace);
      	swift_prefix = (merge_swift_prefix t1.swift_prefix t2.swift_prefix);
      	php_class_prefix = (merge_php_class_prefix t1.php_class_prefix t2.php_class_prefix);
      	php_namespace = (merge_php_namespace t1.php_namespace t2.php_namespace);
      	php_metadata_namespace = (merge_php_metadata_namespace t1.php_metadata_namespace t2.php_metadata_namespace);
      	ruby_package = (merge_ruby_package t1.ruby_package t2.ruby_package);
      	features = (merge_features t1.features t2.features);
      	uninterpreted_option = (merge_uninterpreted_option t1.uninterpreted_option t2.uninterpreted_option);
      	extensions' = (List.append t1.extensions' t2.extensions');
       }
      let spec () = Runtime'.Spec.( basic_opt ((1, "java_package", "javaPackage"), string) ^:: basic_opt ((8, "java_outer_classname", "javaOuterClassname"), string) ^:: basic ((9, "optimize_for", "optimizeFor"), (enum (module OptimizeMode)), (OptimizeMode.SPEED)) ^:: basic ((10, "java_multiple_files", "javaMultipleFiles"), bool, (false)) ^:: basic_opt ((11, "go_package", "goPackage"), string) ^:: basic ((16, "cc_generic_services", "ccGenericServices"), bool, (false)) ^:: basic ((17, "java_generic_services", "javaGenericServices"), bool, (false)) ^:: basic ((18, "py_generic_services", "pyGenericServices"), bool, (false)) ^:: basic_opt ((20, "java_generate_equals_and_hash", "javaGenerateEqualsAndHash"), bool) ^:: basic ((23, "deprecated", "deprecated"), bool, (false)) ^:: basic ((27, "java_string_check_utf8", "javaStringCheckUtf8"), bool, (false)) ^:: basic ((31, "cc_enable_arenas", "ccEnableArenas"), bool, (true)) ^:: basic_opt ((36, "objc_class_prefix", "objcClassPrefix"), string) ^:: basic_opt ((37, "csharp_namespace", "csharpNamespace"), string) ^:: basic_opt ((39, "swift_prefix", "swiftPrefix"), string) ^:: basic_opt ((40, "php_class_prefix", "phpClassPrefix"), string) ^:: basic_opt ((41, "php_namespace", "phpNamespace"), string) ^:: basic_opt ((44, "php_metadata_namespace", "phpMetadataNamespace"), string) ^:: basic_opt ((45, "ruby_package", "rubyPackage"), string) ^:: basic_opt ((50, "features", "features"), (message (module FeatureSet))) ^:: repeated ((999, "uninterpreted_option", "uninterpretedOption"), (message (module UninterpretedOption)), not_packed) ^:: nil_ext [ (1000, 536870912) ] )
      let to_proto' =
        let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
        fun writer { java_package; java_outer_classname; optimize_for; java_multiple_files; go_package; cc_generic_services; java_generic_services; py_generic_services; java_generate_equals_and_hash; deprecated; java_string_check_utf8; cc_enable_arenas; objc_class_prefix; csharp_namespace; swift_prefix; php_class_prefix; php_namespace; php_metadata_namespace; ruby_package; features; uninterpreted_option; extensions' } -> serialize writer java_package java_outer_classname optimize_for java_multiple_files go_package cc_generic_services java_generic_services py_generic_services java_generate_equals_and_hash deprecated java_string_check_utf8 cc_enable_arenas objc_class_prefix csharp_namespace swift_prefix php_class_prefix php_namespace php_metadata_namespace ruby_package features uninterpreted_option extensions'

      let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
      let from_proto_exn =
        let constructor java_package java_outer_classname optimize_for java_multiple_files go_package cc_generic_services java_generic_services py_generic_services java_generate_equals_and_hash deprecated java_string_check_utf8 cc_enable_arenas objc_class_prefix csharp_namespace swift_prefix php_class_prefix php_namespace php_metadata_namespace ruby_package features uninterpreted_option extensions' = { java_package; java_outer_classname; optimize_for; java_multiple_files; go_package; cc_generic_services; java_generic_services; py_generic_services; java_generate_equals_and_hash; deprecated; java_string_check_utf8; cc_enable_arenas; objc_class_prefix; csharp_namespace; swift_prefix; php_class_prefix; php_namespace; php_metadata_namespace; ruby_package; features; uninterpreted_option; extensions' } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
      let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
      let to_json options =
        let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
        fun { java_package; java_outer_classname; optimize_for; java_multiple_files; go_package; cc_generic_services; java_generic_services; py_generic_services; java_generate_equals_and_hash; deprecated; java_string_check_utf8; cc_enable_arenas; objc_class_prefix; csharp_namespace; swift_prefix; php_class_prefix; php_namespace; php_metadata_namespace; ruby_package; features; uninterpreted_option; extensions' } -> serialize java_package java_outer_classname optimize_for java_multiple_files go_package cc_generic_services java_generic_services py_generic_services java_generate_equals_and_hash deprecated java_string_check_utf8 cc_enable_arenas objc_class_prefix csharp_namespace swift_prefix php_class_prefix php_namespace php_metadata_namespace ruby_package features uninterpreted_option extensions'
      let from_json_exn =
        let constructor java_package java_outer_classname optimize_for java_multiple_files go_package cc_generic_services java_generic_services py_generic_services java_generate_equals_and_hash deprecated java_string_check_utf8 cc_enable_arenas objc_class_prefix csharp_namespace swift_prefix php_class_prefix php_namespace php_metadata_namespace ruby_package features uninterpreted_option extensions' = { java_package; java_outer_classname; optimize_for; java_multiple_files; go_package; cc_generic_services; java_generic_services; py_generic_services; java_generate_equals_and_hash; deprecated; java_string_check_utf8; cc_enable_arenas; objc_class_prefix; csharp_namespace; swift_prefix; php_class_prefix; php_namespace; php_metadata_namespace; ruby_package; features; uninterpreted_option; extensions' } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
      let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
    end

    and MessageOptions : sig
      type t = {
        message_set_wire_format:bool;
        (**
{%html:
<p>Set true to use the old proto1 MessageSet wire format for extensions.
This is provided for backwards-compatibility with the MessageSet wire
format.  You should not use this for any other reason:  It's less
efficient, has fewer features, and is more complicated.</p>
<p>The message must be defined exactly as follows:</p>
<pre><code> message Foo {
   option message_set_wire_format = true;
   extensions 4 to max;
 }
</code></pre>
<p>Note that the message cannot have any defined fields; MessageSets only
have extensions.</p>
<p>All extensions of your type must be singular messages; e.g. they cannot
be int32s, enums, or repeated messages.</p>
<p>Because this is an option, the above two restrictions are not enforced by
the protocol compiler.</p>
%}
        *)

        no_standard_descriptor_accessor:bool;
        (**
{%html:
<p>Disables the generation of the standard &quot;descriptor()&quot; accessor, which can
conflict with a field of the same name.  This is meant to make migration
from proto1 easier; new code should avoid fields named &quot;descriptor&quot;.</p>
%}
        *)

        deprecated:bool;
        (**
{%html:
<p>Is this message deprecated?
Depending on the target platform, this can emit Deprecated annotations
for the message, or it will be completely ignored; in the very least,
this is a formalization for deprecating messages.</p>
%}
        *)

        map_entry:bool option;
        (**
{%html:
<p>Whether the message is an automatically generated map entry type for the
maps field.</p>
<p>For maps fields:</p>
<pre><code> map&lt;KeyType, ValueType&gt; map_field = 1;
</code></pre>
<p>The parsed descriptor looks like:</p>
<pre><code> message MapFieldEntry {
     option map_entry = true;
     optional KeyType key = 1;
     optional ValueType value = 2;
 }
 repeated MapFieldEntry map_field = 1;
</code></pre>
<p>Implementations may choose not to generate the map_entry=true message, but
use a native map in the target language to hold the keys and values.
The reflection APIs in such implementations still need to work as
if the field is a repeated message field.</p>
<p>NOTE: Do not set the option in .proto files. Always use the maps syntax
instead. The option should only be implicitly set by the proto compiler
parser.</p>
%}
        *)

        deprecated_legacy_json_field_conflicts:bool option[@ocaml.alert protobuf "Marked as deprecated in the .proto file"];
        (**
{%html:
<p>Enable the legacy handling of JSON field name conflicts.  This lowercases
and strips underscored from the fields before comparison in proto3 only.
The new behavior takes <code>json_name</code> into account and applies to proto2 as
well.</p>
<p>This should only be used as a temporary measure against broken builds due
to the change in behavior for JSON field name conflicts.</p>
<p>TODO This is legacy behavior we plan to remove once downstream
teams have had time to migrate.</p>
%}
        *)

        features:FeatureSet.t option;
        (**
{%html:
<p>Clients can define custom options in extensions of this message. See above.</p>
%}
        *)

        uninterpreted_option:UninterpretedOption.t list;
        (**
{%html:
<p>The parser stores options it doesn't recognize here. See above.</p>
%}
        *)

        extensions':Runtime'.Extensions.t;
      }
      val make: ?message_set_wire_format:bool -> ?no_standard_descriptor_accessor:bool -> ?deprecated:bool -> ?map_entry:bool -> ?deprecated_legacy_json_field_conflicts:bool -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?message_set_wire_format:bool -> ?no_standard_descriptor_accessor:bool -> ?deprecated:bool -> ?map_entry:bool -> ?deprecated_legacy_json_field_conflicts:bool -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end = struct
      module This'_ = MessageOptions
      let name () = ".google.protobuf.MessageOptions"
      type t = {
        message_set_wire_format:bool;
        no_standard_descriptor_accessor:bool;
        deprecated:bool;
        map_entry:bool option;
        deprecated_legacy_json_field_conflicts:bool option;
        features:FeatureSet.t option;
        uninterpreted_option:UninterpretedOption.t list;
        extensions':Runtime'.Extensions.t;
      }
      type make_t = ?message_set_wire_format:bool -> ?no_standard_descriptor_accessor:bool -> ?deprecated:bool -> ?map_entry:bool -> ?deprecated_legacy_json_field_conflicts:bool -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      let make ?(message_set_wire_format = false) ?(no_standard_descriptor_accessor = false) ?(deprecated = false) ?map_entry ?deprecated_legacy_json_field_conflicts ?features ?(uninterpreted_option = []) ?(extensions' = Runtime'.Extensions.default) () = { message_set_wire_format; no_standard_descriptor_accessor; deprecated; map_entry; deprecated_legacy_json_field_conflicts; features; uninterpreted_option; extensions' }
      let merge =
      let merge_message_set_wire_format = Runtime'.Merge.merge Runtime'.Spec.( basic ((1, "message_set_wire_format", "messageSetWireFormat"), bool, (false)) ) in
      let merge_no_standard_descriptor_accessor = Runtime'.Merge.merge Runtime'.Spec.( basic ((2, "no_standard_descriptor_accessor", "noStandardDescriptorAccessor"), bool, (false)) ) in
      let merge_deprecated = Runtime'.Merge.merge Runtime'.Spec.( basic ((3, "deprecated", "deprecated"), bool, (false)) ) in
      let merge_map_entry = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((7, "map_entry", "mapEntry"), bool) ) in
      let merge_deprecated_legacy_json_field_conflicts = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((11, "deprecated_legacy_json_field_conflicts", "deprecatedLegacyJsonFieldConflicts"), bool) ) in
      let merge_features = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((12, "features", "features"), (message (module FeatureSet))) ) in
      let merge_uninterpreted_option = Runtime'.Merge.merge Runtime'.Spec.( repeated ((999, "uninterpreted_option", "uninterpretedOption"), (message (module UninterpretedOption)), not_packed) ) in
      fun t1 t2 -> {
      	message_set_wire_format = (merge_message_set_wire_format t1.message_set_wire_format t2.message_set_wire_format);
      	no_standard_descriptor_accessor = (merge_no_standard_descriptor_accessor t1.no_standard_descriptor_accessor t2.no_standard_descriptor_accessor);
      	deprecated = (merge_deprecated t1.deprecated t2.deprecated);
      	map_entry = (merge_map_entry t1.map_entry t2.map_entry);
      	deprecated_legacy_json_field_conflicts = (merge_deprecated_legacy_json_field_conflicts t1.deprecated_legacy_json_field_conflicts t2.deprecated_legacy_json_field_conflicts);
      	features = (merge_features t1.features t2.features);
      	uninterpreted_option = (merge_uninterpreted_option t1.uninterpreted_option t2.uninterpreted_option);
      	extensions' = (List.append t1.extensions' t2.extensions');
       }
      let spec () = Runtime'.Spec.( basic ((1, "message_set_wire_format", "messageSetWireFormat"), bool, (false)) ^:: basic ((2, "no_standard_descriptor_accessor", "noStandardDescriptorAccessor"), bool, (false)) ^:: basic ((3, "deprecated", "deprecated"), bool, (false)) ^:: basic_opt ((7, "map_entry", "mapEntry"), bool) ^:: basic_opt ((11, "deprecated_legacy_json_field_conflicts", "deprecatedLegacyJsonFieldConflicts"), bool) ^:: basic_opt ((12, "features", "features"), (message (module FeatureSet))) ^:: repeated ((999, "uninterpreted_option", "uninterpretedOption"), (message (module UninterpretedOption)), not_packed) ^:: nil_ext [ (1000, 536870912) ] )
      let to_proto' =
        let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
        fun writer { message_set_wire_format; no_standard_descriptor_accessor; deprecated; map_entry; deprecated_legacy_json_field_conflicts; features; uninterpreted_option; extensions' } -> serialize writer message_set_wire_format no_standard_descriptor_accessor deprecated map_entry deprecated_legacy_json_field_conflicts features uninterpreted_option extensions'

      let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
      let from_proto_exn =
        let constructor message_set_wire_format no_standard_descriptor_accessor deprecated map_entry deprecated_legacy_json_field_conflicts features uninterpreted_option extensions' = { message_set_wire_format; no_standard_descriptor_accessor; deprecated; map_entry; deprecated_legacy_json_field_conflicts; features; uninterpreted_option; extensions' } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
      let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
      let to_json options =
        let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
        fun { message_set_wire_format; no_standard_descriptor_accessor; deprecated; map_entry; deprecated_legacy_json_field_conflicts; features; uninterpreted_option; extensions' } -> serialize message_set_wire_format no_standard_descriptor_accessor deprecated map_entry deprecated_legacy_json_field_conflicts features uninterpreted_option extensions'
      let from_json_exn =
        let constructor message_set_wire_format no_standard_descriptor_accessor deprecated map_entry deprecated_legacy_json_field_conflicts features uninterpreted_option extensions' = { message_set_wire_format; no_standard_descriptor_accessor; deprecated; map_entry; deprecated_legacy_json_field_conflicts; features; uninterpreted_option; extensions' } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
      let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
    end

    and FieldOptions : sig
      module rec CType : sig
        type t =
          | STRING
          (**
{%html:
<p>Default mode.</p>
%}
          *)

          | CORD
          (**
{%html:
<p>The option [ctype=CORD] may be applied to a non-repeated field of type
&quot;bytes&quot;. It indicates that in C++, the data should be stored in a Cord
instead of a string.  For very large strings, this may reduce memory
fragmentation. It may also allow better performance when parsing from a
Cord, or when parsing with aliasing enabled, as the parsed Cord may then
alias the original buffer.</p>
%}
          *)

          | STRING_PIECE

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      and JSType : sig
        type t =
          | JS_NORMAL
          (**
{%html:
<p>Use the default type.</p>
%}
          *)

          | JS_STRING
          (**
{%html:
<p>Use JavaScript strings.</p>
%}
          *)

          | JS_NUMBER
          (**
{%html:
<p>Use JavaScript numbers.</p>
%}
          *)


        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end


      (**
{%html:
<p>If set to RETENTION_SOURCE, the option will be omitted from the binary.</p>
%}
      *)
      and OptionRetention : sig
        type t =
          | RETENTION_UNKNOWN
          | RETENTION_RUNTIME
          | RETENTION_SOURCE

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end


      (**
{%html:
<p>This indicates the types of entities that the field may apply to when used
as an option. If it is unset, then the field may be freely used as an
option on any kind of entity.</p>
%}
      *)
      and OptionTargetType : sig
        type t =
          | TARGET_TYPE_UNKNOWN
          | TARGET_TYPE_FILE
          | TARGET_TYPE_EXTENSION_RANGE
          | TARGET_TYPE_MESSAGE
          | TARGET_TYPE_FIELD
          | TARGET_TYPE_ONEOF
          | TARGET_TYPE_ENUM
          | TARGET_TYPE_ENUM_ENTRY
          | TARGET_TYPE_SERVICE
          | TARGET_TYPE_METHOD

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      and EditionDefault : sig
        type t = {
          value:string option;
          (**
{%html:
<p>Textproto value.</p>
%}
          *)

          edition:Edition.t option;
        }
        val make: ?value:string -> ?edition:Edition.t -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?value:string -> ?edition:Edition.t -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end


      (**
{%html:
<p>Information about the support window of a feature.</p>
%}
      *)
      and FeatureSupport : sig
        type t = {
          edition_introduced:Edition.t option;
          (**
{%html:
<p>The edition that this feature was first available in.  In editions
earlier than this one, the default assigned to EDITION_LEGACY will be
used, and proto files will not be able to override it.</p>
%}
          *)

          edition_deprecated:Edition.t option;
          (**
{%html:
<p>The edition this feature becomes deprecated in.  Using this after this
edition may trigger warnings.</p>
%}
          *)

          deprecation_warning:string option;
          (**
{%html:
<p>The deprecation warning text if this feature is used after the edition it
was marked deprecated in.</p>
%}
          *)

          edition_removed:Edition.t option;
          (**
{%html:
<p>The edition this feature is no longer available in.  In editions after
this one, the last default assigned will be used, and proto files will
not be able to override it.</p>
%}
          *)

          removal_error:string option;
          (**
{%html:
<p>The removal error text if this feature is used after the edition it was
removed in.</p>
%}
          *)

        }
        val make: ?edition_introduced:Edition.t -> ?edition_deprecated:Edition.t -> ?deprecation_warning:string -> ?edition_removed:Edition.t -> ?removal_error:string -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?edition_introduced:Edition.t -> ?edition_deprecated:Edition.t -> ?deprecation_warning:string -> ?edition_removed:Edition.t -> ?removal_error:string -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end

      type t = {
        ctype:CType.t;
        (**
{%html:
<p>NOTE: ctype is deprecated. Use <code>features.(pb.cpp).string_type</code> instead.
The ctype option instructs the C++ code generator to use a different
representation of the field than it normally would.  See the specific
options below.  This option is only implemented to support use of
[ctype=CORD] and [ctype=STRING] (the default) on non-repeated fields of
type &quot;bytes&quot; in the open source release.
TODO: make ctype actually deprecated.</p>
%}
        *)

        packed:bool option;
        (**
{%html:
<p>The packed option can be enabled for repeated primitive fields to enable
a more efficient representation on the wire. Rather than repeatedly
writing the tag and type for each element, the entire array is encoded as
a single length-delimited blob. In proto3, only explicit setting it to
false will avoid using packed encoding.  This option is prohibited in
Editions, but the <code>repeated_field_encoding</code> feature can be used to control
the behavior.</p>
%}
        *)

        deprecated:bool;
        (**
{%html:
<p>Clients can define custom options in extensions of this message. See above.</p>
%}
        *)

        lazy':bool;
        (**
{%html:
<p>Should this field be parsed lazily?  Lazy applies only to message-type
fields.  It means that when the outer message is initially parsed, the
inner message's contents will not be parsed but instead stored in encoded
form.  The inner message will actually be parsed when it is first accessed.</p>
<p>This is only a hint.  Implementations are free to choose whether to use
eager or lazy parsing regardless of the value of this option.  However,
setting this option true suggests that the protocol author believes that
using lazy parsing on this field is worth the additional bookkeeping
overhead typically needed to implement it.</p>
<p>This option does not affect the public interface of any generated code;
all method signatures remain the same.  Furthermore, thread-safety of the
interface is not affected by this option; const methods remain safe to
call from multiple threads concurrently, while non-const methods continue
to require exclusive access.</p>
<p>Note that lazy message fields are still eagerly verified to check
ill-formed wireformat or missing required fields. Calling IsInitialized()
on the outer message would fail if the inner message has missing required
fields. Failed verification would result in parsing failure (except when
uninitialized messages are acceptable).</p>
%}
        *)

        jstype:JSType.t;
        (**
{%html:
<p>The jstype option determines the JavaScript type used for values of the
field.  The option is permitted only for 64 bit integral and fixed types
(int64, uint64, sint64, fixed64, sfixed64).  A field with jstype JS_STRING
is represented as JavaScript string, which avoids loss of precision that
can happen when a large value is converted to a floating point JavaScript.
Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
use the JavaScript &quot;number&quot; type.  The behavior of the default option
JS_NORMAL is implementation dependent.</p>
<p>This option is an enum to permit additional types to be added, e.g.
goog.math.Integer.</p>
%}
        *)

        weak:bool[@ocaml.alert protobuf "Marked as deprecated in the .proto file"];
        (**
{%html:
<p>DEPRECATED. DO NOT USE!
For Google-internal migration only. Do not use.</p>
%}
        *)

        unverified_lazy:bool;
        (**
{%html:
<p>unverified_lazy does no correctness checks on the byte stream. This should
only be used where lazy with verification is prohibitive for performance
reasons.</p>
%}
        *)

        debug_redact:bool;
        (**
{%html:
<p>Indicate that the field value should not be printed out when using debug
formats, e.g. when the field contains sensitive credentials.</p>
%}
        *)

        retention:OptionRetention.t option;
        targets:OptionTargetType.t list;
        (**
{%html:
<p>reserve target, target_obsolete_do_not_use</p>
%}
        *)

        edition_defaults:EditionDefault.t list;
        features:FeatureSet.t option;
        (**
{%html:
<p>Any features defined in the specific edition.
WARNING: This field should only be used by protobuf plugins or special
cases like the proto compiler. Other uses are discouraged and
developers should rely on the protoreflect APIs for their client language.</p>
%}
        *)

        feature_support:FeatureSupport.t option;
        uninterpreted_option:UninterpretedOption.t list;
        (**
{%html:
<p>The parser stores options it doesn't recognize here. See above.</p>
%}
        *)

        extensions':Runtime'.Extensions.t;
      }
      val make: ?ctype:CType.t -> ?packed:bool -> ?deprecated:bool -> ?lazy':bool -> ?jstype:JSType.t -> ?weak:bool -> ?unverified_lazy:bool -> ?debug_redact:bool -> ?retention:OptionRetention.t -> ?targets:OptionTargetType.t list -> ?edition_defaults:EditionDefault.t list -> ?features:FeatureSet.t -> ?feature_support:FeatureSupport.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?ctype:CType.t -> ?packed:bool -> ?deprecated:bool -> ?lazy':bool -> ?jstype:JSType.t -> ?weak:bool -> ?unverified_lazy:bool -> ?debug_redact:bool -> ?retention:OptionRetention.t -> ?targets:OptionTargetType.t list -> ?edition_defaults:EditionDefault.t list -> ?features:FeatureSet.t -> ?feature_support:FeatureSupport.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end = struct
      module This'_ = FieldOptions
      module rec CType : sig
        type t =
          | STRING
          (**
{%html:
<p>Default mode.</p>
%}
          *)

          | CORD
          (**
{%html:
<p>The option [ctype=CORD] may be applied to a non-repeated field of type
&quot;bytes&quot;. It indicates that in C++, the data should be stored in a Cord
instead of a string.  For very large strings, this may reduce memory
fragmentation. It may also allow better performance when parsing from a
Cord, or when parsing with aliasing enabled, as the parsed Cord may then
alias the original buffer.</p>
%}
          *)

          | STRING_PIECE

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end = struct
        module This'_ = CType
        type t =
          | STRING
          (**
{%html:
<p>Default mode.</p>
%}
          *)

          | CORD
          (**
{%html:
<p>The option [ctype=CORD] may be applied to a non-repeated field of type
&quot;bytes&quot;. It indicates that in C++, the data should be stored in a Cord
instead of a string.  For very large strings, this may reduce memory
fragmentation. It may also allow better performance when parsing from a
Cord, or when parsing with aliasing enabled, as the parsed Cord may then
alias the original buffer.</p>
%}
          *)

          | STRING_PIECE

        let name () = ".google.protobuf.FieldOptions.CType"
        let to_int = function
          | STRING -> 0
          | CORD -> 1
          | STRING_PIECE -> 2
        let from_int_exn = function
          | 0 -> STRING
          | 1 -> CORD
          | 2 -> STRING_PIECE
          | n -> Runtime'.Result.raise (`Unknown_enum_value n)
        let from_int e = Runtime'.Result.catch (fun () -> from_int_exn e)
        let to_string = function
          | STRING -> "STRING"
          | CORD -> "CORD"
          | STRING_PIECE -> "STRING_PIECE"
        let from_string_exn = function
          | "STRING" -> STRING
          | "CORD" -> CORD
          | "STRING_PIECE" -> STRING_PIECE
          | s -> Runtime'.Result.raise (`Unknown_enum_name s)

      end

      and JSType : sig
        type t =
          | JS_NORMAL
          (**
{%html:
<p>Use the default type.</p>
%}
          *)

          | JS_STRING
          (**
{%html:
<p>Use JavaScript strings.</p>
%}
          *)

          | JS_NUMBER
          (**
{%html:
<p>Use JavaScript numbers.</p>
%}
          *)


        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end = struct
        module This'_ = JSType
        type t =
          | JS_NORMAL
          (**
{%html:
<p>Use the default type.</p>
%}
          *)

          | JS_STRING
          (**
{%html:
<p>Use JavaScript strings.</p>
%}
          *)

          | JS_NUMBER
          (**
{%html:
<p>Use JavaScript numbers.</p>
%}
          *)


        let name () = ".google.protobuf.FieldOptions.JSType"
        let to_int = function
          | JS_NORMAL -> 0
          | JS_STRING -> 1
          | JS_NUMBER -> 2
        let from_int_exn = function
          | 0 -> JS_NORMAL
          | 1 -> JS_STRING
          | 2 -> JS_NUMBER
          | n -> Runtime'.Result.raise (`Unknown_enum_value n)
        let from_int e = Runtime'.Result.catch (fun () -> from_int_exn e)
        let to_string = function
          | JS_NORMAL -> "JS_NORMAL"
          | JS_STRING -> "JS_STRING"
          | JS_NUMBER -> "JS_NUMBER"
        let from_string_exn = function
          | "JS_NORMAL" -> JS_NORMAL
          | "JS_STRING" -> JS_STRING
          | "JS_NUMBER" -> JS_NUMBER
          | s -> Runtime'.Result.raise (`Unknown_enum_name s)

      end

      and OptionRetention : sig
        type t =
          | RETENTION_UNKNOWN
          | RETENTION_RUNTIME
          | RETENTION_SOURCE

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end = struct
        module This'_ = OptionRetention
        type t =
          | RETENTION_UNKNOWN
          | RETENTION_RUNTIME
          | RETENTION_SOURCE

        let name () = ".google.protobuf.FieldOptions.OptionRetention"
        let to_int = function
          | RETENTION_UNKNOWN -> 0
          | RETENTION_RUNTIME -> 1
          | RETENTION_SOURCE -> 2
        let from_int_exn = function
          | 0 -> RETENTION_UNKNOWN
          | 1 -> RETENTION_RUNTIME
          | 2 -> RETENTION_SOURCE
          | n -> Runtime'.Result.raise (`Unknown_enum_value n)
        let from_int e = Runtime'.Result.catch (fun () -> from_int_exn e)
        let to_string = function
          | RETENTION_UNKNOWN -> "RETENTION_UNKNOWN"
          | RETENTION_RUNTIME -> "RETENTION_RUNTIME"
          | RETENTION_SOURCE -> "RETENTION_SOURCE"
        let from_string_exn = function
          | "RETENTION_UNKNOWN" -> RETENTION_UNKNOWN
          | "RETENTION_RUNTIME" -> RETENTION_RUNTIME
          | "RETENTION_SOURCE" -> RETENTION_SOURCE
          | s -> Runtime'.Result.raise (`Unknown_enum_name s)

      end

      and OptionTargetType : sig
        type t =
          | TARGET_TYPE_UNKNOWN
          | TARGET_TYPE_FILE
          | TARGET_TYPE_EXTENSION_RANGE
          | TARGET_TYPE_MESSAGE
          | TARGET_TYPE_FIELD
          | TARGET_TYPE_ONEOF
          | TARGET_TYPE_ENUM
          | TARGET_TYPE_ENUM_ENTRY
          | TARGET_TYPE_SERVICE
          | TARGET_TYPE_METHOD

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end = struct
        module This'_ = OptionTargetType
        type t =
          | TARGET_TYPE_UNKNOWN
          | TARGET_TYPE_FILE
          | TARGET_TYPE_EXTENSION_RANGE
          | TARGET_TYPE_MESSAGE
          | TARGET_TYPE_FIELD
          | TARGET_TYPE_ONEOF
          | TARGET_TYPE_ENUM
          | TARGET_TYPE_ENUM_ENTRY
          | TARGET_TYPE_SERVICE
          | TARGET_TYPE_METHOD

        let name () = ".google.protobuf.FieldOptions.OptionTargetType"
        let to_int = function
          | TARGET_TYPE_UNKNOWN -> 0
          | TARGET_TYPE_FILE -> 1
          | TARGET_TYPE_EXTENSION_RANGE -> 2
          | TARGET_TYPE_MESSAGE -> 3
          | TARGET_TYPE_FIELD -> 4
          | TARGET_TYPE_ONEOF -> 5
          | TARGET_TYPE_ENUM -> 6
          | TARGET_TYPE_ENUM_ENTRY -> 7
          | TARGET_TYPE_SERVICE -> 8
          | TARGET_TYPE_METHOD -> 9
        let from_int_exn = function
          | 0 -> TARGET_TYPE_UNKNOWN
          | 1 -> TARGET_TYPE_FILE
          | 2 -> TARGET_TYPE_EXTENSION_RANGE
          | 3 -> TARGET_TYPE_MESSAGE
          | 4 -> TARGET_TYPE_FIELD
          | 5 -> TARGET_TYPE_ONEOF
          | 6 -> TARGET_TYPE_ENUM
          | 7 -> TARGET_TYPE_ENUM_ENTRY
          | 8 -> TARGET_TYPE_SERVICE
          | 9 -> TARGET_TYPE_METHOD
          | n -> Runtime'.Result.raise (`Unknown_enum_value n)
        let from_int e = Runtime'.Result.catch (fun () -> from_int_exn e)
        let to_string = function
          | TARGET_TYPE_UNKNOWN -> "TARGET_TYPE_UNKNOWN"
          | TARGET_TYPE_FILE -> "TARGET_TYPE_FILE"
          | TARGET_TYPE_EXTENSION_RANGE -> "TARGET_TYPE_EXTENSION_RANGE"
          | TARGET_TYPE_MESSAGE -> "TARGET_TYPE_MESSAGE"
          | TARGET_TYPE_FIELD -> "TARGET_TYPE_FIELD"
          | TARGET_TYPE_ONEOF -> "TARGET_TYPE_ONEOF"
          | TARGET_TYPE_ENUM -> "TARGET_TYPE_ENUM"
          | TARGET_TYPE_ENUM_ENTRY -> "TARGET_TYPE_ENUM_ENTRY"
          | TARGET_TYPE_SERVICE -> "TARGET_TYPE_SERVICE"
          | TARGET_TYPE_METHOD -> "TARGET_TYPE_METHOD"
        let from_string_exn = function
          | "TARGET_TYPE_UNKNOWN" -> TARGET_TYPE_UNKNOWN
          | "TARGET_TYPE_FILE" -> TARGET_TYPE_FILE
          | "TARGET_TYPE_EXTENSION_RANGE" -> TARGET_TYPE_EXTENSION_RANGE
          | "TARGET_TYPE_MESSAGE" -> TARGET_TYPE_MESSAGE
          | "TARGET_TYPE_FIELD" -> TARGET_TYPE_FIELD
          | "TARGET_TYPE_ONEOF" -> TARGET_TYPE_ONEOF
          | "TARGET_TYPE_ENUM" -> TARGET_TYPE_ENUM
          | "TARGET_TYPE_ENUM_ENTRY" -> TARGET_TYPE_ENUM_ENTRY
          | "TARGET_TYPE_SERVICE" -> TARGET_TYPE_SERVICE
          | "TARGET_TYPE_METHOD" -> TARGET_TYPE_METHOD
          | s -> Runtime'.Result.raise (`Unknown_enum_name s)

      end

      and EditionDefault : sig
        type t = {
          value:string option;
          (**
{%html:
<p>Textproto value.</p>
%}
          *)

          edition:Edition.t option;
        }
        val make: ?value:string -> ?edition:Edition.t -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?value:string -> ?edition:Edition.t -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end = struct
        module This'_ = EditionDefault
        let name () = ".google.protobuf.FieldOptions.EditionDefault"
        type t = {
          value:string option;
          edition:Edition.t option;
        }
        type make_t = ?value:string -> ?edition:Edition.t -> unit -> t
        let make ?value ?edition () = { value; edition }
        let merge =
        let merge_value = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((2, "value", "value"), string) ) in
        let merge_edition = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((3, "edition", "edition"), (enum (module Edition))) ) in
        fun t1 t2 -> {
        	value = (merge_value t1.value t2.value);
        	edition = (merge_edition t1.edition t2.edition);
         }
        let spec () = Runtime'.Spec.( basic_opt ((2, "value", "value"), string) ^:: basic_opt ((3, "edition", "edition"), (enum (module Edition))) ^:: nil )
        let to_proto' =
          let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
          fun writer { value; edition } -> serialize writer value edition

        let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
        let from_proto_exn =
          let constructor value edition = { value; edition } in
          Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
        let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
        let to_json options =
          let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
          fun { value; edition } -> serialize value edition
        let from_json_exn =
          let constructor value edition = { value; edition } in
          Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
        let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
      end

      and FeatureSupport : sig
        type t = {
          edition_introduced:Edition.t option;
          (**
{%html:
<p>The edition that this feature was first available in.  In editions
earlier than this one, the default assigned to EDITION_LEGACY will be
used, and proto files will not be able to override it.</p>
%}
          *)

          edition_deprecated:Edition.t option;
          (**
{%html:
<p>The edition this feature becomes deprecated in.  Using this after this
edition may trigger warnings.</p>
%}
          *)

          deprecation_warning:string option;
          (**
{%html:
<p>The deprecation warning text if this feature is used after the edition it
was marked deprecated in.</p>
%}
          *)

          edition_removed:Edition.t option;
          (**
{%html:
<p>The edition this feature is no longer available in.  In editions after
this one, the last default assigned will be used, and proto files will
not be able to override it.</p>
%}
          *)

          removal_error:string option;
          (**
{%html:
<p>The removal error text if this feature is used after the edition it was
removed in.</p>
%}
          *)

        }
        val make: ?edition_introduced:Edition.t -> ?edition_deprecated:Edition.t -> ?deprecation_warning:string -> ?edition_removed:Edition.t -> ?removal_error:string -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?edition_introduced:Edition.t -> ?edition_deprecated:Edition.t -> ?deprecation_warning:string -> ?edition_removed:Edition.t -> ?removal_error:string -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end = struct
        module This'_ = FeatureSupport
        let name () = ".google.protobuf.FieldOptions.FeatureSupport"
        type t = {
          edition_introduced:Edition.t option;
          edition_deprecated:Edition.t option;
          deprecation_warning:string option;
          edition_removed:Edition.t option;
          removal_error:string option;
        }
        type make_t = ?edition_introduced:Edition.t -> ?edition_deprecated:Edition.t -> ?deprecation_warning:string -> ?edition_removed:Edition.t -> ?removal_error:string -> unit -> t
        let make ?edition_introduced ?edition_deprecated ?deprecation_warning ?edition_removed ?removal_error () = { edition_introduced; edition_deprecated; deprecation_warning; edition_removed; removal_error }
        let merge =
        let merge_edition_introduced = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((1, "edition_introduced", "editionIntroduced"), (enum (module Edition))) ) in
        let merge_edition_deprecated = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((2, "edition_deprecated", "editionDeprecated"), (enum (module Edition))) ) in
        let merge_deprecation_warning = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((3, "deprecation_warning", "deprecationWarning"), string) ) in
        let merge_edition_removed = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((4, "edition_removed", "editionRemoved"), (enum (module Edition))) ) in
        let merge_removal_error = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((5, "removal_error", "removalError"), string) ) in
        fun t1 t2 -> {
        	edition_introduced = (merge_edition_introduced t1.edition_introduced t2.edition_introduced);
        	edition_deprecated = (merge_edition_deprecated t1.edition_deprecated t2.edition_deprecated);
        	deprecation_warning = (merge_deprecation_warning t1.deprecation_warning t2.deprecation_warning);
        	edition_removed = (merge_edition_removed t1.edition_removed t2.edition_removed);
        	removal_error = (merge_removal_error t1.removal_error t2.removal_error);
         }
        let spec () = Runtime'.Spec.( basic_opt ((1, "edition_introduced", "editionIntroduced"), (enum (module Edition))) ^:: basic_opt ((2, "edition_deprecated", "editionDeprecated"), (enum (module Edition))) ^:: basic_opt ((3, "deprecation_warning", "deprecationWarning"), string) ^:: basic_opt ((4, "edition_removed", "editionRemoved"), (enum (module Edition))) ^:: basic_opt ((5, "removal_error", "removalError"), string) ^:: nil )
        let to_proto' =
          let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
          fun writer { edition_introduced; edition_deprecated; deprecation_warning; edition_removed; removal_error } -> serialize writer edition_introduced edition_deprecated deprecation_warning edition_removed removal_error

        let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
        let from_proto_exn =
          let constructor edition_introduced edition_deprecated deprecation_warning edition_removed removal_error = { edition_introduced; edition_deprecated; deprecation_warning; edition_removed; removal_error } in
          Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
        let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
        let to_json options =
          let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
          fun { edition_introduced; edition_deprecated; deprecation_warning; edition_removed; removal_error } -> serialize edition_introduced edition_deprecated deprecation_warning edition_removed removal_error
        let from_json_exn =
          let constructor edition_introduced edition_deprecated deprecation_warning edition_removed removal_error = { edition_introduced; edition_deprecated; deprecation_warning; edition_removed; removal_error } in
          Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
        let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
      end

      let name () = ".google.protobuf.FieldOptions"
      type t = {
        ctype:CType.t;
        packed:bool option;
        deprecated:bool;
        lazy':bool;
        jstype:JSType.t;
        weak:bool;
        unverified_lazy:bool;
        debug_redact:bool;
        retention:OptionRetention.t option;
        targets:OptionTargetType.t list;
        edition_defaults:EditionDefault.t list;
        features:FeatureSet.t option;
        feature_support:FeatureSupport.t option;
        uninterpreted_option:UninterpretedOption.t list;
        extensions':Runtime'.Extensions.t;
      }
      type make_t = ?ctype:CType.t -> ?packed:bool -> ?deprecated:bool -> ?lazy':bool -> ?jstype:JSType.t -> ?weak:bool -> ?unverified_lazy:bool -> ?debug_redact:bool -> ?retention:OptionRetention.t -> ?targets:OptionTargetType.t list -> ?edition_defaults:EditionDefault.t list -> ?features:FeatureSet.t -> ?feature_support:FeatureSupport.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      let make ?(ctype = CType.STRING) ?packed ?(deprecated = false) ?(lazy' = false) ?(jstype = JSType.JS_NORMAL) ?(weak = false) ?(unverified_lazy = false) ?(debug_redact = false) ?retention ?(targets = []) ?(edition_defaults = []) ?features ?feature_support ?(uninterpreted_option = []) ?(extensions' = Runtime'.Extensions.default) () = { ctype; packed; deprecated; lazy'; jstype; weak; unverified_lazy; debug_redact; retention; targets; edition_defaults; features; feature_support; uninterpreted_option; extensions' }
      let merge =
      let merge_ctype = Runtime'.Merge.merge Runtime'.Spec.( basic ((1, "ctype", "ctype"), (enum (module CType)), (CType.STRING)) ) in
      let merge_packed = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((2, "packed", "packed"), bool) ) in
      let merge_deprecated = Runtime'.Merge.merge Runtime'.Spec.( basic ((3, "deprecated", "deprecated"), bool, (false)) ) in
      let merge_lazy' = Runtime'.Merge.merge Runtime'.Spec.( basic ((5, "lazy", "lazy"), bool, (false)) ) in
      let merge_jstype = Runtime'.Merge.merge Runtime'.Spec.( basic ((6, "jstype", "jstype"), (enum (module JSType)), (JSType.JS_NORMAL)) ) in
      let merge_weak = Runtime'.Merge.merge Runtime'.Spec.( basic ((10, "weak", "weak"), bool, (false)) ) in
      let merge_unverified_lazy = Runtime'.Merge.merge Runtime'.Spec.( basic ((15, "unverified_lazy", "unverifiedLazy"), bool, (false)) ) in
      let merge_debug_redact = Runtime'.Merge.merge Runtime'.Spec.( basic ((16, "debug_redact", "debugRedact"), bool, (false)) ) in
      let merge_retention = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((17, "retention", "retention"), (enum (module OptionRetention))) ) in
      let merge_targets = Runtime'.Merge.merge Runtime'.Spec.( repeated ((19, "targets", "targets"), (enum (module OptionTargetType)), not_packed) ) in
      let merge_edition_defaults = Runtime'.Merge.merge Runtime'.Spec.( repeated ((20, "edition_defaults", "editionDefaults"), (message (module EditionDefault)), not_packed) ) in
      let merge_features = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((21, "features", "features"), (message (module FeatureSet))) ) in
      let merge_feature_support = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((22, "feature_support", "featureSupport"), (message (module FeatureSupport))) ) in
      let merge_uninterpreted_option = Runtime'.Merge.merge Runtime'.Spec.( repeated ((999, "uninterpreted_option", "uninterpretedOption"), (message (module UninterpretedOption)), not_packed) ) in
      fun t1 t2 -> {
      	ctype = (merge_ctype t1.ctype t2.ctype);
      	packed = (merge_packed t1.packed t2.packed);
      	deprecated = (merge_deprecated t1.deprecated t2.deprecated);
      	lazy' = (merge_lazy' t1.lazy' t2.lazy');
      	jstype = (merge_jstype t1.jstype t2.jstype);
      	weak = (merge_weak t1.weak t2.weak);
      	unverified_lazy = (merge_unverified_lazy t1.unverified_lazy t2.unverified_lazy);
      	debug_redact = (merge_debug_redact t1.debug_redact t2.debug_redact);
      	retention = (merge_retention t1.retention t2.retention);
      	targets = (merge_targets t1.targets t2.targets);
      	edition_defaults = (merge_edition_defaults t1.edition_defaults t2.edition_defaults);
      	features = (merge_features t1.features t2.features);
      	feature_support = (merge_feature_support t1.feature_support t2.feature_support);
      	uninterpreted_option = (merge_uninterpreted_option t1.uninterpreted_option t2.uninterpreted_option);
      	extensions' = (List.append t1.extensions' t2.extensions');
       }
      let spec () = Runtime'.Spec.( basic ((1, "ctype", "ctype"), (enum (module CType)), (CType.STRING)) ^:: basic_opt ((2, "packed", "packed"), bool) ^:: basic ((3, "deprecated", "deprecated"), bool, (false)) ^:: basic ((5, "lazy", "lazy"), bool, (false)) ^:: basic ((6, "jstype", "jstype"), (enum (module JSType)), (JSType.JS_NORMAL)) ^:: basic ((10, "weak", "weak"), bool, (false)) ^:: basic ((15, "unverified_lazy", "unverifiedLazy"), bool, (false)) ^:: basic ((16, "debug_redact", "debugRedact"), bool, (false)) ^:: basic_opt ((17, "retention", "retention"), (enum (module OptionRetention))) ^:: repeated ((19, "targets", "targets"), (enum (module OptionTargetType)), not_packed) ^:: repeated ((20, "edition_defaults", "editionDefaults"), (message (module EditionDefault)), not_packed) ^:: basic_opt ((21, "features", "features"), (message (module FeatureSet))) ^:: basic_opt ((22, "feature_support", "featureSupport"), (message (module FeatureSupport))) ^:: repeated ((999, "uninterpreted_option", "uninterpretedOption"), (message (module UninterpretedOption)), not_packed) ^:: nil_ext [ (1000, 536870912) ] )
      let to_proto' =
        let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
        fun writer { ctype; packed; deprecated; lazy'; jstype; weak; unverified_lazy; debug_redact; retention; targets; edition_defaults; features; feature_support; uninterpreted_option; extensions' } -> serialize writer ctype packed deprecated lazy' jstype weak unverified_lazy debug_redact retention targets edition_defaults features feature_support uninterpreted_option extensions'

      let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
      let from_proto_exn =
        let constructor ctype packed deprecated lazy' jstype weak unverified_lazy debug_redact retention targets edition_defaults features feature_support uninterpreted_option extensions' = { ctype; packed; deprecated; lazy'; jstype; weak; unverified_lazy; debug_redact; retention; targets; edition_defaults; features; feature_support; uninterpreted_option; extensions' } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
      let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
      let to_json options =
        let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
        fun { ctype; packed; deprecated; lazy'; jstype; weak; unverified_lazy; debug_redact; retention; targets; edition_defaults; features; feature_support; uninterpreted_option; extensions' } -> serialize ctype packed deprecated lazy' jstype weak unverified_lazy debug_redact retention targets edition_defaults features feature_support uninterpreted_option extensions'
      let from_json_exn =
        let constructor ctype packed deprecated lazy' jstype weak unverified_lazy debug_redact retention targets edition_defaults features feature_support uninterpreted_option extensions' = { ctype; packed; deprecated; lazy'; jstype; weak; unverified_lazy; debug_redact; retention; targets; edition_defaults; features; feature_support; uninterpreted_option; extensions' } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
      let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
    end

    and OneofOptions : sig
      type t = {
        features:FeatureSet.t option;
        (**
{%html:
<p>Any features defined in the specific edition.
WARNING: This field should only be used by protobuf plugins or special
cases like the proto compiler. Other uses are discouraged and
developers should rely on the protoreflect APIs for their client language.</p>
%}
        *)

        uninterpreted_option:UninterpretedOption.t list;
        (**
{%html:
<p>The parser stores options it doesn't recognize here. See above.</p>
%}
        *)

        extensions':Runtime'.Extensions.t;
      }
      val make: ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end = struct
      module This'_ = OneofOptions
      let name () = ".google.protobuf.OneofOptions"
      type t = {
        features:FeatureSet.t option;
        uninterpreted_option:UninterpretedOption.t list;
        extensions':Runtime'.Extensions.t;
      }
      type make_t = ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      let make ?features ?(uninterpreted_option = []) ?(extensions' = Runtime'.Extensions.default) () = { features; uninterpreted_option; extensions' }
      let merge =
      let merge_features = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((1, "features", "features"), (message (module FeatureSet))) ) in
      let merge_uninterpreted_option = Runtime'.Merge.merge Runtime'.Spec.( repeated ((999, "uninterpreted_option", "uninterpretedOption"), (message (module UninterpretedOption)), not_packed) ) in
      fun t1 t2 -> {
      	features = (merge_features t1.features t2.features);
      	uninterpreted_option = (merge_uninterpreted_option t1.uninterpreted_option t2.uninterpreted_option);
      	extensions' = (List.append t1.extensions' t2.extensions');
       }
      let spec () = Runtime'.Spec.( basic_opt ((1, "features", "features"), (message (module FeatureSet))) ^:: repeated ((999, "uninterpreted_option", "uninterpretedOption"), (message (module UninterpretedOption)), not_packed) ^:: nil_ext [ (1000, 536870912) ] )
      let to_proto' =
        let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
        fun writer { features; uninterpreted_option; extensions' } -> serialize writer features uninterpreted_option extensions'

      let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
      let from_proto_exn =
        let constructor features uninterpreted_option extensions' = { features; uninterpreted_option; extensions' } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
      let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
      let to_json options =
        let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
        fun { features; uninterpreted_option; extensions' } -> serialize features uninterpreted_option extensions'
      let from_json_exn =
        let constructor features uninterpreted_option extensions' = { features; uninterpreted_option; extensions' } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
      let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
    end

    and EnumOptions : sig
      type t = {
        allow_alias:bool option;
        (**
{%html:
<p>Set this option to true to allow mapping different tag names to the same
value.</p>
%}
        *)

        deprecated:bool;
        (**
{%html:
<p>Is this enum deprecated?
Depending on the target platform, this can emit Deprecated annotations
for the enum, or it will be completely ignored; in the very least, this
is a formalization for deprecating enums.</p>
%}
        *)

        deprecated_legacy_json_field_conflicts:bool option[@ocaml.alert protobuf "Marked as deprecated in the .proto file"];
        (**
{%html:
<p>Enable the legacy handling of JSON field name conflicts.  This lowercases
and strips underscored from the fields before comparison in proto3 only.
The new behavior takes <code>json_name</code> into account and applies to proto2 as
well.
TODO Remove this legacy behavior once downstream teams have
had time to migrate.</p>
%}
        *)

        features:FeatureSet.t option;
        (**
{%html:
<p>Any features defined in the specific edition.
WARNING: This field should only be used by protobuf plugins or special
cases like the proto compiler. Other uses are discouraged and
developers should rely on the protoreflect APIs for their client language.</p>
%}
        *)

        uninterpreted_option:UninterpretedOption.t list;
        (**
{%html:
<p>The parser stores options it doesn't recognize here. See above.</p>
%}
        *)

        extensions':Runtime'.Extensions.t;
      }
      val make: ?allow_alias:bool -> ?deprecated:bool -> ?deprecated_legacy_json_field_conflicts:bool -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?allow_alias:bool -> ?deprecated:bool -> ?deprecated_legacy_json_field_conflicts:bool -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end = struct
      module This'_ = EnumOptions
      let name () = ".google.protobuf.EnumOptions"
      type t = {
        allow_alias:bool option;
        deprecated:bool;
        deprecated_legacy_json_field_conflicts:bool option;
        features:FeatureSet.t option;
        uninterpreted_option:UninterpretedOption.t list;
        extensions':Runtime'.Extensions.t;
      }
      type make_t = ?allow_alias:bool -> ?deprecated:bool -> ?deprecated_legacy_json_field_conflicts:bool -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      let make ?allow_alias ?(deprecated = false) ?deprecated_legacy_json_field_conflicts ?features ?(uninterpreted_option = []) ?(extensions' = Runtime'.Extensions.default) () = { allow_alias; deprecated; deprecated_legacy_json_field_conflicts; features; uninterpreted_option; extensions' }
      let merge =
      let merge_allow_alias = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((2, "allow_alias", "allowAlias"), bool) ) in
      let merge_deprecated = Runtime'.Merge.merge Runtime'.Spec.( basic ((3, "deprecated", "deprecated"), bool, (false)) ) in
      let merge_deprecated_legacy_json_field_conflicts = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((6, "deprecated_legacy_json_field_conflicts", "deprecatedLegacyJsonFieldConflicts"), bool) ) in
      let merge_features = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((7, "features", "features"), (message (module FeatureSet))) ) in
      let merge_uninterpreted_option = Runtime'.Merge.merge Runtime'.Spec.( repeated ((999, "uninterpreted_option", "uninterpretedOption"), (message (module UninterpretedOption)), not_packed) ) in
      fun t1 t2 -> {
      	allow_alias = (merge_allow_alias t1.allow_alias t2.allow_alias);
      	deprecated = (merge_deprecated t1.deprecated t2.deprecated);
      	deprecated_legacy_json_field_conflicts = (merge_deprecated_legacy_json_field_conflicts t1.deprecated_legacy_json_field_conflicts t2.deprecated_legacy_json_field_conflicts);
      	features = (merge_features t1.features t2.features);
      	uninterpreted_option = (merge_uninterpreted_option t1.uninterpreted_option t2.uninterpreted_option);
      	extensions' = (List.append t1.extensions' t2.extensions');
       }
      let spec () = Runtime'.Spec.( basic_opt ((2, "allow_alias", "allowAlias"), bool) ^:: basic ((3, "deprecated", "deprecated"), bool, (false)) ^:: basic_opt ((6, "deprecated_legacy_json_field_conflicts", "deprecatedLegacyJsonFieldConflicts"), bool) ^:: basic_opt ((7, "features", "features"), (message (module FeatureSet))) ^:: repeated ((999, "uninterpreted_option", "uninterpretedOption"), (message (module UninterpretedOption)), not_packed) ^:: nil_ext [ (1000, 536870912) ] )
      let to_proto' =
        let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
        fun writer { allow_alias; deprecated; deprecated_legacy_json_field_conflicts; features; uninterpreted_option; extensions' } -> serialize writer allow_alias deprecated deprecated_legacy_json_field_conflicts features uninterpreted_option extensions'

      let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
      let from_proto_exn =
        let constructor allow_alias deprecated deprecated_legacy_json_field_conflicts features uninterpreted_option extensions' = { allow_alias; deprecated; deprecated_legacy_json_field_conflicts; features; uninterpreted_option; extensions' } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
      let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
      let to_json options =
        let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
        fun { allow_alias; deprecated; deprecated_legacy_json_field_conflicts; features; uninterpreted_option; extensions' } -> serialize allow_alias deprecated deprecated_legacy_json_field_conflicts features uninterpreted_option extensions'
      let from_json_exn =
        let constructor allow_alias deprecated deprecated_legacy_json_field_conflicts features uninterpreted_option extensions' = { allow_alias; deprecated; deprecated_legacy_json_field_conflicts; features; uninterpreted_option; extensions' } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
      let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
    end

    and EnumValueOptions : sig
      type t = {
        deprecated:bool;
        (**
{%html:
<p>Is this enum value deprecated?
Depending on the target platform, this can emit Deprecated annotations
for the enum value, or it will be completely ignored; in the very least,
this is a formalization for deprecating enum values.</p>
%}
        *)

        features:FeatureSet.t option;
        (**
{%html:
<p>Any features defined in the specific edition.
WARNING: This field should only be used by protobuf plugins or special
cases like the proto compiler. Other uses are discouraged and
developers should rely on the protoreflect APIs for their client language.</p>
%}
        *)

        debug_redact:bool;
        (**
{%html:
<p>Indicate that fields annotated with this enum value should not be printed
out when using debug formats, e.g. when the field contains sensitive
credentials.</p>
%}
        *)

        feature_support:FieldOptions.FeatureSupport.t option;
        (**
{%html:
<p>Information about the support window of a feature value.</p>
%}
        *)

        uninterpreted_option:UninterpretedOption.t list;
        (**
{%html:
<p>The parser stores options it doesn't recognize here. See above.</p>
%}
        *)

        extensions':Runtime'.Extensions.t;
      }
      val make: ?deprecated:bool -> ?features:FeatureSet.t -> ?debug_redact:bool -> ?feature_support:FieldOptions.FeatureSupport.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?deprecated:bool -> ?features:FeatureSet.t -> ?debug_redact:bool -> ?feature_support:FieldOptions.FeatureSupport.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end = struct
      module This'_ = EnumValueOptions
      let name () = ".google.protobuf.EnumValueOptions"
      type t = {
        deprecated:bool;
        features:FeatureSet.t option;
        debug_redact:bool;
        feature_support:FieldOptions.FeatureSupport.t option;
        uninterpreted_option:UninterpretedOption.t list;
        extensions':Runtime'.Extensions.t;
      }
      type make_t = ?deprecated:bool -> ?features:FeatureSet.t -> ?debug_redact:bool -> ?feature_support:FieldOptions.FeatureSupport.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      let make ?(deprecated = false) ?features ?(debug_redact = false) ?feature_support ?(uninterpreted_option = []) ?(extensions' = Runtime'.Extensions.default) () = { deprecated; features; debug_redact; feature_support; uninterpreted_option; extensions' }
      let merge =
      let merge_deprecated = Runtime'.Merge.merge Runtime'.Spec.( basic ((1, "deprecated", "deprecated"), bool, (false)) ) in
      let merge_features = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((2, "features", "features"), (message (module FeatureSet))) ) in
      let merge_debug_redact = Runtime'.Merge.merge Runtime'.Spec.( basic ((3, "debug_redact", "debugRedact"), bool, (false)) ) in
      let merge_feature_support = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((4, "feature_support", "featureSupport"), (message (module FieldOptions.FeatureSupport))) ) in
      let merge_uninterpreted_option = Runtime'.Merge.merge Runtime'.Spec.( repeated ((999, "uninterpreted_option", "uninterpretedOption"), (message (module UninterpretedOption)), not_packed) ) in
      fun t1 t2 -> {
      	deprecated = (merge_deprecated t1.deprecated t2.deprecated);
      	features = (merge_features t1.features t2.features);
      	debug_redact = (merge_debug_redact t1.debug_redact t2.debug_redact);
      	feature_support = (merge_feature_support t1.feature_support t2.feature_support);
      	uninterpreted_option = (merge_uninterpreted_option t1.uninterpreted_option t2.uninterpreted_option);
      	extensions' = (List.append t1.extensions' t2.extensions');
       }
      let spec () = Runtime'.Spec.( basic ((1, "deprecated", "deprecated"), bool, (false)) ^:: basic_opt ((2, "features", "features"), (message (module FeatureSet))) ^:: basic ((3, "debug_redact", "debugRedact"), bool, (false)) ^:: basic_opt ((4, "feature_support", "featureSupport"), (message (module FieldOptions.FeatureSupport))) ^:: repeated ((999, "uninterpreted_option", "uninterpretedOption"), (message (module UninterpretedOption)), not_packed) ^:: nil_ext [ (1000, 536870912) ] )
      let to_proto' =
        let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
        fun writer { deprecated; features; debug_redact; feature_support; uninterpreted_option; extensions' } -> serialize writer deprecated features debug_redact feature_support uninterpreted_option extensions'

      let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
      let from_proto_exn =
        let constructor deprecated features debug_redact feature_support uninterpreted_option extensions' = { deprecated; features; debug_redact; feature_support; uninterpreted_option; extensions' } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
      let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
      let to_json options =
        let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
        fun { deprecated; features; debug_redact; feature_support; uninterpreted_option; extensions' } -> serialize deprecated features debug_redact feature_support uninterpreted_option extensions'
      let from_json_exn =
        let constructor deprecated features debug_redact feature_support uninterpreted_option extensions' = { deprecated; features; debug_redact; feature_support; uninterpreted_option; extensions' } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
      let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
    end

    and ServiceOptions : sig
      type t = {
        deprecated:bool;
        (**
{%html:
<p>Is this service deprecated?
Depending on the target platform, this can emit Deprecated annotations
for the service, or it will be completely ignored; in the very least,
this is a formalization for deprecating services.</p>
<p>Note:  Field numbers 1 through 32 are reserved for Google's internal RPC</p>
<pre><code> framework.  We apologize for hoarding these numbers to ourselves, but
 we were already using them long before we decided to release Protocol
 Buffers.
</code></pre>
%}
        *)

        features:FeatureSet.t option;
        (**
{%html:
<p>Any features defined in the specific edition.
WARNING: This field should only be used by protobuf plugins or special
cases like the proto compiler. Other uses are discouraged and
developers should rely on the protoreflect APIs for their client language.</p>
%}
        *)

        uninterpreted_option:UninterpretedOption.t list;
        (**
{%html:
<p>The parser stores options it doesn't recognize here. See above.</p>
%}
        *)

        extensions':Runtime'.Extensions.t;
      }
      val make: ?deprecated:bool -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?deprecated:bool -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end = struct
      module This'_ = ServiceOptions
      let name () = ".google.protobuf.ServiceOptions"
      type t = {
        deprecated:bool;
        features:FeatureSet.t option;
        uninterpreted_option:UninterpretedOption.t list;
        extensions':Runtime'.Extensions.t;
      }
      type make_t = ?deprecated:bool -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      let make ?(deprecated = false) ?features ?(uninterpreted_option = []) ?(extensions' = Runtime'.Extensions.default) () = { deprecated; features; uninterpreted_option; extensions' }
      let merge =
      let merge_deprecated = Runtime'.Merge.merge Runtime'.Spec.( basic ((33, "deprecated", "deprecated"), bool, (false)) ) in
      let merge_features = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((34, "features", "features"), (message (module FeatureSet))) ) in
      let merge_uninterpreted_option = Runtime'.Merge.merge Runtime'.Spec.( repeated ((999, "uninterpreted_option", "uninterpretedOption"), (message (module UninterpretedOption)), not_packed) ) in
      fun t1 t2 -> {
      	deprecated = (merge_deprecated t1.deprecated t2.deprecated);
      	features = (merge_features t1.features t2.features);
      	uninterpreted_option = (merge_uninterpreted_option t1.uninterpreted_option t2.uninterpreted_option);
      	extensions' = (List.append t1.extensions' t2.extensions');
       }
      let spec () = Runtime'.Spec.( basic ((33, "deprecated", "deprecated"), bool, (false)) ^:: basic_opt ((34, "features", "features"), (message (module FeatureSet))) ^:: repeated ((999, "uninterpreted_option", "uninterpretedOption"), (message (module UninterpretedOption)), not_packed) ^:: nil_ext [ (1000, 536870912) ] )
      let to_proto' =
        let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
        fun writer { deprecated; features; uninterpreted_option; extensions' } -> serialize writer deprecated features uninterpreted_option extensions'

      let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
      let from_proto_exn =
        let constructor deprecated features uninterpreted_option extensions' = { deprecated; features; uninterpreted_option; extensions' } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
      let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
      let to_json options =
        let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
        fun { deprecated; features; uninterpreted_option; extensions' } -> serialize deprecated features uninterpreted_option extensions'
      let from_json_exn =
        let constructor deprecated features uninterpreted_option extensions' = { deprecated; features; uninterpreted_option; extensions' } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
      let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
    end

    and MethodOptions : sig

      (**
{%html:
<p>Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
or neither? HTTP based RPC implementation may choose GET verb for safe
methods, and PUT verb for idempotent methods instead of the default POST.</p>
%}
      *)
      module rec IdempotencyLevel : sig
        type t =
          | IDEMPOTENCY_UNKNOWN
          | NO_SIDE_EFFECTS
          (**
{%html:
<p>implies idempotent</p>
%}
          *)

          | IDEMPOTENT
          (**
{%html:
<p>idempotent, but may have side effects</p>
%}
          *)


        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      type t = {
        deprecated:bool;
        (**
{%html:
<p>Is this method deprecated?
Depending on the target platform, this can emit Deprecated annotations
for the method, or it will be completely ignored; in the very least,
this is a formalization for deprecating methods.</p>
<p>Note:  Field numbers 1 through 32 are reserved for Google's internal RPC</p>
<pre><code> framework.  We apologize for hoarding these numbers to ourselves, but
 we were already using them long before we decided to release Protocol
 Buffers.
</code></pre>
%}
        *)

        idempotency_level:IdempotencyLevel.t;
        features:FeatureSet.t option;
        (**
{%html:
<p>Any features defined in the specific edition.
WARNING: This field should only be used by protobuf plugins or special
cases like the proto compiler. Other uses are discouraged and
developers should rely on the protoreflect APIs for their client language.</p>
%}
        *)

        uninterpreted_option:UninterpretedOption.t list;
        (**
{%html:
<p>The parser stores options it doesn't recognize here. See above.</p>
%}
        *)

        extensions':Runtime'.Extensions.t;
      }
      val make: ?deprecated:bool -> ?idempotency_level:IdempotencyLevel.t -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?deprecated:bool -> ?idempotency_level:IdempotencyLevel.t -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end = struct
      module This'_ = MethodOptions
      module rec IdempotencyLevel : sig
        type t =
          | IDEMPOTENCY_UNKNOWN
          | NO_SIDE_EFFECTS
          (**
{%html:
<p>implies idempotent</p>
%}
          *)

          | IDEMPOTENT
          (**
{%html:
<p>idempotent, but may have side effects</p>
%}
          *)


        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end = struct
        module This'_ = IdempotencyLevel
        type t =
          | IDEMPOTENCY_UNKNOWN
          | NO_SIDE_EFFECTS
          (**
{%html:
<p>implies idempotent</p>
%}
          *)

          | IDEMPOTENT
          (**
{%html:
<p>idempotent, but may have side effects</p>
%}
          *)


        let name () = ".google.protobuf.MethodOptions.IdempotencyLevel"
        let to_int = function
          | IDEMPOTENCY_UNKNOWN -> 0
          | NO_SIDE_EFFECTS -> 1
          | IDEMPOTENT -> 2
        let from_int_exn = function
          | 0 -> IDEMPOTENCY_UNKNOWN
          | 1 -> NO_SIDE_EFFECTS
          | 2 -> IDEMPOTENT
          | n -> Runtime'.Result.raise (`Unknown_enum_value n)
        let from_int e = Runtime'.Result.catch (fun () -> from_int_exn e)
        let to_string = function
          | IDEMPOTENCY_UNKNOWN -> "IDEMPOTENCY_UNKNOWN"
          | NO_SIDE_EFFECTS -> "NO_SIDE_EFFECTS"
          | IDEMPOTENT -> "IDEMPOTENT"
        let from_string_exn = function
          | "IDEMPOTENCY_UNKNOWN" -> IDEMPOTENCY_UNKNOWN
          | "NO_SIDE_EFFECTS" -> NO_SIDE_EFFECTS
          | "IDEMPOTENT" -> IDEMPOTENT
          | s -> Runtime'.Result.raise (`Unknown_enum_name s)

      end

      let name () = ".google.protobuf.MethodOptions"
      type t = {
        deprecated:bool;
        idempotency_level:IdempotencyLevel.t;
        features:FeatureSet.t option;
        uninterpreted_option:UninterpretedOption.t list;
        extensions':Runtime'.Extensions.t;
      }
      type make_t = ?deprecated:bool -> ?idempotency_level:IdempotencyLevel.t -> ?features:FeatureSet.t -> ?uninterpreted_option:UninterpretedOption.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      let make ?(deprecated = false) ?(idempotency_level = IdempotencyLevel.IDEMPOTENCY_UNKNOWN) ?features ?(uninterpreted_option = []) ?(extensions' = Runtime'.Extensions.default) () = { deprecated; idempotency_level; features; uninterpreted_option; extensions' }
      let merge =
      let merge_deprecated = Runtime'.Merge.merge Runtime'.Spec.( basic ((33, "deprecated", "deprecated"), bool, (false)) ) in
      let merge_idempotency_level = Runtime'.Merge.merge Runtime'.Spec.( basic ((34, "idempotency_level", "idempotencyLevel"), (enum (module IdempotencyLevel)), (IdempotencyLevel.IDEMPOTENCY_UNKNOWN)) ) in
      let merge_features = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((35, "features", "features"), (message (module FeatureSet))) ) in
      let merge_uninterpreted_option = Runtime'.Merge.merge Runtime'.Spec.( repeated ((999, "uninterpreted_option", "uninterpretedOption"), (message (module UninterpretedOption)), not_packed) ) in
      fun t1 t2 -> {
      	deprecated = (merge_deprecated t1.deprecated t2.deprecated);
      	idempotency_level = (merge_idempotency_level t1.idempotency_level t2.idempotency_level);
      	features = (merge_features t1.features t2.features);
      	uninterpreted_option = (merge_uninterpreted_option t1.uninterpreted_option t2.uninterpreted_option);
      	extensions' = (List.append t1.extensions' t2.extensions');
       }
      let spec () = Runtime'.Spec.( basic ((33, "deprecated", "deprecated"), bool, (false)) ^:: basic ((34, "idempotency_level", "idempotencyLevel"), (enum (module IdempotencyLevel)), (IdempotencyLevel.IDEMPOTENCY_UNKNOWN)) ^:: basic_opt ((35, "features", "features"), (message (module FeatureSet))) ^:: repeated ((999, "uninterpreted_option", "uninterpretedOption"), (message (module UninterpretedOption)), not_packed) ^:: nil_ext [ (1000, 536870912) ] )
      let to_proto' =
        let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
        fun writer { deprecated; idempotency_level; features; uninterpreted_option; extensions' } -> serialize writer deprecated idempotency_level features uninterpreted_option extensions'

      let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
      let from_proto_exn =
        let constructor deprecated idempotency_level features uninterpreted_option extensions' = { deprecated; idempotency_level; features; uninterpreted_option; extensions' } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
      let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
      let to_json options =
        let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
        fun { deprecated; idempotency_level; features; uninterpreted_option; extensions' } -> serialize deprecated idempotency_level features uninterpreted_option extensions'
      let from_json_exn =
        let constructor deprecated idempotency_level features uninterpreted_option extensions' = { deprecated; idempotency_level; features; uninterpreted_option; extensions' } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
      let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
    end

    and UninterpretedOption : sig

      (**
{%html:
<p>The name of the uninterpreted option.  Each string represents a segment in
a dot-separated name.  is_extension is true iff a segment represents an
extension (denoted with parentheses in options specs in .proto files).
E.g.,{ [&quot;foo&quot;, false], [&quot;bar.baz&quot;, true], [&quot;moo&quot;, false] } represents
&quot;foo.(bar.baz).moo&quot;.</p>
%}
      *)
      module rec NamePart : sig
        type t = {
          name_part:string;
          is_extension:bool;
        }
        val make: name_part:string -> is_extension:bool -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = name_part:string -> is_extension:bool -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end

      type t = {
        name:NamePart.t list;
        identifier_value:string option;
        (**
{%html:
<p>The value of the uninterpreted option, in whatever type the tokenizer
identified it as during parsing. Exactly one of these should be set.</p>
%}
        *)

        positive_int_value:int option;
        negative_int_value:int option;
        double_value:float option;
        string_value:bytes option;
        aggregate_value:string option;
      }
      val make: ?name:NamePart.t list -> ?identifier_value:string -> ?positive_int_value:int -> ?negative_int_value:int -> ?double_value:float -> ?string_value:bytes -> ?aggregate_value:string -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?name:NamePart.t list -> ?identifier_value:string -> ?positive_int_value:int -> ?negative_int_value:int -> ?double_value:float -> ?string_value:bytes -> ?aggregate_value:string -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end = struct
      module This'_ = UninterpretedOption
      module rec NamePart : sig
        type t = {
          name_part:string;
          is_extension:bool;
        }
        val make: name_part:string -> is_extension:bool -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = name_part:string -> is_extension:bool -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end = struct
        module This'_ = NamePart
        let name () = ".google.protobuf.UninterpretedOption.NamePart"
        type t = {
          name_part:string;
          is_extension:bool;
        }
        type make_t = name_part:string -> is_extension:bool -> unit -> t
        let make ~name_part ~is_extension () = { name_part; is_extension }
        let merge =
        let merge_name_part = Runtime'.Merge.merge Runtime'.Spec.( basic_req ((1, "name_part", "namePart"), string) ) in
        let merge_is_extension = Runtime'.Merge.merge Runtime'.Spec.( basic_req ((2, "is_extension", "isExtension"), bool) ) in
        fun t1 t2 -> {
        	name_part = (merge_name_part t1.name_part t2.name_part);
        	is_extension = (merge_is_extension t1.is_extension t2.is_extension);
         }
        let spec () = Runtime'.Spec.( basic_req ((1, "name_part", "namePart"), string) ^:: basic_req ((2, "is_extension", "isExtension"), bool) ^:: nil )
        let to_proto' =
          let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
          fun writer { name_part; is_extension } -> serialize writer name_part is_extension

        let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
        let from_proto_exn =
          let constructor name_part is_extension = { name_part; is_extension } in
          Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
        let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
        let to_json options =
          let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
          fun { name_part; is_extension } -> serialize name_part is_extension
        let from_json_exn =
          let constructor name_part is_extension = { name_part; is_extension } in
          Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
        let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
      end

      let name () = ".google.protobuf.UninterpretedOption"
      type t = {
        name:NamePart.t list;
        identifier_value:string option;
        positive_int_value:int option;
        negative_int_value:int option;
        double_value:float option;
        string_value:bytes option;
        aggregate_value:string option;
      }
      type make_t = ?name:NamePart.t list -> ?identifier_value:string -> ?positive_int_value:int -> ?negative_int_value:int -> ?double_value:float -> ?string_value:bytes -> ?aggregate_value:string -> unit -> t
      let make ?(name = []) ?identifier_value ?positive_int_value ?negative_int_value ?double_value ?string_value ?aggregate_value () = { name; identifier_value; positive_int_value; negative_int_value; double_value; string_value; aggregate_value }
      let merge =
      let merge_name = Runtime'.Merge.merge Runtime'.Spec.( repeated ((2, "name", "name"), (message (module NamePart)), not_packed) ) in
      let merge_identifier_value = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((3, "identifier_value", "identifierValue"), string) ) in
      let merge_positive_int_value = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((4, "positive_int_value", "positiveIntValue"), uint64_int) ) in
      let merge_negative_int_value = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((5, "negative_int_value", "negativeIntValue"), int64_int) ) in
      let merge_double_value = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((6, "double_value", "doubleValue"), double) ) in
      let merge_string_value = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((7, "string_value", "stringValue"), bytes) ) in
      let merge_aggregate_value = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((8, "aggregate_value", "aggregateValue"), string) ) in
      fun t1 t2 -> {
      	name = (merge_name t1.name t2.name);
      	identifier_value = (merge_identifier_value t1.identifier_value t2.identifier_value);
      	positive_int_value = (merge_positive_int_value t1.positive_int_value t2.positive_int_value);
      	negative_int_value = (merge_negative_int_value t1.negative_int_value t2.negative_int_value);
      	double_value = (merge_double_value t1.double_value t2.double_value);
      	string_value = (merge_string_value t1.string_value t2.string_value);
      	aggregate_value = (merge_aggregate_value t1.aggregate_value t2.aggregate_value);
       }
      let spec () = Runtime'.Spec.( repeated ((2, "name", "name"), (message (module NamePart)), not_packed) ^:: basic_opt ((3, "identifier_value", "identifierValue"), string) ^:: basic_opt ((4, "positive_int_value", "positiveIntValue"), uint64_int) ^:: basic_opt ((5, "negative_int_value", "negativeIntValue"), int64_int) ^:: basic_opt ((6, "double_value", "doubleValue"), double) ^:: basic_opt ((7, "string_value", "stringValue"), bytes) ^:: basic_opt ((8, "aggregate_value", "aggregateValue"), string) ^:: nil )
      let to_proto' =
        let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
        fun writer { name; identifier_value; positive_int_value; negative_int_value; double_value; string_value; aggregate_value } -> serialize writer name identifier_value positive_int_value negative_int_value double_value string_value aggregate_value

      let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
      let from_proto_exn =
        let constructor name identifier_value positive_int_value negative_int_value double_value string_value aggregate_value = { name; identifier_value; positive_int_value; negative_int_value; double_value; string_value; aggregate_value } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
      let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
      let to_json options =
        let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
        fun { name; identifier_value; positive_int_value; negative_int_value; double_value; string_value; aggregate_value } -> serialize name identifier_value positive_int_value negative_int_value double_value string_value aggregate_value
      let from_json_exn =
        let constructor name identifier_value positive_int_value negative_int_value double_value string_value aggregate_value = { name; identifier_value; positive_int_value; negative_int_value; double_value; string_value; aggregate_value } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
      let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
    end

    and FeatureSet : sig
      module rec FieldPresence : sig
        type t =
          | FIELD_PRESENCE_UNKNOWN
          | EXPLICIT
          | IMPLICIT
          | LEGACY_REQUIRED

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      and EnumType : sig
        type t =
          | ENUM_TYPE_UNKNOWN
          | OPEN
          | CLOSED

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      and RepeatedFieldEncoding : sig
        type t =
          | REPEATED_FIELD_ENCODING_UNKNOWN
          | PACKED
          | EXPANDED

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      and Utf8Validation : sig
        type t =
          | UTF8_VALIDATION_UNKNOWN
          | VERIFY
          | NONE

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      and MessageEncoding : sig
        type t =
          | MESSAGE_ENCODING_UNKNOWN
          | LENGTH_PREFIXED
          | DELIMITED

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      and JsonFormat : sig
        type t =
          | JSON_FORMAT_UNKNOWN
          | ALLOW
          | LEGACY_BEST_EFFORT

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      and EnforceNamingStyle : sig
        type t =
          | ENFORCE_NAMING_STYLE_UNKNOWN
          | STYLE2024
          | STYLE_LEGACY

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end

      and VisibilityFeature : sig
        module rec DefaultSymbolVisibility : sig
          type t =
            | DEFAULT_SYMBOL_VISIBILITY_UNKNOWN
            | EXPORT_ALL
            (**
{%html:
<p>Default pre-EDITION_2024, all UNSET visibility are export.</p>
%}
            *)

            | EXPORT_TOP_LEVEL
            (**
{%html:
<p>All top-level symbols default to export, nested default to local.</p>
%}
            *)

            | LOCAL_ALL
            (**
{%html:
<p>All symbols default to local.</p>
%}
            *)

            | STRICT
            (**
{%html:
<p>All symbols local by default. Nested types cannot be exported.
With special case caveat for message { enum {} reserved 1 to max; }
This is the recommended setting for new protos.</p>
%}
            *)


          val name: unit -> string
          (** Fully qualified protobuf name of this enum *)

          (**/**)
          val to_int: t -> int
          val from_int: int -> t Runtime'.Result.t
          val from_int_exn: int -> t
          val to_string: t -> string
          val from_string_exn: string -> t
          (**/**)
        end

        type t = unit
        val make: unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end

      type t = {
        field_presence:FieldPresence.t option;
        enum_type:EnumType.t option;
        repeated_field_encoding:RepeatedFieldEncoding.t option;
        utf8_validation:Utf8Validation.t option;
        message_encoding:MessageEncoding.t option;
        json_format:JsonFormat.t option;
        (**
{%html:
<p>for https://github.com/bufbuild/protobuf-es</p>
%}
        *)

        enforce_naming_style:EnforceNamingStyle.t option;
        default_symbol_visibility:VisibilityFeature.DefaultSymbolVisibility.t option;
        extensions':Runtime'.Extensions.t;
      }
      val make: ?field_presence:FieldPresence.t -> ?enum_type:EnumType.t -> ?repeated_field_encoding:RepeatedFieldEncoding.t -> ?utf8_validation:Utf8Validation.t -> ?message_encoding:MessageEncoding.t -> ?json_format:JsonFormat.t -> ?enforce_naming_style:EnforceNamingStyle.t -> ?default_symbol_visibility:VisibilityFeature.DefaultSymbolVisibility.t -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?field_presence:FieldPresence.t -> ?enum_type:EnumType.t -> ?repeated_field_encoding:RepeatedFieldEncoding.t -> ?utf8_validation:Utf8Validation.t -> ?message_encoding:MessageEncoding.t -> ?json_format:JsonFormat.t -> ?enforce_naming_style:EnforceNamingStyle.t -> ?default_symbol_visibility:VisibilityFeature.DefaultSymbolVisibility.t -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end = struct
      module This'_ = FeatureSet
      module rec FieldPresence : sig
        type t =
          | FIELD_PRESENCE_UNKNOWN
          | EXPLICIT
          | IMPLICIT
          | LEGACY_REQUIRED

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end = struct
        module This'_ = FieldPresence
        type t =
          | FIELD_PRESENCE_UNKNOWN
          | EXPLICIT
          | IMPLICIT
          | LEGACY_REQUIRED

        let name () = ".google.protobuf.FeatureSet.FieldPresence"
        let to_int = function
          | FIELD_PRESENCE_UNKNOWN -> 0
          | EXPLICIT -> 1
          | IMPLICIT -> 2
          | LEGACY_REQUIRED -> 3
        let from_int_exn = function
          | 0 -> FIELD_PRESENCE_UNKNOWN
          | 1 -> EXPLICIT
          | 2 -> IMPLICIT
          | 3 -> LEGACY_REQUIRED
          | n -> Runtime'.Result.raise (`Unknown_enum_value n)
        let from_int e = Runtime'.Result.catch (fun () -> from_int_exn e)
        let to_string = function
          | FIELD_PRESENCE_UNKNOWN -> "FIELD_PRESENCE_UNKNOWN"
          | EXPLICIT -> "EXPLICIT"
          | IMPLICIT -> "IMPLICIT"
          | LEGACY_REQUIRED -> "LEGACY_REQUIRED"
        let from_string_exn = function
          | "FIELD_PRESENCE_UNKNOWN" -> FIELD_PRESENCE_UNKNOWN
          | "EXPLICIT" -> EXPLICIT
          | "IMPLICIT" -> IMPLICIT
          | "LEGACY_REQUIRED" -> LEGACY_REQUIRED
          | s -> Runtime'.Result.raise (`Unknown_enum_name s)

      end

      and EnumType : sig
        type t =
          | ENUM_TYPE_UNKNOWN
          | OPEN
          | CLOSED

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end = struct
        module This'_ = EnumType
        type t =
          | ENUM_TYPE_UNKNOWN
          | OPEN
          | CLOSED

        let name () = ".google.protobuf.FeatureSet.EnumType"
        let to_int = function
          | ENUM_TYPE_UNKNOWN -> 0
          | OPEN -> 1
          | CLOSED -> 2
        let from_int_exn = function
          | 0 -> ENUM_TYPE_UNKNOWN
          | 1 -> OPEN
          | 2 -> CLOSED
          | n -> Runtime'.Result.raise (`Unknown_enum_value n)
        let from_int e = Runtime'.Result.catch (fun () -> from_int_exn e)
        let to_string = function
          | ENUM_TYPE_UNKNOWN -> "ENUM_TYPE_UNKNOWN"
          | OPEN -> "OPEN"
          | CLOSED -> "CLOSED"
        let from_string_exn = function
          | "ENUM_TYPE_UNKNOWN" -> ENUM_TYPE_UNKNOWN
          | "OPEN" -> OPEN
          | "CLOSED" -> CLOSED
          | s -> Runtime'.Result.raise (`Unknown_enum_name s)

      end

      and RepeatedFieldEncoding : sig
        type t =
          | REPEATED_FIELD_ENCODING_UNKNOWN
          | PACKED
          | EXPANDED

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end = struct
        module This'_ = RepeatedFieldEncoding
        type t =
          | REPEATED_FIELD_ENCODING_UNKNOWN
          | PACKED
          | EXPANDED

        let name () = ".google.protobuf.FeatureSet.RepeatedFieldEncoding"
        let to_int = function
          | REPEATED_FIELD_ENCODING_UNKNOWN -> 0
          | PACKED -> 1
          | EXPANDED -> 2
        let from_int_exn = function
          | 0 -> REPEATED_FIELD_ENCODING_UNKNOWN
          | 1 -> PACKED
          | 2 -> EXPANDED
          | n -> Runtime'.Result.raise (`Unknown_enum_value n)
        let from_int e = Runtime'.Result.catch (fun () -> from_int_exn e)
        let to_string = function
          | REPEATED_FIELD_ENCODING_UNKNOWN -> "REPEATED_FIELD_ENCODING_UNKNOWN"
          | PACKED -> "PACKED"
          | EXPANDED -> "EXPANDED"
        let from_string_exn = function
          | "REPEATED_FIELD_ENCODING_UNKNOWN" -> REPEATED_FIELD_ENCODING_UNKNOWN
          | "PACKED" -> PACKED
          | "EXPANDED" -> EXPANDED
          | s -> Runtime'.Result.raise (`Unknown_enum_name s)

      end

      and Utf8Validation : sig
        type t =
          | UTF8_VALIDATION_UNKNOWN
          | VERIFY
          | NONE

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end = struct
        module This'_ = Utf8Validation
        type t =
          | UTF8_VALIDATION_UNKNOWN
          | VERIFY
          | NONE

        let name () = ".google.protobuf.FeatureSet.Utf8Validation"
        let to_int = function
          | UTF8_VALIDATION_UNKNOWN -> 0
          | VERIFY -> 2
          | NONE -> 3
        let from_int_exn = function
          | 0 -> UTF8_VALIDATION_UNKNOWN
          | 2 -> VERIFY
          | 3 -> NONE
          | n -> Runtime'.Result.raise (`Unknown_enum_value n)
        let from_int e = Runtime'.Result.catch (fun () -> from_int_exn e)
        let to_string = function
          | UTF8_VALIDATION_UNKNOWN -> "UTF8_VALIDATION_UNKNOWN"
          | VERIFY -> "VERIFY"
          | NONE -> "NONE"
        let from_string_exn = function
          | "UTF8_VALIDATION_UNKNOWN" -> UTF8_VALIDATION_UNKNOWN
          | "VERIFY" -> VERIFY
          | "NONE" -> NONE
          | s -> Runtime'.Result.raise (`Unknown_enum_name s)

      end

      and MessageEncoding : sig
        type t =
          | MESSAGE_ENCODING_UNKNOWN
          | LENGTH_PREFIXED
          | DELIMITED

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end = struct
        module This'_ = MessageEncoding
        type t =
          | MESSAGE_ENCODING_UNKNOWN
          | LENGTH_PREFIXED
          | DELIMITED

        let name () = ".google.protobuf.FeatureSet.MessageEncoding"
        let to_int = function
          | MESSAGE_ENCODING_UNKNOWN -> 0
          | LENGTH_PREFIXED -> 1
          | DELIMITED -> 2
        let from_int_exn = function
          | 0 -> MESSAGE_ENCODING_UNKNOWN
          | 1 -> LENGTH_PREFIXED
          | 2 -> DELIMITED
          | n -> Runtime'.Result.raise (`Unknown_enum_value n)
        let from_int e = Runtime'.Result.catch (fun () -> from_int_exn e)
        let to_string = function
          | MESSAGE_ENCODING_UNKNOWN -> "MESSAGE_ENCODING_UNKNOWN"
          | LENGTH_PREFIXED -> "LENGTH_PREFIXED"
          | DELIMITED -> "DELIMITED"
        let from_string_exn = function
          | "MESSAGE_ENCODING_UNKNOWN" -> MESSAGE_ENCODING_UNKNOWN
          | "LENGTH_PREFIXED" -> LENGTH_PREFIXED
          | "DELIMITED" -> DELIMITED
          | s -> Runtime'.Result.raise (`Unknown_enum_name s)

      end

      and JsonFormat : sig
        type t =
          | JSON_FORMAT_UNKNOWN
          | ALLOW
          | LEGACY_BEST_EFFORT

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end = struct
        module This'_ = JsonFormat
        type t =
          | JSON_FORMAT_UNKNOWN
          | ALLOW
          | LEGACY_BEST_EFFORT

        let name () = ".google.protobuf.FeatureSet.JsonFormat"
        let to_int = function
          | JSON_FORMAT_UNKNOWN -> 0
          | ALLOW -> 1
          | LEGACY_BEST_EFFORT -> 2
        let from_int_exn = function
          | 0 -> JSON_FORMAT_UNKNOWN
          | 1 -> ALLOW
          | 2 -> LEGACY_BEST_EFFORT
          | n -> Runtime'.Result.raise (`Unknown_enum_value n)
        let from_int e = Runtime'.Result.catch (fun () -> from_int_exn e)
        let to_string = function
          | JSON_FORMAT_UNKNOWN -> "JSON_FORMAT_UNKNOWN"
          | ALLOW -> "ALLOW"
          | LEGACY_BEST_EFFORT -> "LEGACY_BEST_EFFORT"
        let from_string_exn = function
          | "JSON_FORMAT_UNKNOWN" -> JSON_FORMAT_UNKNOWN
          | "ALLOW" -> ALLOW
          | "LEGACY_BEST_EFFORT" -> LEGACY_BEST_EFFORT
          | s -> Runtime'.Result.raise (`Unknown_enum_name s)

      end

      and EnforceNamingStyle : sig
        type t =
          | ENFORCE_NAMING_STYLE_UNKNOWN
          | STYLE2024
          | STYLE_LEGACY

        val name: unit -> string
        (** Fully qualified protobuf name of this enum *)

        (**/**)
        val to_int: t -> int
        val from_int: int -> t Runtime'.Result.t
        val from_int_exn: int -> t
        val to_string: t -> string
        val from_string_exn: string -> t
        (**/**)
      end = struct
        module This'_ = EnforceNamingStyle
        type t =
          | ENFORCE_NAMING_STYLE_UNKNOWN
          | STYLE2024
          | STYLE_LEGACY

        let name () = ".google.protobuf.FeatureSet.EnforceNamingStyle"
        let to_int = function
          | ENFORCE_NAMING_STYLE_UNKNOWN -> 0
          | STYLE2024 -> 1
          | STYLE_LEGACY -> 2
        let from_int_exn = function
          | 0 -> ENFORCE_NAMING_STYLE_UNKNOWN
          | 1 -> STYLE2024
          | 2 -> STYLE_LEGACY
          | n -> Runtime'.Result.raise (`Unknown_enum_value n)
        let from_int e = Runtime'.Result.catch (fun () -> from_int_exn e)
        let to_string = function
          | ENFORCE_NAMING_STYLE_UNKNOWN -> "ENFORCE_NAMING_STYLE_UNKNOWN"
          | STYLE2024 -> "STYLE2024"
          | STYLE_LEGACY -> "STYLE_LEGACY"
        let from_string_exn = function
          | "ENFORCE_NAMING_STYLE_UNKNOWN" -> ENFORCE_NAMING_STYLE_UNKNOWN
          | "STYLE2024" -> STYLE2024
          | "STYLE_LEGACY" -> STYLE_LEGACY
          | s -> Runtime'.Result.raise (`Unknown_enum_name s)

      end

      and VisibilityFeature : sig
        module rec DefaultSymbolVisibility : sig
          type t =
            | DEFAULT_SYMBOL_VISIBILITY_UNKNOWN
            | EXPORT_ALL
            (**
{%html:
<p>Default pre-EDITION_2024, all UNSET visibility are export.</p>
%}
            *)

            | EXPORT_TOP_LEVEL
            (**
{%html:
<p>All top-level symbols default to export, nested default to local.</p>
%}
            *)

            | LOCAL_ALL
            (**
{%html:
<p>All symbols default to local.</p>
%}
            *)

            | STRICT
            (**
{%html:
<p>All symbols local by default. Nested types cannot be exported.
With special case caveat for message { enum {} reserved 1 to max; }
This is the recommended setting for new protos.</p>
%}
            *)


          val name: unit -> string
          (** Fully qualified protobuf name of this enum *)

          (**/**)
          val to_int: t -> int
          val from_int: int -> t Runtime'.Result.t
          val from_int_exn: int -> t
          val to_string: t -> string
          val from_string_exn: string -> t
          (**/**)
        end

        type t = unit
        val make: unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end = struct
        module This'_ = VisibilityFeature
        module rec DefaultSymbolVisibility : sig
          type t =
            | DEFAULT_SYMBOL_VISIBILITY_UNKNOWN
            | EXPORT_ALL
            (**
{%html:
<p>Default pre-EDITION_2024, all UNSET visibility are export.</p>
%}
            *)

            | EXPORT_TOP_LEVEL
            (**
{%html:
<p>All top-level symbols default to export, nested default to local.</p>
%}
            *)

            | LOCAL_ALL
            (**
{%html:
<p>All symbols default to local.</p>
%}
            *)

            | STRICT
            (**
{%html:
<p>All symbols local by default. Nested types cannot be exported.
With special case caveat for message { enum {} reserved 1 to max; }
This is the recommended setting for new protos.</p>
%}
            *)


          val name: unit -> string
          (** Fully qualified protobuf name of this enum *)

          (**/**)
          val to_int: t -> int
          val from_int: int -> t Runtime'.Result.t
          val from_int_exn: int -> t
          val to_string: t -> string
          val from_string_exn: string -> t
          (**/**)
        end = struct
          module This'_ = DefaultSymbolVisibility
          type t =
            | DEFAULT_SYMBOL_VISIBILITY_UNKNOWN
            | EXPORT_ALL
            (**
{%html:
<p>Default pre-EDITION_2024, all UNSET visibility are export.</p>
%}
            *)

            | EXPORT_TOP_LEVEL
            (**
{%html:
<p>All top-level symbols default to export, nested default to local.</p>
%}
            *)

            | LOCAL_ALL
            (**
{%html:
<p>All symbols default to local.</p>
%}
            *)

            | STRICT
            (**
{%html:
<p>All symbols local by default. Nested types cannot be exported.
With special case caveat for message { enum {} reserved 1 to max; }
This is the recommended setting for new protos.</p>
%}
            *)


          let name () = ".google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibility"
          let to_int = function
            | DEFAULT_SYMBOL_VISIBILITY_UNKNOWN -> 0
            | EXPORT_ALL -> 1
            | EXPORT_TOP_LEVEL -> 2
            | LOCAL_ALL -> 3
            | STRICT -> 4
          let from_int_exn = function
            | 0 -> DEFAULT_SYMBOL_VISIBILITY_UNKNOWN
            | 1 -> EXPORT_ALL
            | 2 -> EXPORT_TOP_LEVEL
            | 3 -> LOCAL_ALL
            | 4 -> STRICT
            | n -> Runtime'.Result.raise (`Unknown_enum_value n)
          let from_int e = Runtime'.Result.catch (fun () -> from_int_exn e)
          let to_string = function
            | DEFAULT_SYMBOL_VISIBILITY_UNKNOWN -> "DEFAULT_SYMBOL_VISIBILITY_UNKNOWN"
            | EXPORT_ALL -> "EXPORT_ALL"
            | EXPORT_TOP_LEVEL -> "EXPORT_TOP_LEVEL"
            | LOCAL_ALL -> "LOCAL_ALL"
            | STRICT -> "STRICT"
          let from_string_exn = function
            | "DEFAULT_SYMBOL_VISIBILITY_UNKNOWN" -> DEFAULT_SYMBOL_VISIBILITY_UNKNOWN
            | "EXPORT_ALL" -> EXPORT_ALL
            | "EXPORT_TOP_LEVEL" -> EXPORT_TOP_LEVEL
            | "LOCAL_ALL" -> LOCAL_ALL
            | "STRICT" -> STRICT
            | s -> Runtime'.Result.raise (`Unknown_enum_name s)

        end

        let name () = ".google.protobuf.FeatureSet.VisibilityFeature"
        type t = unit
        type make_t = unit -> t
        let make () = ()
        let merge =

        fun () () -> ()
        let spec () = Runtime'.Spec.( nil )
        let to_proto' =
          let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
          fun writer () -> serialize writer

        let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
        let from_proto_exn =
          let constructor  = () in
          Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
        let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
        let to_json options =
          let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
          fun () -> serialize
        let from_json_exn =
          let constructor  = () in
          Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
        let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
      end

      let name () = ".google.protobuf.FeatureSet"
      type t = {
        field_presence:FieldPresence.t option;
        enum_type:EnumType.t option;
        repeated_field_encoding:RepeatedFieldEncoding.t option;
        utf8_validation:Utf8Validation.t option;
        message_encoding:MessageEncoding.t option;
        json_format:JsonFormat.t option;
        enforce_naming_style:EnforceNamingStyle.t option;
        default_symbol_visibility:VisibilityFeature.DefaultSymbolVisibility.t option;
        extensions':Runtime'.Extensions.t;
      }
      type make_t = ?field_presence:FieldPresence.t -> ?enum_type:EnumType.t -> ?repeated_field_encoding:RepeatedFieldEncoding.t -> ?utf8_validation:Utf8Validation.t -> ?message_encoding:MessageEncoding.t -> ?json_format:JsonFormat.t -> ?enforce_naming_style:EnforceNamingStyle.t -> ?default_symbol_visibility:VisibilityFeature.DefaultSymbolVisibility.t -> ?extensions':Runtime'.Extensions.t -> unit -> t
      let make ?field_presence ?enum_type ?repeated_field_encoding ?utf8_validation ?message_encoding ?json_format ?enforce_naming_style ?default_symbol_visibility ?(extensions' = Runtime'.Extensions.default) () = { field_presence; enum_type; repeated_field_encoding; utf8_validation; message_encoding; json_format; enforce_naming_style; default_symbol_visibility; extensions' }
      let merge =
      let merge_field_presence = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((1, "field_presence", "fieldPresence"), (enum (module FieldPresence))) ) in
      let merge_enum_type = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((2, "enum_type", "enumType"), (enum (module EnumType))) ) in
      let merge_repeated_field_encoding = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((3, "repeated_field_encoding", "repeatedFieldEncoding"), (enum (module RepeatedFieldEncoding))) ) in
      let merge_utf8_validation = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((4, "utf8_validation", "utf8Validation"), (enum (module Utf8Validation))) ) in
      let merge_message_encoding = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((5, "message_encoding", "messageEncoding"), (enum (module MessageEncoding))) ) in
      let merge_json_format = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((6, "json_format", "jsonFormat"), (enum (module JsonFormat))) ) in
      let merge_enforce_naming_style = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((7, "enforce_naming_style", "enforceNamingStyle"), (enum (module EnforceNamingStyle))) ) in
      let merge_default_symbol_visibility = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((8, "default_symbol_visibility", "defaultSymbolVisibility"), (enum (module VisibilityFeature.DefaultSymbolVisibility))) ) in
      fun t1 t2 -> {
      	field_presence = (merge_field_presence t1.field_presence t2.field_presence);
      	enum_type = (merge_enum_type t1.enum_type t2.enum_type);
      	repeated_field_encoding = (merge_repeated_field_encoding t1.repeated_field_encoding t2.repeated_field_encoding);
      	utf8_validation = (merge_utf8_validation t1.utf8_validation t2.utf8_validation);
      	message_encoding = (merge_message_encoding t1.message_encoding t2.message_encoding);
      	json_format = (merge_json_format t1.json_format t2.json_format);
      	enforce_naming_style = (merge_enforce_naming_style t1.enforce_naming_style t2.enforce_naming_style);
      	default_symbol_visibility = (merge_default_symbol_visibility t1.default_symbol_visibility t2.default_symbol_visibility);
      	extensions' = (List.append t1.extensions' t2.extensions');
       }
      let spec () = Runtime'.Spec.( basic_opt ((1, "field_presence", "fieldPresence"), (enum (module FieldPresence))) ^:: basic_opt ((2, "enum_type", "enumType"), (enum (module EnumType))) ^:: basic_opt ((3, "repeated_field_encoding", "repeatedFieldEncoding"), (enum (module RepeatedFieldEncoding))) ^:: basic_opt ((4, "utf8_validation", "utf8Validation"), (enum (module Utf8Validation))) ^:: basic_opt ((5, "message_encoding", "messageEncoding"), (enum (module MessageEncoding))) ^:: basic_opt ((6, "json_format", "jsonFormat"), (enum (module JsonFormat))) ^:: basic_opt ((7, "enforce_naming_style", "enforceNamingStyle"), (enum (module EnforceNamingStyle))) ^:: basic_opt ((8, "default_symbol_visibility", "defaultSymbolVisibility"), (enum (module VisibilityFeature.DefaultSymbolVisibility))) ^:: nil_ext [ (1000, 9995); (9995, 10000); (10000, 10001) ] )
      let to_proto' =
        let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
        fun writer { field_presence; enum_type; repeated_field_encoding; utf8_validation; message_encoding; json_format; enforce_naming_style; default_symbol_visibility; extensions' } -> serialize writer field_presence enum_type repeated_field_encoding utf8_validation message_encoding json_format enforce_naming_style default_symbol_visibility extensions'

      let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
      let from_proto_exn =
        let constructor field_presence enum_type repeated_field_encoding utf8_validation message_encoding json_format enforce_naming_style default_symbol_visibility extensions' = { field_presence; enum_type; repeated_field_encoding; utf8_validation; message_encoding; json_format; enforce_naming_style; default_symbol_visibility; extensions' } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
      let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
      let to_json options =
        let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
        fun { field_presence; enum_type; repeated_field_encoding; utf8_validation; message_encoding; json_format; enforce_naming_style; default_symbol_visibility; extensions' } -> serialize field_presence enum_type repeated_field_encoding utf8_validation message_encoding json_format enforce_naming_style default_symbol_visibility extensions'
      let from_json_exn =
        let constructor field_presence enum_type repeated_field_encoding utf8_validation message_encoding json_format enforce_naming_style default_symbol_visibility extensions' = { field_presence; enum_type; repeated_field_encoding; utf8_validation; message_encoding; json_format; enforce_naming_style; default_symbol_visibility; extensions' } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
      let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
    end

    and FeatureSetDefaults : sig

      (**
{%html:
<p>A map from every known edition with a unique set of defaults to its
defaults. Not all editions may be contained here.  For a given edition,
the defaults at the closest matching edition ordered at or before it should
be used.  This field must be in strict ascending order by edition.</p>
%}
      *)
      module rec FeatureSetEditionDefault : sig
        type t = {
          edition:Edition.t option;
          overridable_features:FeatureSet.t option;
          (**
{%html:
<p>Defaults of features that can be overridden in this edition.</p>
%}
          *)

          fixed_features:FeatureSet.t option;
          (**
{%html:
<p>Defaults of features that can't be overridden in this edition.</p>
%}
          *)

        }
        val make: ?edition:Edition.t -> ?overridable_features:FeatureSet.t -> ?fixed_features:FeatureSet.t -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?edition:Edition.t -> ?overridable_features:FeatureSet.t -> ?fixed_features:FeatureSet.t -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end

      type t = {
        defaults:FeatureSetEditionDefault.t list;
        minimum_edition:Edition.t option;
        (**
{%html:
<p>The minimum supported edition (inclusive) when this was constructed.
Editions before this will not have defaults.</p>
%}
        *)

        maximum_edition:Edition.t option;
        (**
{%html:
<p>The maximum known edition (inclusive) when this was constructed. Editions
after this will not have reliable defaults.</p>
%}
        *)

      }
      val make: ?defaults:FeatureSetEditionDefault.t list -> ?minimum_edition:Edition.t -> ?maximum_edition:Edition.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?defaults:FeatureSetEditionDefault.t list -> ?minimum_edition:Edition.t -> ?maximum_edition:Edition.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end = struct
      module This'_ = FeatureSetDefaults
      module rec FeatureSetEditionDefault : sig
        type t = {
          edition:Edition.t option;
          overridable_features:FeatureSet.t option;
          (**
{%html:
<p>Defaults of features that can be overridden in this edition.</p>
%}
          *)

          fixed_features:FeatureSet.t option;
          (**
{%html:
<p>Defaults of features that can't be overridden in this edition.</p>
%}
          *)

        }
        val make: ?edition:Edition.t -> ?overridable_features:FeatureSet.t -> ?fixed_features:FeatureSet.t -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?edition:Edition.t -> ?overridable_features:FeatureSet.t -> ?fixed_features:FeatureSet.t -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end = struct
        module This'_ = FeatureSetEditionDefault
        let name () = ".google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault"
        type t = {
          edition:Edition.t option;
          overridable_features:FeatureSet.t option;
          fixed_features:FeatureSet.t option;
        }
        type make_t = ?edition:Edition.t -> ?overridable_features:FeatureSet.t -> ?fixed_features:FeatureSet.t -> unit -> t
        let make ?edition ?overridable_features ?fixed_features () = { edition; overridable_features; fixed_features }
        let merge =
        let merge_edition = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((3, "edition", "edition"), (enum (module Edition))) ) in
        let merge_overridable_features = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((4, "overridable_features", "overridableFeatures"), (message (module FeatureSet))) ) in
        let merge_fixed_features = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((5, "fixed_features", "fixedFeatures"), (message (module FeatureSet))) ) in
        fun t1 t2 -> {
        	edition = (merge_edition t1.edition t2.edition);
        	overridable_features = (merge_overridable_features t1.overridable_features t2.overridable_features);
        	fixed_features = (merge_fixed_features t1.fixed_features t2.fixed_features);
         }
        let spec () = Runtime'.Spec.( basic_opt ((3, "edition", "edition"), (enum (module Edition))) ^:: basic_opt ((4, "overridable_features", "overridableFeatures"), (message (module FeatureSet))) ^:: basic_opt ((5, "fixed_features", "fixedFeatures"), (message (module FeatureSet))) ^:: nil )
        let to_proto' =
          let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
          fun writer { edition; overridable_features; fixed_features } -> serialize writer edition overridable_features fixed_features

        let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
        let from_proto_exn =
          let constructor edition overridable_features fixed_features = { edition; overridable_features; fixed_features } in
          Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
        let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
        let to_json options =
          let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
          fun { edition; overridable_features; fixed_features } -> serialize edition overridable_features fixed_features
        let from_json_exn =
          let constructor edition overridable_features fixed_features = { edition; overridable_features; fixed_features } in
          Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
        let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
      end

      let name () = ".google.protobuf.FeatureSetDefaults"
      type t = {
        defaults:FeatureSetEditionDefault.t list;
        minimum_edition:Edition.t option;
        maximum_edition:Edition.t option;
      }
      type make_t = ?defaults:FeatureSetEditionDefault.t list -> ?minimum_edition:Edition.t -> ?maximum_edition:Edition.t -> unit -> t
      let make ?(defaults = []) ?minimum_edition ?maximum_edition () = { defaults; minimum_edition; maximum_edition }
      let merge =
      let merge_defaults = Runtime'.Merge.merge Runtime'.Spec.( repeated ((1, "defaults", "defaults"), (message (module FeatureSetEditionDefault)), not_packed) ) in
      let merge_minimum_edition = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((4, "minimum_edition", "minimumEdition"), (enum (module Edition))) ) in
      let merge_maximum_edition = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((5, "maximum_edition", "maximumEdition"), (enum (module Edition))) ) in
      fun t1 t2 -> {
      	defaults = (merge_defaults t1.defaults t2.defaults);
      	minimum_edition = (merge_minimum_edition t1.minimum_edition t2.minimum_edition);
      	maximum_edition = (merge_maximum_edition t1.maximum_edition t2.maximum_edition);
       }
      let spec () = Runtime'.Spec.( repeated ((1, "defaults", "defaults"), (message (module FeatureSetEditionDefault)), not_packed) ^:: basic_opt ((4, "minimum_edition", "minimumEdition"), (enum (module Edition))) ^:: basic_opt ((5, "maximum_edition", "maximumEdition"), (enum (module Edition))) ^:: nil )
      let to_proto' =
        let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
        fun writer { defaults; minimum_edition; maximum_edition } -> serialize writer defaults minimum_edition maximum_edition

      let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
      let from_proto_exn =
        let constructor defaults minimum_edition maximum_edition = { defaults; minimum_edition; maximum_edition } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
      let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
      let to_json options =
        let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
        fun { defaults; minimum_edition; maximum_edition } -> serialize defaults minimum_edition maximum_edition
      let from_json_exn =
        let constructor defaults minimum_edition maximum_edition = { defaults; minimum_edition; maximum_edition } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
      let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
    end

    and SourceCodeInfo : sig
      module rec Location : sig
        type t = {
          path:int list;
          (**
{%html:
<p>Identifies which part of the FileDescriptorProto was defined at this
location.</p>
<p>Each element is a field number or an index.  They form a path from
the root FileDescriptorProto to the place where the definition appears.
For example, this path:</p>
<pre><code> [ 4, 3, 2, 7, 1 ]
</code></pre>
<p>refers to:</p>
<pre><code> file.message_type(3)  // 4, 3
     .field(7)         // 2, 7
     .name()           // 1
</code></pre>
<p>This is because FileDescriptorProto.message_type has field number 4:</p>
<pre><code> repeated DescriptorProto message_type = 4;
</code></pre>
<p>and DescriptorProto.field has field number 2:</p>
<pre><code> repeated FieldDescriptorProto field = 2;
</code></pre>
<p>and FieldDescriptorProto.name has field number 1:</p>
<pre><code> optional string name = 1;
</code></pre>
<p>Thus, the above path gives the location of a field name.  If we removed
the last element:</p>
<pre><code> [ 4, 3, 2, 7 ]
</code></pre>
<p>this path refers to the whole field declaration (from the beginning
of the label to the terminating semicolon).</p>
%}
          *)

          span:int list;
          (**
{%html:
<p>Always has exactly three or four elements: start line, start column,
end line (optional, otherwise assumed same as start line), end column.
These are packed into a single field for efficiency.  Note that line
and column numbers are zero-based -- typically you will want to add
1 to each before displaying to a user.</p>
%}
          *)

          leading_comments:string option;
          (**
{%html:
<p>If this SourceCodeInfo represents a complete declaration, these are any
comments appearing before and after the declaration which appear to be
attached to the declaration.</p>
<p>A series of line comments appearing on consecutive lines, with no other
tokens appearing on those lines, will be treated as a single comment.</p>
<p>leading_detached_comments will keep paragraphs of comments that appear
before (but not connected to) the current element. Each paragraph,
separated by empty lines, will be one comment element in the repeated
field.</p>
<p>Only the comment content is provided; comment markers (e.g. //) are
stripped out.  For block comments, leading whitespace and an asterisk
will be stripped from the beginning of each line other than the first.
Newlines are included in the output.</p>
<p>Examples:</p>
<pre><code> optional int32 foo = 1;  // Comment attached to foo.
</code></pre>
<p>Comment attached to bar.</p>
<pre><code> optional int32 bar = 2;

 optional string baz = 3;
</code></pre>
<p>Comment attached to baz.
Another line attached to baz.</p>
<p>Comment attached to moo.</p>
<p>Another line attached to moo.</p>
<pre><code> optional double moo = 4;
</code></pre>
<p>Detached comment for corge. This is not leading or trailing comments
to moo or corge because there are blank lines separating it from
both.</p>
<p>Detached comment for corge paragraph 2.</p>
<pre><code> optional string corge = 5;
 /* Block comment attached
  * to corge.  Leading asterisks
  * will be removed. */
 /* Block comment attached to
  * grault. */
 optional int32 grault = 6;
</code></pre>
<p>ignored detached comments.</p>
%}
          *)

          trailing_comments:string option;
          leading_detached_comments:string list;
        }
        val make: ?path:int list -> ?span:int list -> ?leading_comments:string -> ?trailing_comments:string -> ?leading_detached_comments:string list -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?path:int list -> ?span:int list -> ?leading_comments:string -> ?trailing_comments:string -> ?leading_detached_comments:string list -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end

      type t = {
        location:Location.t list;
        (**
{%html:
<p>A Location identifies a piece of source code in a .proto file which
corresponds to a particular definition.  This information is intended
to be useful to IDEs, code indexers, documentation generators, and similar
tools.</p>
<p>For example, say we have a file like:</p>
<pre><code> message Foo {
   optional string foo = 1;
 }
</code></pre>
<p>Let's look at just the field definition:</p>
<pre><code> optional string foo = 1;
 ^       ^^     ^^  ^  ^^^
 a       bc     de  f  ghi
</code></pre>
<p>We have the following locations:</p>
<pre><code> span   path               represents
 [a,i)  [ 4, 0, 2, 0 ]     The whole field definition.
 [a,b)  [ 4, 0, 2, 0, 4 ]  The label (optional).
 [c,d)  [ 4, 0, 2, 0, 5 ]  The type (string).
 [e,f)  [ 4, 0, 2, 0, 1 ]  The name (foo).
 [g,h)  [ 4, 0, 2, 0, 3 ]  The number (1).
</code></pre>
<p>Notes:</p>
<ul>
<li>A location may refer to a repeated field itself (i.e. not to any
particular index within it).  This is used whenever a set of elements are
logically enclosed in a single code segment.  For example, an entire
extend block (possibly containing multiple extension definitions) will
have an outer location whose path refers to the &quot;extensions&quot; repeated
field without an index.
</li>
<li>Multiple locations may have the same path.  This happens when a single
logical declaration is spread out across multiple places.  The most
obvious example is the &quot;extend&quot; block again -- there may be multiple
extend blocks in the same scope, each of which will have the same path.
</li>
<li>A location's span is not always a subset of its parent's span.  For
example, the &quot;extendee&quot; of an extension declaration appears at the
beginning of the &quot;extend&quot; block and is shared by all extensions within
the block.
</li>
<li>Just because a location's span is a subset of some other location's span
does not mean that it is a descendant.  For example, a &quot;group&quot; defines
both a type and a field in a single declaration.  Thus, the locations
corresponding to the type and field and their components will overlap.
</li>
<li>Code which tries to interpret locations should probably be designed to
ignore those that it doesn't understand, as more types of locations could
be recorded in the future.
</li>
</ul>
%}
        *)

        extensions':Runtime'.Extensions.t;
      }
      val make: ?location:Location.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?location:Location.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end = struct
      module This'_ = SourceCodeInfo
      module rec Location : sig
        type t = {
          path:int list;
          (**
{%html:
<p>Identifies which part of the FileDescriptorProto was defined at this
location.</p>
<p>Each element is a field number or an index.  They form a path from
the root FileDescriptorProto to the place where the definition appears.
For example, this path:</p>
<pre><code> [ 4, 3, 2, 7, 1 ]
</code></pre>
<p>refers to:</p>
<pre><code> file.message_type(3)  // 4, 3
     .field(7)         // 2, 7
     .name()           // 1
</code></pre>
<p>This is because FileDescriptorProto.message_type has field number 4:</p>
<pre><code> repeated DescriptorProto message_type = 4;
</code></pre>
<p>and DescriptorProto.field has field number 2:</p>
<pre><code> repeated FieldDescriptorProto field = 2;
</code></pre>
<p>and FieldDescriptorProto.name has field number 1:</p>
<pre><code> optional string name = 1;
</code></pre>
<p>Thus, the above path gives the location of a field name.  If we removed
the last element:</p>
<pre><code> [ 4, 3, 2, 7 ]
</code></pre>
<p>this path refers to the whole field declaration (from the beginning
of the label to the terminating semicolon).</p>
%}
          *)

          span:int list;
          (**
{%html:
<p>Always has exactly three or four elements: start line, start column,
end line (optional, otherwise assumed same as start line), end column.
These are packed into a single field for efficiency.  Note that line
and column numbers are zero-based -- typically you will want to add
1 to each before displaying to a user.</p>
%}
          *)

          leading_comments:string option;
          (**
{%html:
<p>If this SourceCodeInfo represents a complete declaration, these are any
comments appearing before and after the declaration which appear to be
attached to the declaration.</p>
<p>A series of line comments appearing on consecutive lines, with no other
tokens appearing on those lines, will be treated as a single comment.</p>
<p>leading_detached_comments will keep paragraphs of comments that appear
before (but not connected to) the current element. Each paragraph,
separated by empty lines, will be one comment element in the repeated
field.</p>
<p>Only the comment content is provided; comment markers (e.g. //) are
stripped out.  For block comments, leading whitespace and an asterisk
will be stripped from the beginning of each line other than the first.
Newlines are included in the output.</p>
<p>Examples:</p>
<pre><code> optional int32 foo = 1;  // Comment attached to foo.
</code></pre>
<p>Comment attached to bar.</p>
<pre><code> optional int32 bar = 2;

 optional string baz = 3;
</code></pre>
<p>Comment attached to baz.
Another line attached to baz.</p>
<p>Comment attached to moo.</p>
<p>Another line attached to moo.</p>
<pre><code> optional double moo = 4;
</code></pre>
<p>Detached comment for corge. This is not leading or trailing comments
to moo or corge because there are blank lines separating it from
both.</p>
<p>Detached comment for corge paragraph 2.</p>
<pre><code> optional string corge = 5;
 /* Block comment attached
  * to corge.  Leading asterisks
  * will be removed. */
 /* Block comment attached to
  * grault. */
 optional int32 grault = 6;
</code></pre>
<p>ignored detached comments.</p>
%}
          *)

          trailing_comments:string option;
          leading_detached_comments:string list;
        }
        val make: ?path:int list -> ?span:int list -> ?leading_comments:string -> ?trailing_comments:string -> ?leading_detached_comments:string list -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?path:int list -> ?span:int list -> ?leading_comments:string -> ?trailing_comments:string -> ?leading_detached_comments:string list -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end = struct
        module This'_ = Location
        let name () = ".google.protobuf.SourceCodeInfo.Location"
        type t = {
          path:int list;
          span:int list;
          leading_comments:string option;
          trailing_comments:string option;
          leading_detached_comments:string list;
        }
        type make_t = ?path:int list -> ?span:int list -> ?leading_comments:string -> ?trailing_comments:string -> ?leading_detached_comments:string list -> unit -> t
        let make ?(path = []) ?(span = []) ?leading_comments ?trailing_comments ?(leading_detached_comments = []) () = { path; span; leading_comments; trailing_comments; leading_detached_comments }
        let merge =
        let merge_path = Runtime'.Merge.merge Runtime'.Spec.( repeated ((1, "path", "path"), int32_int, packed) ) in
        let merge_span = Runtime'.Merge.merge Runtime'.Spec.( repeated ((2, "span", "span"), int32_int, packed) ) in
        let merge_leading_comments = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((3, "leading_comments", "leadingComments"), string) ) in
        let merge_trailing_comments = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((4, "trailing_comments", "trailingComments"), string) ) in
        let merge_leading_detached_comments = Runtime'.Merge.merge Runtime'.Spec.( repeated ((6, "leading_detached_comments", "leadingDetachedComments"), string, not_packed) ) in
        fun t1 t2 -> {
        	path = (merge_path t1.path t2.path);
        	span = (merge_span t1.span t2.span);
        	leading_comments = (merge_leading_comments t1.leading_comments t2.leading_comments);
        	trailing_comments = (merge_trailing_comments t1.trailing_comments t2.trailing_comments);
        	leading_detached_comments = (merge_leading_detached_comments t1.leading_detached_comments t2.leading_detached_comments);
         }
        let spec () = Runtime'.Spec.( repeated ((1, "path", "path"), int32_int, packed) ^:: repeated ((2, "span", "span"), int32_int, packed) ^:: basic_opt ((3, "leading_comments", "leadingComments"), string) ^:: basic_opt ((4, "trailing_comments", "trailingComments"), string) ^:: repeated ((6, "leading_detached_comments", "leadingDetachedComments"), string, not_packed) ^:: nil )
        let to_proto' =
          let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
          fun writer { path; span; leading_comments; trailing_comments; leading_detached_comments } -> serialize writer path span leading_comments trailing_comments leading_detached_comments

        let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
        let from_proto_exn =
          let constructor path span leading_comments trailing_comments leading_detached_comments = { path; span; leading_comments; trailing_comments; leading_detached_comments } in
          Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
        let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
        let to_json options =
          let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
          fun { path; span; leading_comments; trailing_comments; leading_detached_comments } -> serialize path span leading_comments trailing_comments leading_detached_comments
        let from_json_exn =
          let constructor path span leading_comments trailing_comments leading_detached_comments = { path; span; leading_comments; trailing_comments; leading_detached_comments } in
          Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
        let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
      end

      let name () = ".google.protobuf.SourceCodeInfo"
      type t = {
        location:Location.t list;
        extensions':Runtime'.Extensions.t;
      }
      type make_t = ?location:Location.t list -> ?extensions':Runtime'.Extensions.t -> unit -> t
      let make ?(location = []) ?(extensions' = Runtime'.Extensions.default) () = { location; extensions' }
      let merge =
      let merge_location = Runtime'.Merge.merge Runtime'.Spec.( repeated ((1, "location", "location"), (message (module Location)), not_packed) ) in
      fun t1 t2 -> {
      	location = (merge_location t1.location t2.location);
      	extensions' = (List.append t1.extensions' t2.extensions');
       }
      let spec () = Runtime'.Spec.( repeated ((1, "location", "location"), (message (module Location)), not_packed) ^:: nil_ext [ (536000000, 536000001) ] )
      let to_proto' =
        let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
        fun writer { location; extensions' } -> serialize writer location extensions'

      let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
      let from_proto_exn =
        let constructor location extensions' = { location; extensions' } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
      let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
      let to_json options =
        let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
        fun { location; extensions' } -> serialize location extensions'
      let from_json_exn =
        let constructor location extensions' = { location; extensions' } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
      let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
    end

    and GeneratedCodeInfo : sig
      module rec Annotation : sig

        (**
{%html:
<p>Represents the identified object's effect on the element in the original
.proto file.</p>
%}
        *)
        module rec Semantic : sig
          type t =
            | NONE
            (**
{%html:
<p>There is no effect or the effect is indescribable.</p>
%}
            *)

            | SET
            (**
{%html:
<p>The element is set or otherwise mutated.</p>
%}
            *)

            | ALIAS
            (**
{%html:
<p>An alias to the element is returned.</p>
%}
            *)


          val name: unit -> string
          (** Fully qualified protobuf name of this enum *)

          (**/**)
          val to_int: t -> int
          val from_int: int -> t Runtime'.Result.t
          val from_int_exn: int -> t
          val to_string: t -> string
          val from_string_exn: string -> t
          (**/**)
        end

        type t = {
          path:int list;
          (**
{%html:
<p>Identifies the element in the original source .proto file. This field
is formatted the same as SourceCodeInfo.Location.path.</p>
%}
          *)

          source_file:string option;
          (**
{%html:
<p>Identifies the filesystem path to the original source .proto.</p>
%}
          *)

          begin':int option;
          (**
{%html:
<p>Identifies the starting offset in bytes in the generated code
that relates to the identified object.</p>
%}
          *)

          end':int option;
          (**
{%html:
<p>Identifies the ending offset in bytes in the generated code that
relates to the identified object. The end offset should be one past
the last relevant byte (so the length of the text = end - begin).</p>
%}
          *)

          semantic:Semantic.t option;
        }
        val make: ?path:int list -> ?source_file:string -> ?begin':int -> ?end':int -> ?semantic:Semantic.t -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?path:int list -> ?source_file:string -> ?begin':int -> ?end':int -> ?semantic:Semantic.t -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end

      type t = (Annotation.t list)
      (**
{%html:
<p>An Annotation connects some span of text in generated code to an element
of its generating .proto file.</p>
%}
      *)

      val make: ?annotation:Annotation.t list -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?annotation:Annotation.t list -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end = struct
      module This'_ = GeneratedCodeInfo
      module rec Annotation : sig

        (**
{%html:
<p>Represents the identified object's effect on the element in the original
.proto file.</p>
%}
        *)
        module rec Semantic : sig
          type t =
            | NONE
            (**
{%html:
<p>There is no effect or the effect is indescribable.</p>
%}
            *)

            | SET
            (**
{%html:
<p>The element is set or otherwise mutated.</p>
%}
            *)

            | ALIAS
            (**
{%html:
<p>An alias to the element is returned.</p>
%}
            *)


          val name: unit -> string
          (** Fully qualified protobuf name of this enum *)

          (**/**)
          val to_int: t -> int
          val from_int: int -> t Runtime'.Result.t
          val from_int_exn: int -> t
          val to_string: t -> string
          val from_string_exn: string -> t
          (**/**)
        end

        type t = {
          path:int list;
          (**
{%html:
<p>Identifies the element in the original source .proto file. This field
is formatted the same as SourceCodeInfo.Location.path.</p>
%}
          *)

          source_file:string option;
          (**
{%html:
<p>Identifies the filesystem path to the original source .proto.</p>
%}
          *)

          begin':int option;
          (**
{%html:
<p>Identifies the starting offset in bytes in the generated code
that relates to the identified object.</p>
%}
          *)

          end':int option;
          (**
{%html:
<p>Identifies the ending offset in bytes in the generated code that
relates to the identified object. The end offset should be one past
the last relevant byte (so the length of the text = end - begin).</p>
%}
          *)

          semantic:Semantic.t option;
        }
        val make: ?path:int list -> ?source_file:string -> ?begin':int -> ?end':int -> ?semantic:Semantic.t -> unit -> t
        (** Helper function to generate a message using default values *)

        val to_proto: t -> Runtime'.Writer.t
        (** Serialize the message to binary format *)

        val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from binary format *)

        val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
        (** Serialize to Json (compatible with Yojson.Basic.t) *)

        val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
        (** Deserialize from Json (compatible with Yojson.Basic.t) *)

        val name: unit -> string
        (** Fully qualified protobuf name of this message *)

        (**/**)
        type make_t = ?path:int list -> ?source_file:string -> ?begin':int -> ?end':int -> ?semantic:Semantic.t -> unit -> t
        val merge: t -> t -> t
        val to_proto': Runtime'.Writer.t -> t -> unit
        val from_proto_exn: Runtime'.Reader.t -> t
        val from_json_exn: Runtime'.Json.t -> t
        (**/**)
      end = struct
        module This'_ = Annotation
        module rec Semantic : sig
          type t =
            | NONE
            (**
{%html:
<p>There is no effect or the effect is indescribable.</p>
%}
            *)

            | SET
            (**
{%html:
<p>The element is set or otherwise mutated.</p>
%}
            *)

            | ALIAS
            (**
{%html:
<p>An alias to the element is returned.</p>
%}
            *)


          val name: unit -> string
          (** Fully qualified protobuf name of this enum *)

          (**/**)
          val to_int: t -> int
          val from_int: int -> t Runtime'.Result.t
          val from_int_exn: int -> t
          val to_string: t -> string
          val from_string_exn: string -> t
          (**/**)
        end = struct
          module This'_ = Semantic
          type t =
            | NONE
            (**
{%html:
<p>There is no effect or the effect is indescribable.</p>
%}
            *)

            | SET
            (**
{%html:
<p>The element is set or otherwise mutated.</p>
%}
            *)

            | ALIAS
            (**
{%html:
<p>An alias to the element is returned.</p>
%}
            *)


          let name () = ".google.protobuf.GeneratedCodeInfo.Annotation.Semantic"
          let to_int = function
            | NONE -> 0
            | SET -> 1
            | ALIAS -> 2
          let from_int_exn = function
            | 0 -> NONE
            | 1 -> SET
            | 2 -> ALIAS
            | n -> Runtime'.Result.raise (`Unknown_enum_value n)
          let from_int e = Runtime'.Result.catch (fun () -> from_int_exn e)
          let to_string = function
            | NONE -> "NONE"
            | SET -> "SET"
            | ALIAS -> "ALIAS"
          let from_string_exn = function
            | "NONE" -> NONE
            | "SET" -> SET
            | "ALIAS" -> ALIAS
            | s -> Runtime'.Result.raise (`Unknown_enum_name s)

        end

        let name () = ".google.protobuf.GeneratedCodeInfo.Annotation"
        type t = {
          path:int list;
          source_file:string option;
          begin':int option;
          end':int option;
          semantic:Semantic.t option;
        }
        type make_t = ?path:int list -> ?source_file:string -> ?begin':int -> ?end':int -> ?semantic:Semantic.t -> unit -> t
        let make ?(path = []) ?source_file ?begin' ?end' ?semantic () = { path; source_file; begin'; end'; semantic }
        let merge =
        let merge_path = Runtime'.Merge.merge Runtime'.Spec.( repeated ((1, "path", "path"), int32_int, packed) ) in
        let merge_source_file = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((2, "source_file", "sourceFile"), string) ) in
        let merge_begin' = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((3, "begin", "begin"), int32_int) ) in
        let merge_end' = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((4, "end", "end"), int32_int) ) in
        let merge_semantic = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((5, "semantic", "semantic"), (enum (module Semantic))) ) in
        fun t1 t2 -> {
        	path = (merge_path t1.path t2.path);
        	source_file = (merge_source_file t1.source_file t2.source_file);
        	begin' = (merge_begin' t1.begin' t2.begin');
        	end' = (merge_end' t1.end' t2.end');
        	semantic = (merge_semantic t1.semantic t2.semantic);
         }
        let spec () = Runtime'.Spec.( repeated ((1, "path", "path"), int32_int, packed) ^:: basic_opt ((2, "source_file", "sourceFile"), string) ^:: basic_opt ((3, "begin", "begin"), int32_int) ^:: basic_opt ((4, "end", "end"), int32_int) ^:: basic_opt ((5, "semantic", "semantic"), (enum (module Semantic))) ^:: nil )
        let to_proto' =
          let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
          fun writer { path; source_file; begin'; end'; semantic } -> serialize writer path source_file begin' end' semantic

        let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
        let from_proto_exn =
          let constructor path source_file begin' end' semantic = { path; source_file; begin'; end'; semantic } in
          Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
        let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
        let to_json options =
          let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
          fun { path; source_file; begin'; end'; semantic } -> serialize path source_file begin' end' semantic
        let from_json_exn =
          let constructor path source_file begin' end' semantic = { path; source_file; begin'; end'; semantic } in
          Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
        let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
      end

      let name () = ".google.protobuf.GeneratedCodeInfo"
      type t = (Annotation.t list)
      type make_t = ?annotation:Annotation.t list -> unit -> t
      let make ?(annotation = []) () = (annotation)
      let merge =
      let merge_annotation = Runtime'.Merge.merge Runtime'.Spec.( repeated ((1, "annotation", "annotation"), (message (module Annotation)), not_packed) ) in
      fun (t1_annotation) (t2_annotation) -> merge_annotation t1_annotation t2_annotation
      let spec () = Runtime'.Spec.( repeated ((1, "annotation", "annotation"), (message (module Annotation)), not_packed) ^:: nil )
      let to_proto' =
        let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
        fun writer (annotation) -> serialize writer annotation

      let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
      let from_proto_exn =
        let constructor annotation = (annotation) in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
      let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
      let to_json options =
        let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
        fun (annotation) -> serialize annotation
      let from_json_exn =
        let constructor annotation = (annotation) in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
      let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
    end

  end
end