Source file onnx_protoc.ml

(********************************************************)
(*           AUTOGENERATED FILE - DO NOT EDIT!          *)
(********************************************************)
(* Generated by: ocaml-protoc-plugin                    *)
(* https://github.com/andersfugmann/ocaml-protoc-plugin *)
(********************************************************)
(*
  Source: onnx_protoc.proto
  Syntax: proto2
  Parameters:
    debug=false
    annot=''
    opens=[]
    int64_as_int=false
    int32_as_int=false
    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 Onnx : sig

  (**
    Versioning

    ONNX versioning is specified in docs/IR.md and elaborated on in
    docs/Versioning.md

    To be compatible with both proto2 and proto3, we will use a version number
    that is not defined by the default value but an explicit enum number.
  *)
  module rec Version : sig
    type t =
      | P_START_VERSION
      (**
        proto3 requires the first enum value to be zero.
        We add this just to appease the compiler.
      *)
      | IR_VERSION_2017_10_10
      (**
        The version field is always serialized and we will use it to store the
        version that the  graph is generated from. This helps us set up version
        control.
        For the IR, we are using simple numbers starting with 0x00000001,
        which was the version we published on Oct 10, 2017.
      *)
      | IR_VERSION_2017_10_30
      (**
        IR_VERSION 2 published on Oct 30, 2017
        - Added type discriminator to AttributeProto to support proto3 users
      *)
      | IR_VERSION_2017_11_3
      (**
        IR VERSION 3 published on Nov 3, 2017
        - For operator versioning:
        - Added new message OperatorSetIdProto
        - Added opset_import in ModelProto
        - For vendor extensions, added domain in NodeProto
      *)
      | IR_VERSION_2019_1_22
      (**
        IR VERSION 4 published on Jan 22, 2019
        - Relax constraint that initializers should be a subset of graph inputs
        - Add type BFLOAT16
      *)
      | IR_VERSION_2019_3_18
      (**
        IR VERSION 5 published on March 18, 2019
        - Add message TensorAnnotation.
        - Add quantization annotation in GraphProto to map tensor with its scale
        and zero point quantization parameters.
      *)
      | IR_VERSION_2019_9_19
      (**
        IR VERSION 6 published on Sep 19, 2019
        - Add support for sparse tensor constants stored in model.
        - Add message SparseTensorProto
        - Add sparse initializers
      *)
      | IR_VERSION_2020_5_8
      (**
        IR VERSION 7 published on May 8, 2020
        - Add support to allow function body graph to rely on multiple external
        opreator sets.
        - Add a list to promote inference graph's initializers to global and
        mutable variables. Global variables are visible in all graphs of the
        stored models.
        - Add message TrainingInfoProto to store initialization
        method and training algorithm. The execution of TrainingInfoProto
        can modify the values of mutable variables.
        - Implicitly add inference graph into each TrainingInfoProto's algorithm.
      *)
      | IR_VERSION
      (**
        IR VERSION 8 published on <TBD>
        Introduce TypeProto.SparseTensor
        Introduce TypeProto.Optional
        Added a list of FunctionProtos local to the model
        Deprecated since_version and operator status from FunctionProto
      *)

    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

  (** Operator/function status. *)
  and OperatorStatus : sig
    type t =
      | EXPERIMENTAL
      | STABLE

    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

  (**
    Attributes

    A named attribute containing either singular float, integer, string, graph,
    and tensor values, or repeated float, integer, string, graph, and tensor
    values. An AttributeProto MUST contain the name field, and *only one* of the
    following content fields, effectively enforcing a C/C++ union equivalent.
  *)
  and AttributeProto : sig

    (**
      Note: this enum is structurally identical to the OpSchema::AttrType
      enum defined in schema.h.  If you rev one, you likely need to rev the
      other.
    *)
    module rec AttributeType : sig
      type t =
        | UNDEFINED
        | FLOAT
        | INT
        | STRING
        | TENSOR
        | GRAPH
        | SPARSE_TENSOR
        | TYPE_PROTO
        | FLOATS
        | INTS
        | STRINGS
        | TENSORS
        | GRAPHS
        | SPARSE_TENSORS
        | TYPE_PROTOS

      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;(** The name field MUST be present for this version of the IR.


    namespace Attribute *)
    f: float option;(** Exactly ONE of the following fields must be present for this version of the
    IR


    float *)
    i: int64 option;(** int *)
    s: bytes option;(** UTF-8 string *)
    t: TensorProto.t option;(** tensor value *)
    g: GraphProto.t option;(** graph *)
    floats: float list;(** list of floats *)
    ints: int64 list;(** list of ints *)
    strings: bytes list;(** list of UTF-8 strings *)
    tensors: TensorProto.t list;(** list of tensors *)
    graphs: GraphProto.t list;(** list of graph *)
    doc_string: string option;(** A human-readable documentation for this attribute. Markdown is allowed. *)
    tp: TypeProto.t option;(** Do not use field below, it's deprecated.
    optional ValueProto v = 12;         // value - subsumes everything but
    graph


    type proto *)
    type_protos: TypeProto.t list;(** list of type protos *)
    type': AttributeType.t option;(** The type field MUST be present for this version of the IR.
    For 0.0.1 versions of the IR, this field was not defined, and
    implementations needed to use has_field heuristics to determine
    which value field was in use.  For IR_VERSION 0.0.2 or later, this
    field MUST be set and match the f|i|s|t|... field in use.  This
    change was made to accommodate proto3 implementations.


    discriminator that indicates which field below is in use *)
    ref_attr_name: string option;(** if ref_attr_name is not empty, ref_attr_name is the attribute name in
    parent function. In this case, this AttributeProto does not contain data,
    and it's a reference of attribute in parent scope. NOTE: This should ONLY
    be used in function (sub-graph). It's invalid to be used in main graph. *)
    sparse_tensor: SparseTensorProto.t option;(** sparse tensor value *)
    sparse_tensors: SparseTensorProto.t list;(** list of sparse tensors *)
    }
    val make: ?name:string -> ?f:float -> ?i:int64 -> ?s:bytes -> ?t:TensorProto.t -> ?g:GraphProto.t -> ?floats:float list -> ?ints:int64 list -> ?strings:bytes list -> ?tensors:TensorProto.t list -> ?graphs:GraphProto.t list -> ?doc_string:string -> ?tp:TypeProto.t -> ?type_protos:TypeProto.t list -> ?type':AttributeType.t -> ?ref_attr_name:string -> ?sparse_tensor:SparseTensorProto.t -> ?sparse_tensors:SparseTensorProto.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 = ?name:string -> ?f:float -> ?i:int64 -> ?s:bytes -> ?t:TensorProto.t -> ?g:GraphProto.t -> ?floats:float list -> ?ints:int64 list -> ?strings:bytes list -> ?tensors:TensorProto.t list -> ?graphs:GraphProto.t list -> ?doc_string:string -> ?tp:TypeProto.t -> ?type_protos:TypeProto.t list -> ?type':AttributeType.t -> ?ref_attr_name:string -> ?sparse_tensor:SparseTensorProto.t -> ?sparse_tensors:SparseTensorProto.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

  (**
    Defines information on value, including the name, the type, and
    the shape of the value.
  *)
  and ValueInfoProto : sig
    type t = {
    name: string option;(** This field MUST be present in this version of the IR.


    namespace Value *)
    type': TypeProto.t option;(** This field MUST be present in this version of the IR for
    inputs and outputs of the top-level graph. *)
    doc_string: string option;(** A human-readable documentation for this value. Markdown is allowed. *)
    }
    val make: ?name:string -> ?type':TypeProto.t -> ?doc_string: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:string -> ?type':TypeProto.t -> ?doc_string: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

  (**
    Nodes

    Computation graphs are made up of a DAG of nodes, which represent what is
    commonly called a "layer" or "pipeline stage" in machine learning frameworks.

    For example, it can be a node of type "Conv" that takes in an image, a filter
    tensor and a bias tensor, and produces the convolved output.
  *)
  and NodeProto : sig
    type t = {
    input: string list;(** namespace Value *)
    output: string list;(** namespace Value *)
    name: string option;(** An optional identifier for this node in a graph.
    This field MAY be absent in ths version of the IR.


    namespace Node *)
    op_type: string option;(** The symbolic identifier of the Operator to execute.


    namespace Operator *)
    attribute: AttributeProto.t list;(** Additional named attributes. *)
    doc_string: string option;(** A human-readable documentation for this node. Markdown is allowed. *)
    domain: string option;(** The domain of the OperatorSet that specifies the operator named by op_type.


    namespace Domain *)
    }
    val make: ?input:string list -> ?output:string list -> ?name:string -> ?op_type:string -> ?attribute:AttributeProto.t list -> ?doc_string:string -> ?domain: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 = ?input:string list -> ?output:string list -> ?name:string -> ?op_type:string -> ?attribute:AttributeProto.t list -> ?doc_string:string -> ?domain: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

  (**
    Training information
    TrainingInfoProto stores information for training a model.
    In particular, this defines two functionalities: an initialization-step
    and a training-algorithm-step. Initialization resets the model
    back to its original state as if no training has been performed.
    Training algorithm improves the model based on input data.

    The semantics of the initialization-step is that the initializers
    in ModelProto.graph and in TrainingInfoProto.algorithm are first
    initialized as specified by the initializers in the graph, and then
    updated by the "initialization_binding" in every instance in
    ModelProto.training_info.

    The field "algorithm" defines a computation graph which represents a
    training algorithm's step. After the execution of a
    TrainingInfoProto.algorithm, the initializers specified by "update_binding"
    may be immediately updated. If the targeted training algorithm contains
    consecutive update steps (such as block coordinate descent methods),
    the user needs to create a TrainingInfoProto for each step.
  *)
  and TrainingInfoProto : sig
    type t = {
    initialization: GraphProto.t option;(** This field describes a graph to compute the initial tensors
    upon starting the training process. Initialization graph has no input
    and can have multiple outputs. Usually, trainable tensors in neural
    networks are randomly initialized. To achieve that, for each tensor,
    the user can put a random number operator such as RandomNormal or
    RandomUniform in TrainingInfoProto.initialization.node and assign its
    random output to the specific tensor using "initialization_binding".
    This graph can also set the initializers in "algorithm" in the same
    TrainingInfoProto; a use case is resetting the number of training
    iteration to zero.

    By default, this field is an empty graph and its evaluation does not
    produce any output. Thus, no initializer would be changed by default. *)
    algorithm: GraphProto.t option;(** This field represents a training algorithm step. Given required inputs,
    it computes outputs to update initializers in its own or inference graph's
    initializer lists. In general, this field contains loss node, gradient
    node, optimizer node, increment of iteration count.

    An execution of the training algorithm step is performed by executing the
    graph obtained by combining the inference graph (namely "ModelProto.graph")
    and the "algorithm" graph. That is, the actual the actual
    input/initializer/output/node/value_info/sparse_initializer list of
    the training graph is the concatenation of
    "ModelProto.graph.input/initializer/output/node/value_info/sparse_initializer"
    and "algorithm.input/initializer/output/node/value_info/sparse_initializer"
    in that order. This combined graph must satisfy the normal ONNX conditions.
    Now, let's provide a visualization of graph combination for clarity.
    Let the inference graph (i.e., "ModelProto.graph") be
    {v
        tensor_a, tensor_b -> MatMul -> tensor_c -> Sigmoid -> tensor_d
    v}
    and the "algorithm" graph be
    {v
        tensor_d -> Add -> tensor_e
    v}
    The combination process results
    {v
        tensor_a, tensor_b -> MatMul -> tensor_c -> Sigmoid -> tensor_d -> Add
        -> tensor_e
    v}
    Notice that an input of a node in the "algorithm" graph may reference the
    output of a node in the inference graph (but not the other way round).
    Also, inference node cannot reference inputs of "algorithm". With these
    restrictions, inference graph can always be run independently without
    training information.

    By default, this field is an empty graph and its evaluation does not
    produce any output. Evaluating the default training step never
    update any initializers. *)
    initialization_binding: StringStringEntryProto.t list;(** This field specifies the bindings from the outputs of "initialization" to
    some initializers in "ModelProto.graph.initializer" and
    the "algorithm.initializer" in the same TrainingInfoProto.
    See "update_binding" below for details.

    By default, this field is empty and no initializer would be changed
    by the execution of "initialization". *)
    update_binding: StringStringEntryProto.t list;(** Gradient-based training is usually an iterative procedure. In one gradient
    descent iteration, we apply

    x = x - r * g

    where "x" is the optimized tensor, "r" stands for learning rate, and "g" is
    gradient of "x" with respect to a chosen loss. To avoid adding assignments
    into the training graph, we split the update equation into

    y = x - r * g
    x = y

    The user needs to save "y = x - r * g" into TrainingInfoProto.algorithm. To
    tell that "y" should be assigned to "x", the field "update_binding" may
    contain a key-value pair of strings, "x" (key of StringStringEntryProto)
    and "y" (value of StringStringEntryProto).
    For a neural network with multiple trainable (mutable) tensors, there can
    be multiple key-value pairs in "update_binding".

    The initializers appears as keys in "update_binding" are considered
    mutable variables. This implies some behaviors
    as described below.
    {v
      1. We have only unique keys in all "update_binding"s so that two
         variables may not have the same name. This ensures that one
         variable is assigned up to once.
      2. The keys must appear in names of "ModelProto.graph.initializer" or
         "TrainingInfoProto.algorithm.initializer".
      3. The values must be output names of "algorithm" or
      "ModelProto.graph.output".
      4. Mutable variables are initialized to the value specified by the
         corresponding initializer, and then potentially updated by
         "initializer_binding"s and "update_binding"s in "TrainingInfoProto"s.
    v}
    This field usually contains names of trainable tensors
    (in ModelProto.graph), optimizer states such as momentums in advanced
    stochastic gradient methods (in TrainingInfoProto.graph),
    and number of training iterations (in TrainingInfoProto.graph).

    By default, this field is empty and no initializer would be changed
    by the execution of "algorithm". *)
    }
    val make: ?initialization:GraphProto.t -> ?algorithm:GraphProto.t -> ?initialization_binding:StringStringEntryProto.t list -> ?update_binding:StringStringEntryProto.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 = ?initialization:GraphProto.t -> ?algorithm:GraphProto.t -> ?initialization_binding:StringStringEntryProto.t list -> ?update_binding:StringStringEntryProto.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

  (**
    Models

    ModelProto is a top-level file/container format for bundling a ML model and
    associating its computation graph with metadata.

    The semantics of the model are described by the associated GraphProto's.
  *)
  and ModelProto : sig
    type t = {
    ir_version: int64 option;(** The version of the IR this model targets. See Version enum above.
    This field MUST be present. *)
    producer_name: string option;(** The name of the framework or tool used to generate this model.
    This field SHOULD be present to indicate which
    implementation/tool/framework emitted the model. *)
    producer_version: string option;(** The version of the framework or tool used to generate this model.
    This field SHOULD be present to indicate which
    implementation/tool/framework emitted the model. *)
    domain: string option;(** Domain name of the model.
    We use reverse domain names as name space indicators. For example:
    `com.facebook.fair` or `com.microsoft.cognitiveservices`

    Together with `model_version` and GraphProto.name, this forms the unique
    identity of the graph. *)
    model_version: int64 option;(** The version of the graph encoded. See Version enum below. *)
    doc_string: string option;(** A human-readable documentation for this model. Markdown is allowed. *)
    graph: GraphProto.t option;(** The parameterized graph that is evaluated to execute the model. *)
    opset_import: OperatorSetIdProto.t list;(** The OperatorSets this model relies on.
    All ModelProtos MUST have at least one entry that
    specifies which version of the ONNX OperatorSet is
    being imported.

    All nodes in the ModelProto's graph will bind against the operator
    with the same-domain/same-op_type operator with the HIGHEST version
    in the referenced operator sets. *)
    metadata_props: StringStringEntryProto.t list;(** Named metadata values; keys should be distinct. *)
    training_info: TrainingInfoProto.t list;(** Training-specific information. Sequentially executing all stored
    `TrainingInfoProto.algorithm`s and assigning their outputs following
    the corresponding `TrainingInfoProto.update_binding`s is one training
    iteration. Similarly, to initialize the model
    (as if training hasn't happened), the user should sequentially execute
    all stored `TrainingInfoProto.initialization`s and assigns their outputs
    using `TrainingInfoProto.initialization_binding`s.

    If this field is empty, the training behavior of the model is undefined. *)
    functions: FunctionProto.t list;(** A list of function protos local to the model.

    Name of the function "FunctionProto.name" should be unique within the
    domain "FunctionProto.domain". In case of any conflicts the behavior
    (whether the model local functions are given higher priority, or standard
    opserator sets are given higher priotity or this is treated as error) is
    defined by the runtimes.

    The operator sets imported by FunctionProto should be compatible with the
    ones imported by ModelProto and other model local FunctionProtos. Example,
    if same operator set say 'A' is imported by a FunctionProto and ModelProto
    or by 2 FunctionProtos then versions for the operator set may be different
    but, the operator schema returned for op_type, domain, version combination
    for both the versions should be same for every node in the function body.

    One FunctionProto can reference other FunctionProto in the model, however,
    recursive reference is not allowed. *)
    }
    val make: ?ir_version:int64 -> ?producer_name:string -> ?producer_version:string -> ?domain:string -> ?model_version:int64 -> ?doc_string:string -> ?graph:GraphProto.t -> ?opset_import:OperatorSetIdProto.t list -> ?metadata_props:StringStringEntryProto.t list -> ?training_info:TrainingInfoProto.t list -> ?functions:FunctionProto.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 = ?ir_version:int64 -> ?producer_name:string -> ?producer_version:string -> ?domain:string -> ?model_version:int64 -> ?doc_string:string -> ?graph:GraphProto.t -> ?opset_import:OperatorSetIdProto.t list -> ?metadata_props:StringStringEntryProto.t list -> ?training_info:TrainingInfoProto.t list -> ?functions:FunctionProto.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

  (**
    StringStringEntryProto follows the pattern for cross-proto-version maps.
    See https://developers.google.com/protocol-buffers/docs/proto3#maps
  *)
  and StringStringEntryProto : sig
    type t = {
    key: string option;
    value: string option;
    }
    val make: ?key:string -> ?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 = ?key:string -> ?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
  and TensorAnnotation : sig
    type t = {
    tensor_name: string option;
    quant_parameter_tensor_names: StringStringEntryProto.t list;(** <key, value> pairs to annotate tensor specified by <tensor_name> above.
    The keys used in the mapping below must be pre-defined in ONNX spec.
    For example, for 8-bit linear quantization case, 'SCALE_TENSOR',
    'ZERO_POINT_TENSOR' will be pre-defined as quantization parameter keys. *)
    }
    val make: ?tensor_name:string -> ?quant_parameter_tensor_names:StringStringEntryProto.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 = ?tensor_name:string -> ?quant_parameter_tensor_names:StringStringEntryProto.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

  (**
    Graphs

    A graph defines the computational logic of a model and is comprised of a
    parameterized list of nodes that form a directed acyclic graph based on their
    inputs and outputs. This is the equivalent of the "network" or "graph" in
    many deep learning frameworks.
  *)
  and GraphProto : sig
    type t = {
    node: NodeProto.t list;(** The nodes in the graph, sorted topologically. *)
    name: string option;(** The name of the graph.


    namespace Graph *)
    initializer': TensorProto.t list;(** A list of named tensor values, used to specify constant inputs of the
    graph. Each initializer (both TensorProto as well SparseTensorProto) MUST
    have a name. The name MUST be unique across both initializer and
    sparse_initializer, but the name MAY also appear in the input list. *)
    doc_string: string option;(** A human-readable documentation for this graph. Markdown is allowed. *)
    input: ValueInfoProto.t list;(** The inputs and outputs of the graph. *)
    output: ValueInfoProto.t list;
    value_info: ValueInfoProto.t list;(** Information for the values in the graph. The ValueInfoProto.name's
    must be distinct. It is optional for a value to appear in value_info list. *)
    quantization_annotation: TensorAnnotation.t list;(** This field carries information to indicate the mapping among a tensor and
    its quantization parameter tensors. For example: For tensor 'a', it may
    have \{'SCALE_TENSOR', 'a_scale'\} and \{'ZERO_POINT_TENSOR', 'a_zero_point'\}
    annotated, which means, tensor 'a_scale' and tensor 'a_zero_point' are
    scale and zero point of tensor 'a' in the model. *)
    sparse_initializer: SparseTensorProto.t list;(** Initializers (see above) stored in sparse format. *)
    }
    val make: ?node:NodeProto.t list -> ?name:string -> ?initializer':TensorProto.t list -> ?doc_string:string -> ?input:ValueInfoProto.t list -> ?output:ValueInfoProto.t list -> ?value_info:ValueInfoProto.t list -> ?quantization_annotation:TensorAnnotation.t list -> ?sparse_initializer:SparseTensorProto.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 = ?node:NodeProto.t list -> ?name:string -> ?initializer':TensorProto.t list -> ?doc_string:string -> ?input:ValueInfoProto.t list -> ?output:ValueInfoProto.t list -> ?value_info:ValueInfoProto.t list -> ?quantization_annotation:TensorAnnotation.t list -> ?sparse_initializer:SparseTensorProto.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

  (**
    Tensors

    A serialized tensor value.
  *)
  and TensorProto : sig
    module rec DataType : sig
      type t =
        | UNDEFINED
        | FLOAT
        (**
          Basic types.


          float
        *)
        | UINT8
        (** uint8_t *)
        | INT8
        (** int8_t *)
        | UINT16
        (** uint16_t *)
        | INT16
        (** int16_t *)
        | INT32
        (** int32_t *)
        | INT64
        (** int64_t *)
        | STRING
        (** string *)
        | BOOL
        (** bool *)
        | FLOAT16
        (**
          IEEE754 half-precision floating-point format (16 bits wide).
          This format has 1 sign bit, 5 exponent bits, and 10 mantissa bits.
        *)
        | DOUBLE
        | UINT32
        | UINT64
        | COMPLEX64
        (** complex with float32 real and imaginary components *)
        | COMPLEX128
        (** complex with float64 real and imaginary components *)
        | BFLOAT16
        (**
          Non-IEEE floating-point format based on IEEE754 single-precision
          floating-point number truncated to 16 bits.
          This format has 1 sign bit, 8 exponent bits, and 7 mantissa bits.
        *)

      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

    (**
      Location of the data for this tensor. MUST be one of:
      - DEFAULT - data stored inside the protobuf message. Data is stored in
      raw_data (if set) otherwise in type-specified field.
      - EXTERNAL - data stored in an external location as described by
      external_data field.
    *)
    and DataLocation : sig
      type t =
        | DEFAULT
        | EXTERNAL

      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

    (**
      For very large tensors, we may want to store them in chunks, in which
      case the following fields will specify the segment that is stored in
      the current TensorProto.
    *)
    and Segment : sig
      type t = {
      begin': int64 option;
      end': int64 option;
      }
      val make: ?begin':int64 -> ?end':int64 -> 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 = ?begin':int64 -> ?end':int64 -> 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 = {
    dims: int64 list;(** The shape of the tensor. *)
    data_type: DataType.t option;(** The data type of the tensor.
    This field MUST have a valid TensorProto.DataType value *)
    segment: Segment.t option;
    float_data: float list;(** For float and complex64 values
    Complex64 tensors are encoded as a single array of floats,
    with the real components appearing in odd numbered positions,
    and the corresponding imaginary component appearing in the
    subsequent even numbered position. (e.g., \[1.0 + 2.0i, 3.0 + 4.0i\]
    is encoded as \[1.0, 2.0 ,3.0 ,4.0\]
    When this field is present, the data_type field MUST be FLOAT or COMPLEX64. *)
    int32_data: int32 list;(** For int32, uint8, int8, uint16, int16, bool, and float16 values
    float16 values must be bit-wise converted to an uint16_t prior
    to writing to the buffer.
    When this field is present, the data_type field MUST be
    INT32, INT16, INT8, UINT16, UINT8, BOOL, or FLOAT16 *)
    string_data: bytes list;(** For strings.
    Each element of string_data is a UTF-8 encoded Unicode
    string. No trailing null, no leading BOM. The protobuf "string"
    scalar type is not used to match ML community conventions.
    When this field is present, the data_type field MUST be STRING *)
    int64_data: int64 list;(** For int64.
    When this field is present, the data_type field MUST be INT64 *)
    name: string option;(** Optionally, a name for the tensor.


    namespace Value *)
    raw_data: bytes option;(** Serializations can either use one of the fields above, or use this
    raw bytes field. The only exception is the string case, where one is
    required to store the content in the repeated bytes string_data field.

    When this raw_data field is used to store tensor value, elements MUST
    be stored in as fixed-width, little-endian order.
    Floating-point data types MUST be stored in IEEE 754 format.
    Complex64 elements must be written as two consecutive FLOAT values, real
    component first. Complex128 elements must be written as two consecutive
    DOUBLE values, real component first. Boolean type MUST be written one byte
    per tensor element (00000001 for true, 00000000 for false).

    Note: the advantage of specific field rather than the raw_data field is
    that in some cases (e.g. int data), protobuf does a better packing via
    variable length storage, and may lead to smaller binary footprint.
    When this field is present, the data_type field MUST NOT be STRING or
    UNDEFINED *)
    double_data: float list;(** For double
    Complex128 tensors are encoded as a single array of doubles,
    with the real components appearing in odd numbered positions,
    and the corresponding imaginary component appearing in the
    subsequent even numbered position. (e.g., \[1.0 + 2.0i, 3.0 + 4.0i\]
    is encoded as \[1.0, 2.0 ,3.0 ,4.0\]
    When this field is present, the data_type field MUST be DOUBLE or
    COMPLEX128 *)
    uint64_data: int64 list;(** For uint64 and uint32 values
    When this field is present, the data_type field MUST be
    UINT32 or UINT64 *)
    doc_string: string option;(** A human-readable documentation for this tensor. Markdown is allowed. *)
    external_data: StringStringEntryProto.t list;(** Data can be stored inside the protobuf file using type-specific fields or
    raw_data. Alternatively, raw bytes data can be stored in an external file,
    using the external_data field. external_data stores key-value pairs
    describing data location. Recognized keys are:
    - "location" (required) - POSIX filesystem path relative to the directory
    where the ONNX
    {v
                               protobuf model was stored
    v}
    - "offset" (optional) - position of byte at which stored data begins.
    Integer stored as string.
    {v
                             Offset values SHOULD be multiples 4096 (page size)
                             to enable mmap support.
    v}
    - "length" (optional) - number of bytes containing data. Integer stored as
    string.
    - "checksum" (optional) - SHA1 digest of file specified in under 'location'
    key. *)
    data_location: DataLocation.t option;(** If value not set, data is stored in raw_data (if set) otherwise in
    type-specified field. *)
    }
    val make: ?dims:int64 list -> ?data_type:DataType.t -> ?segment:Segment.t -> ?float_data:float list -> ?int32_data:int32 list -> ?string_data:bytes list -> ?int64_data:int64 list -> ?name:string -> ?raw_data:bytes -> ?double_data:float list -> ?uint64_data:int64 list -> ?doc_string:string -> ?external_data:StringStringEntryProto.t list -> ?data_location:DataLocation.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 = ?dims:int64 list -> ?data_type:DataType.t -> ?segment:Segment.t -> ?float_data:float list -> ?int32_data:int32 list -> ?string_data:bytes list -> ?int64_data:int64 list -> ?name:string -> ?raw_data:bytes -> ?double_data:float list -> ?uint64_data:int64 list -> ?doc_string:string -> ?external_data:StringStringEntryProto.t list -> ?data_location:DataLocation.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

  (** A serialized sparse-tensor value *)
  and SparseTensorProto : sig
    type t = {
    values: TensorProto.t option;(** The sequence of non-default values are encoded as a tensor of shape \[NNZ\].
    The default-value is zero for numeric tensors, and empty-string for string
    tensors. values must have a non-empty name present which serves as a name
    for SparseTensorProto when used in sparse_initializer list. *)
    indices: TensorProto.t option;(** The indices of the non-default values, which may be stored in one of two
    formats. (a) Indices can be a tensor of shape \[NNZ, rank\] with the \[i,j\]-th
    value corresponding to the j-th index of the i-th value (in the values
    tensor). (b) Indices can be a tensor of shape \[NNZ\], in which case the i-th
    value must be the linearized-index of the i-th value (in the values
    tensor). The linearized-index can be converted into an index tuple
    (k_1,...,k_rank) using the shape provided below. The indices must appear in
    ascending order without duplication. In the first format, the ordering is
    lexicographic-ordering: e.g., index-value \[1,4\] must appear before \[2,1\] *)
    dims: int64 list;(** The shape of the underlying dense-tensor: \[dim_1, dim_2, ... dim_rank\] *)
    }
    val make: ?values:TensorProto.t -> ?indices:TensorProto.t -> ?dims:int64 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 = ?values:TensorProto.t -> ?indices:TensorProto.t -> ?dims:int64 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

  (**
    Defines a tensor shape. A dimension can be either an integer value
    or a symbolic variable. A symbolic variable represents an unknown
    dimension.
  *)
  and TensorShapeProto : sig
    module rec Dimension : sig
      type t = {
      value: [ `not_set | `Dim_value of int64 | `Dim_param of string ];
      denotation: string option;(** Standard denotation can optionally be used to denote tensor
      dimensions with standard semantic descriptions to ensure
      that operations are applied to the correct axis of a tensor.
      Refer to
      https://github.com/onnx/onnx/blob/master/docs/DimensionDenotation.md#denotation-definition
      for pre-defined dimension denotations. *)
      }
      val make: ?value:[ `not_set | `Dim_value of int64 | `Dim_param of string ] -> ?denotation: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 = ?value:[ `not_set | `Dim_value of int64 | `Dim_param of string ] -> ?denotation: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 = (Dimension.t list)
    val make: ?dim:Dimension.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 = ?dim:Dimension.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

  (**
    Types

    The standard ONNX data types.
  *)
  and TypeProto : sig
    module rec Tensor : sig
      type t = {
      elem_type: TensorProto.DataType.t option;(** This field MUST NOT have the value of UNDEFINED
      This field MUST have a valid TensorProto.DataType value
      This field MUST be present for this version of the IR. *)
      shape: TensorShapeProto.t option;
      }
      val make: ?elem_type:TensorProto.DataType.t -> ?shape:TensorShapeProto.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 = ?elem_type:TensorProto.DataType.t -> ?shape:TensorShapeProto.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

    (** repeated T *)
    and Sequence : sig
      type t = (TypeProto.t option)
      (**
      The type and optional shape of each element of the sequence.
      This field MUST be present for this version of the IR.
      *)

      val make: ?elem_type:TypeProto.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 = ?elem_type:TypeProto.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

    (** map<K,V> *)
    and Map : sig
      type t = {
      key_type: TensorProto.DataType.t option;(** This field MUST have a valid TensorProto.DataType value
      This field MUST be present for this version of the IR.
      This field MUST refer to an integral type (\[U\]INT\{8|16|32|64\}) or STRING *)
      value_type: TypeProto.t option;(** This field MUST be present for this version of the IR. *)
      }
      val make: ?key_type:TensorProto.DataType.t -> ?value_type:TypeProto.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 = ?key_type:TensorProto.DataType.t -> ?value_type:TypeProto.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

    (** wrapper for Tensor, Sequence, or Map *)
    and Optional : sig
      type t = (TypeProto.t option)
      (**
      The type and optional shape of the element wrapped.
      This field MUST be present for this version of the IR.
      Possible values correspond to OptionalProto.DataType enum
      *)

      val make: ?elem_type:TypeProto.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 = ?elem_type:TypeProto.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 SparseTensor : sig
      type t = {
      elem_type: TensorProto.DataType.t option;(** This field MUST NOT have the value of UNDEFINED
      This field MUST have a valid TensorProto.DataType value
      This field MUST be present for this version of the IR. *)
      shape: TensorShapeProto.t option;
      }
      val make: ?elem_type:TensorProto.DataType.t -> ?shape:TensorShapeProto.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 = ?elem_type:TensorProto.DataType.t -> ?shape:TensorShapeProto.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 = {
    value: [ `not_set | `Tensor_type of Tensor.t | `Sequence_type of Sequence.t | `Map_type of Map.t | `Sparse_tensor_type of SparseTensor.t | `Optional_type of Optional.t ];
    denotation: string option;(** An optional denotation can be used to denote the whole
    type with a standard semantic description as to what is
    stored inside. Refer to
    https://github.com/onnx/onnx/blob/master/docs/TypeDenotation.md#type-denotation-definition
    for pre-defined type denotations. *)
    }
    val make: ?value:[ `not_set | `Tensor_type of Tensor.t | `Sequence_type of Sequence.t | `Map_type of Map.t | `Sparse_tensor_type of SparseTensor.t | `Optional_type of Optional.t ] -> ?denotation: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 = ?value:[ `not_set | `Tensor_type of Tensor.t | `Sequence_type of Sequence.t | `Map_type of Map.t | `Sparse_tensor_type of SparseTensor.t | `Optional_type of Optional.t ] -> ?denotation: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

  (**
    Operator Sets

    OperatorSets are uniquely identified by a (domain, opset_version) pair.
  *)
  and OperatorSetIdProto : sig
    type t = {
    domain: string option;(** The domain of the operator set being identified.
    The empty string ("") or absence of this field implies the operator
    set that is defined as part of the ONNX specification.
    This field MUST be present in this version of the IR when referring to any
    other operator set. *)
    version: int64 option;(** The version of the operator set being identified.
    This field MUST be present in this version of the IR. *)
    }
    val make: ?domain:string -> ?version:int64 -> 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 = ?domain:string -> ?version:int64 -> 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 FunctionProto : sig
    type t = {
    name: string option;(** The name of the function, similar usage of op_type in OperatorProto.
    Combined with FunctionProto.domain, this forms the unique identity of
    the FunctionProto. *)
    input: string list;(** The inputs and outputs of the function. *)
    output: string list;
    attribute: string list;(** The attributes of the function. *)
    node: NodeProto.t list;(** The nodes in the function. *)
    doc_string: string option;(** A human-readable documentation for this function. Markdown is allowed. *)
    opset_import: OperatorSetIdProto.t list;
    domain: string option;(** The domain which this function belongs to. Combined with
    FunctionProto.name, this forms the unique identity of the FunctionProto. *)
    }
    val make: ?name:string -> ?input:string list -> ?output:string list -> ?attribute:string list -> ?node:NodeProto.t list -> ?doc_string:string -> ?opset_import:OperatorSetIdProto.t list -> ?domain: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:string -> ?input:string list -> ?output:string list -> ?attribute:string list -> ?node:NodeProto.t list -> ?doc_string:string -> ?opset_import:OperatorSetIdProto.t list -> ?domain: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
end = struct
  module rec Version : sig
    type t =
      | P_START_VERSION
      (**
        proto3 requires the first enum value to be zero.
        We add this just to appease the compiler.
      *)
      | IR_VERSION_2017_10_10
      (**
        The version field is always serialized and we will use it to store the
        version that the  graph is generated from. This helps us set up version
        control.
        For the IR, we are using simple numbers starting with 0x00000001,
        which was the version we published on Oct 10, 2017.
      *)
      | IR_VERSION_2017_10_30
      (**
        IR_VERSION 2 published on Oct 30, 2017
        - Added type discriminator to AttributeProto to support proto3 users
      *)
      | IR_VERSION_2017_11_3
      (**
        IR VERSION 3 published on Nov 3, 2017
        - For operator versioning:
        - Added new message OperatorSetIdProto
        - Added opset_import in ModelProto
        - For vendor extensions, added domain in NodeProto
      *)
      | IR_VERSION_2019_1_22
      (**
        IR VERSION 4 published on Jan 22, 2019
        - Relax constraint that initializers should be a subset of graph inputs
        - Add type BFLOAT16
      *)
      | IR_VERSION_2019_3_18
      (**
        IR VERSION 5 published on March 18, 2019
        - Add message TensorAnnotation.
        - Add quantization annotation in GraphProto to map tensor with its scale
        and zero point quantization parameters.
      *)
      | IR_VERSION_2019_9_19
      (**
        IR VERSION 6 published on Sep 19, 2019
        - Add support for sparse tensor constants stored in model.
        - Add message SparseTensorProto
        - Add sparse initializers
      *)
      | IR_VERSION_2020_5_8
      (**
        IR VERSION 7 published on May 8, 2020
        - Add support to allow function body graph to rely on multiple external
        opreator sets.
        - Add a list to promote inference graph's initializers to global and
        mutable variables. Global variables are visible in all graphs of the
        stored models.
        - Add message TrainingInfoProto to store initialization
        method and training algorithm. The execution of TrainingInfoProto
        can modify the values of mutable variables.
        - Implicitly add inference graph into each TrainingInfoProto's algorithm.
      *)
      | IR_VERSION
      (**
        IR VERSION 8 published on <TBD>
        Introduce TypeProto.SparseTensor
        Introduce TypeProto.Optional
        Added a list of FunctionProtos local to the model
        Deprecated since_version and operator status from FunctionProto
      *)

    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'_ = Version
    type t =
      | P_START_VERSION
      (**
        proto3 requires the first enum value to be zero.
        We add this just to appease the compiler.
      *)
      | IR_VERSION_2017_10_10
      (**
        The version field is always serialized and we will use it to store the
        version that the  graph is generated from. This helps us set up version
        control.
        For the IR, we are using simple numbers starting with 0x00000001,
        which was the version we published on Oct 10, 2017.
      *)
      | IR_VERSION_2017_10_30
      (**
        IR_VERSION 2 published on Oct 30, 2017
        - Added type discriminator to AttributeProto to support proto3 users
      *)
      | IR_VERSION_2017_11_3
      (**
        IR VERSION 3 published on Nov 3, 2017
        - For operator versioning:
        - Added new message OperatorSetIdProto
        - Added opset_import in ModelProto
        - For vendor extensions, added domain in NodeProto
      *)
      | IR_VERSION_2019_1_22
      (**
        IR VERSION 4 published on Jan 22, 2019
        - Relax constraint that initializers should be a subset of graph inputs
        - Add type BFLOAT16
      *)
      | IR_VERSION_2019_3_18
      (**
        IR VERSION 5 published on March 18, 2019
        - Add message TensorAnnotation.
        - Add quantization annotation in GraphProto to map tensor with its scale
        and zero point quantization parameters.
      *)
      | IR_VERSION_2019_9_19
      (**
        IR VERSION 6 published on Sep 19, 2019
        - Add support for sparse tensor constants stored in model.
        - Add message SparseTensorProto
        - Add sparse initializers
      *)
      | IR_VERSION_2020_5_8
      (**
        IR VERSION 7 published on May 8, 2020
        - Add support to allow function body graph to rely on multiple external
        opreator sets.
        - Add a list to promote inference graph's initializers to global and
        mutable variables. Global variables are visible in all graphs of the
        stored models.
        - Add message TrainingInfoProto to store initialization
        method and training algorithm. The execution of TrainingInfoProto
        can modify the values of mutable variables.
        - Implicitly add inference graph into each TrainingInfoProto's algorithm.
      *)
      | IR_VERSION
      (**
        IR VERSION 8 published on <TBD>
        Introduce TypeProto.SparseTensor
        Introduce TypeProto.Optional
        Added a list of FunctionProtos local to the model
        Deprecated since_version and operator status from FunctionProto
      *)

    let name () = ".onnx.Version"
    let to_int = function
      | P_START_VERSION -> 0
      | IR_VERSION_2017_10_10 -> 1
      | IR_VERSION_2017_10_30 -> 2
      | IR_VERSION_2017_11_3 -> 3
      | IR_VERSION_2019_1_22 -> 4
      | IR_VERSION_2019_3_18 -> 5
      | IR_VERSION_2019_9_19 -> 6
      | IR_VERSION_2020_5_8 -> 7
      | IR_VERSION -> 8
    let from_int_exn = function
      | 0 -> P_START_VERSION
      | 1 -> IR_VERSION_2017_10_10
      | 2 -> IR_VERSION_2017_10_30
      | 3 -> IR_VERSION_2017_11_3
      | 4 -> IR_VERSION_2019_1_22
      | 5 -> IR_VERSION_2019_3_18
      | 6 -> IR_VERSION_2019_9_19
      | 7 -> IR_VERSION_2020_5_8
      | 8 -> IR_VERSION
      | n -> Runtime'.Result.raise (`Unknown_enum_value n)
    let from_int e = Runtime'.Result.catch (fun () -> from_int_exn e)
    let to_string = function
      | P_START_VERSION -> "_START_VERSION"
      | IR_VERSION_2017_10_10 -> "IR_VERSION_2017_10_10"
      | IR_VERSION_2017_10_30 -> "IR_VERSION_2017_10_30"
      | IR_VERSION_2017_11_3 -> "IR_VERSION_2017_11_3"
      | IR_VERSION_2019_1_22 -> "IR_VERSION_2019_1_22"
      | IR_VERSION_2019_3_18 -> "IR_VERSION_2019_3_18"
      | IR_VERSION_2019_9_19 -> "IR_VERSION_2019_9_19"
      | IR_VERSION_2020_5_8 -> "IR_VERSION_2020_5_8"
      | IR_VERSION -> "IR_VERSION"
    let from_string_exn = function
      | "_START_VERSION" -> P_START_VERSION
      | "IR_VERSION_2017_10_10" -> IR_VERSION_2017_10_10
      | "IR_VERSION_2017_10_30" -> IR_VERSION_2017_10_30
      | "IR_VERSION_2017_11_3" -> IR_VERSION_2017_11_3
      | "IR_VERSION_2019_1_22" -> IR_VERSION_2019_1_22
      | "IR_VERSION_2019_3_18" -> IR_VERSION_2019_3_18
      | "IR_VERSION_2019_9_19" -> IR_VERSION_2019_9_19
      | "IR_VERSION_2020_5_8" -> IR_VERSION_2020_5_8
      | "IR_VERSION" -> IR_VERSION
      | s -> Runtime'.Result.raise (`Unknown_enum_name s)

  end
  and OperatorStatus : sig
    type t =
      | EXPERIMENTAL
      | STABLE

    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'_ = OperatorStatus
    type t =
      | EXPERIMENTAL
      | STABLE

    let name () = ".onnx.OperatorStatus"
    let to_int = function
      | EXPERIMENTAL -> 0
      | STABLE -> 1
    let from_int_exn = function
      | 0 -> EXPERIMENTAL
      | 1 -> STABLE
      | n -> Runtime'.Result.raise (`Unknown_enum_value n)
    let from_int e = Runtime'.Result.catch (fun () -> from_int_exn e)
    let to_string = function
      | EXPERIMENTAL -> "EXPERIMENTAL"
      | STABLE -> "STABLE"
    let from_string_exn = function
      | "EXPERIMENTAL" -> EXPERIMENTAL
      | "STABLE" -> STABLE
      | s -> Runtime'.Result.raise (`Unknown_enum_name s)

  end
  and AttributeProto : sig

    (**
      Note: this enum is structurally identical to the OpSchema::AttrType
      enum defined in schema.h.  If you rev one, you likely need to rev the
      other.
    *)
    module rec AttributeType : sig
      type t =
        | UNDEFINED
        | FLOAT
        | INT
        | STRING
        | TENSOR
        | GRAPH
        | SPARSE_TENSOR
        | TYPE_PROTO
        | FLOATS
        | INTS
        | STRINGS
        | TENSORS
        | GRAPHS
        | SPARSE_TENSORS
        | TYPE_PROTOS

      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;(** The name field MUST be present for this version of the IR.


    namespace Attribute *)
    f: float option;(** Exactly ONE of the following fields must be present for this version of the
    IR


    float *)
    i: int64 option;(** int *)
    s: bytes option;(** UTF-8 string *)
    t: TensorProto.t option;(** tensor value *)
    g: GraphProto.t option;(** graph *)
    floats: float list;(** list of floats *)
    ints: int64 list;(** list of ints *)
    strings: bytes list;(** list of UTF-8 strings *)
    tensors: TensorProto.t list;(** list of tensors *)
    graphs: GraphProto.t list;(** list of graph *)
    doc_string: string option;(** A human-readable documentation for this attribute. Markdown is allowed. *)
    tp: TypeProto.t option;(** Do not use field below, it's deprecated.
    optional ValueProto v = 12;         // value - subsumes everything but
    graph


    type proto *)
    type_protos: TypeProto.t list;(** list of type protos *)
    type': AttributeType.t option;(** The type field MUST be present for this version of the IR.
    For 0.0.1 versions of the IR, this field was not defined, and
    implementations needed to use has_field heuristics to determine
    which value field was in use.  For IR_VERSION 0.0.2 or later, this
    field MUST be set and match the f|i|s|t|... field in use.  This
    change was made to accommodate proto3 implementations.


    discriminator that indicates which field below is in use *)
    ref_attr_name: string option;(** if ref_attr_name is not empty, ref_attr_name is the attribute name in
    parent function. In this case, this AttributeProto does not contain data,
    and it's a reference of attribute in parent scope. NOTE: This should ONLY
    be used in function (sub-graph). It's invalid to be used in main graph. *)
    sparse_tensor: SparseTensorProto.t option;(** sparse tensor value *)
    sparse_tensors: SparseTensorProto.t list;(** list of sparse tensors *)
    }
    val make: ?name:string -> ?f:float -> ?i:int64 -> ?s:bytes -> ?t:TensorProto.t -> ?g:GraphProto.t -> ?floats:float list -> ?ints:int64 list -> ?strings:bytes list -> ?tensors:TensorProto.t list -> ?graphs:GraphProto.t list -> ?doc_string:string -> ?tp:TypeProto.t -> ?type_protos:TypeProto.t list -> ?type':AttributeType.t -> ?ref_attr_name:string -> ?sparse_tensor:SparseTensorProto.t -> ?sparse_tensors:SparseTensorProto.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 = ?name:string -> ?f:float -> ?i:int64 -> ?s:bytes -> ?t:TensorProto.t -> ?g:GraphProto.t -> ?floats:float list -> ?ints:int64 list -> ?strings:bytes list -> ?tensors:TensorProto.t list -> ?graphs:GraphProto.t list -> ?doc_string:string -> ?tp:TypeProto.t -> ?type_protos:TypeProto.t list -> ?type':AttributeType.t -> ?ref_attr_name:string -> ?sparse_tensor:SparseTensorProto.t -> ?sparse_tensors:SparseTensorProto.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'_ = AttributeProto
    module rec AttributeType : sig
      type t =
        | UNDEFINED
        | FLOAT
        | INT
        | STRING
        | TENSOR
        | GRAPH
        | SPARSE_TENSOR
        | TYPE_PROTO
        | FLOATS
        | INTS
        | STRINGS
        | TENSORS
        | GRAPHS
        | SPARSE_TENSORS
        | TYPE_PROTOS

      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'_ = AttributeType
      type t =
        | UNDEFINED
        | FLOAT
        | INT
        | STRING
        | TENSOR
        | GRAPH
        | SPARSE_TENSOR
        | TYPE_PROTO
        | FLOATS
        | INTS
        | STRINGS
        | TENSORS
        | GRAPHS
        | SPARSE_TENSORS
        | TYPE_PROTOS

      let name () = ".onnx.AttributeProto.AttributeType"
      let to_int = function
        | UNDEFINED -> 0
        | FLOAT -> 1
        | INT -> 2
        | STRING -> 3
        | TENSOR -> 4
        | GRAPH -> 5
        | SPARSE_TENSOR -> 11
        | TYPE_PROTO -> 13
        | FLOATS -> 6
        | INTS -> 7
        | STRINGS -> 8
        | TENSORS -> 9
        | GRAPHS -> 10
        | SPARSE_TENSORS -> 12
        | TYPE_PROTOS -> 14
      let from_int_exn = function
        | 0 -> UNDEFINED
        | 1 -> FLOAT
        | 2 -> INT
        | 3 -> STRING
        | 4 -> TENSOR
        | 5 -> GRAPH
        | 11 -> SPARSE_TENSOR
        | 13 -> TYPE_PROTO
        | 6 -> FLOATS
        | 7 -> INTS
        | 8 -> STRINGS
        | 9 -> TENSORS
        | 10 -> GRAPHS
        | 12 -> SPARSE_TENSORS
        | 14 -> TYPE_PROTOS
        | n -> Runtime'.Result.raise (`Unknown_enum_value n)
      let from_int e = Runtime'.Result.catch (fun () -> from_int_exn e)
      let to_string = function
        | UNDEFINED -> "UNDEFINED"
        | FLOAT -> "FLOAT"
        | INT -> "INT"
        | STRING -> "STRING"
        | TENSOR -> "TENSOR"
        | GRAPH -> "GRAPH"
        | SPARSE_TENSOR -> "SPARSE_TENSOR"
        | TYPE_PROTO -> "TYPE_PROTO"
        | FLOATS -> "FLOATS"
        | INTS -> "INTS"
        | STRINGS -> "STRINGS"
        | TENSORS -> "TENSORS"
        | GRAPHS -> "GRAPHS"
        | SPARSE_TENSORS -> "SPARSE_TENSORS"
        | TYPE_PROTOS -> "TYPE_PROTOS"
      let from_string_exn = function
        | "UNDEFINED" -> UNDEFINED
        | "FLOAT" -> FLOAT
        | "INT" -> INT
        | "STRING" -> STRING
        | "TENSOR" -> TENSOR
        | "GRAPH" -> GRAPH
        | "SPARSE_TENSOR" -> SPARSE_TENSOR
        | "TYPE_PROTO" -> TYPE_PROTO
        | "FLOATS" -> FLOATS
        | "INTS" -> INTS
        | "STRINGS" -> STRINGS
        | "TENSORS" -> TENSORS
        | "GRAPHS" -> GRAPHS
        | "SPARSE_TENSORS" -> SPARSE_TENSORS
        | "TYPE_PROTOS" -> TYPE_PROTOS
        | s -> Runtime'.Result.raise (`Unknown_enum_name s)

    end
    let name () = ".onnx.AttributeProto"
    type t = {
    name: string option;(** The name field MUST be present for this version of the IR.


    namespace Attribute *)
    f: float option;(** Exactly ONE of the following fields must be present for this version of the
    IR


    float *)
    i: int64 option;(** int *)
    s: bytes option;(** UTF-8 string *)
    t: TensorProto.t option;(** tensor value *)
    g: GraphProto.t option;(** graph *)
    floats: float list;(** list of floats *)
    ints: int64 list;(** list of ints *)
    strings: bytes list;(** list of UTF-8 strings *)
    tensors: TensorProto.t list;(** list of tensors *)
    graphs: GraphProto.t list;(** list of graph *)
    doc_string: string option;(** A human-readable documentation for this attribute. Markdown is allowed. *)
    tp: TypeProto.t option;(** Do not use field below, it's deprecated.
    optional ValueProto v = 12;         // value - subsumes everything but
    graph


    type proto *)
    type_protos: TypeProto.t list;(** list of type protos *)
    type': AttributeType.t option;(** The type field MUST be present for this version of the IR.
    For 0.0.1 versions of the IR, this field was not defined, and
    implementations needed to use has_field heuristics to determine
    which value field was in use.  For IR_VERSION 0.0.2 or later, this
    field MUST be set and match the f|i|s|t|... field in use.  This
    change was made to accommodate proto3 implementations.


    discriminator that indicates which field below is in use *)
    ref_attr_name: string option;(** if ref_attr_name is not empty, ref_attr_name is the attribute name in
    parent function. In this case, this AttributeProto does not contain data,
    and it's a reference of attribute in parent scope. NOTE: This should ONLY
    be used in function (sub-graph). It's invalid to be used in main graph. *)
    sparse_tensor: SparseTensorProto.t option;(** sparse tensor value *)
    sparse_tensors: SparseTensorProto.t list;(** list of sparse tensors *)
    }
    type make_t = ?name:string -> ?f:float -> ?i:int64 -> ?s:bytes -> ?t:TensorProto.t -> ?g:GraphProto.t -> ?floats:float list -> ?ints:int64 list -> ?strings:bytes list -> ?tensors:TensorProto.t list -> ?graphs:GraphProto.t list -> ?doc_string:string -> ?tp:TypeProto.t -> ?type_protos:TypeProto.t list -> ?type':AttributeType.t -> ?ref_attr_name:string -> ?sparse_tensor:SparseTensorProto.t -> ?sparse_tensors:SparseTensorProto.t list -> unit -> t
    let make ?name ?f ?i ?s ?t ?g ?(floats = []) ?(ints = []) ?(strings = []) ?(tensors = []) ?(graphs = []) ?doc_string ?tp ?(type_protos = []) ?type' ?ref_attr_name ?sparse_tensor ?(sparse_tensors = []) () = { name; f; i; s; t; g; floats; ints; strings; tensors; graphs; doc_string; tp; type_protos; type'; ref_attr_name; sparse_tensor; sparse_tensors }
    let merge =
    let merge_name = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((1, "name", "name"), string) ) in
    let merge_f = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((2, "f", "f"), float) ) in
    let merge_i = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((3, "i", "i"), int64) ) in
    let merge_s = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((4, "s", "s"), bytes) ) in
    let merge_t = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((5, "t", "t"), (message (module TensorProto))) ) in
    let merge_g = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((6, "g", "g"), (message (module GraphProto))) ) in
    let merge_floats = Runtime'.Merge.merge Runtime'.Spec.( repeated ((7, "floats", "floats"), float, not_packed) ) in
    let merge_ints = Runtime'.Merge.merge Runtime'.Spec.( repeated ((8, "ints", "ints"), int64, not_packed) ) in
    let merge_strings = Runtime'.Merge.merge Runtime'.Spec.( repeated ((9, "strings", "strings"), bytes, not_packed) ) in
    let merge_tensors = Runtime'.Merge.merge Runtime'.Spec.( repeated ((10, "tensors", "tensors"), (message (module TensorProto)), not_packed) ) in
    let merge_graphs = Runtime'.Merge.merge Runtime'.Spec.( repeated ((11, "graphs", "graphs"), (message (module GraphProto)), not_packed) ) in
    let merge_doc_string = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((13, "doc_string", "docString"), string) ) in
    let merge_tp = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((14, "tp", "tp"), (message (module TypeProto))) ) in
    let merge_type_protos = Runtime'.Merge.merge Runtime'.Spec.( repeated ((15, "type_protos", "typeProtos"), (message (module TypeProto)), not_packed) ) in
    let merge_type' = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((20, "type", "type"), (enum (module AttributeType))) ) in
    let merge_ref_attr_name = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((21, "ref_attr_name", "refAttrName"), string) ) in
    let merge_sparse_tensor = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((22, "sparse_tensor", "sparseTensor"), (message (module SparseTensorProto))) ) in
    let merge_sparse_tensors = Runtime'.Merge.merge Runtime'.Spec.( repeated ((23, "sparse_tensors", "sparseTensors"), (message (module SparseTensorProto)), not_packed) ) in
    fun t1 t2 -> {
    name = (merge_name t1.name t2.name);
    f = (merge_f t1.f t2.f);
    i = (merge_i t1.i t2.i);
    s = (merge_s t1.s t2.s);
    t = (merge_t t1.t t2.t);
    g = (merge_g t1.g t2.g);
    floats = (merge_floats t1.floats t2.floats);
    ints = (merge_ints t1.ints t2.ints);
    strings = (merge_strings t1.strings t2.strings);
    tensors = (merge_tensors t1.tensors t2.tensors);
    graphs = (merge_graphs t1.graphs t2.graphs);
    doc_string = (merge_doc_string t1.doc_string t2.doc_string);
    tp = (merge_tp t1.tp t2.tp);
    type_protos = (merge_type_protos t1.type_protos t2.type_protos);
    type' = (merge_type' t1.type' t2.type');
    ref_attr_name = (merge_ref_attr_name t1.ref_attr_name t2.ref_attr_name);
    sparse_tensor = (merge_sparse_tensor t1.sparse_tensor t2.sparse_tensor);
    sparse_tensors = (merge_sparse_tensors t1.sparse_tensors t2.sparse_tensors);
     }
    let spec () = Runtime'.Spec.( basic_opt ((1, "name", "name"), string) ^:: basic_opt ((2, "f", "f"), float) ^:: basic_opt ((3, "i", "i"), int64) ^:: basic_opt ((4, "s", "s"), bytes) ^:: basic_opt ((5, "t", "t"), (message (module TensorProto))) ^:: basic_opt ((6, "g", "g"), (message (module GraphProto))) ^:: repeated ((7, "floats", "floats"), float, not_packed) ^:: repeated ((8, "ints", "ints"), int64, not_packed) ^:: repeated ((9, "strings", "strings"), bytes, not_packed) ^:: repeated ((10, "tensors", "tensors"), (message (module TensorProto)), not_packed) ^:: repeated ((11, "graphs", "graphs"), (message (module GraphProto)), not_packed) ^:: basic_opt ((13, "doc_string", "docString"), string) ^:: basic_opt ((14, "tp", "tp"), (message (module TypeProto))) ^:: repeated ((15, "type_protos", "typeProtos"), (message (module TypeProto)), not_packed) ^:: basic_opt ((20, "type", "type"), (enum (module AttributeType))) ^:: basic_opt ((21, "ref_attr_name", "refAttrName"), string) ^:: basic_opt ((22, "sparse_tensor", "sparseTensor"), (message (module SparseTensorProto))) ^:: repeated ((23, "sparse_tensors", "sparseTensors"), (message (module SparseTensorProto)), not_packed) ^:: nil )
    let to_proto' =
      let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
      fun writer { name; f; i; s; t; g; floats; ints; strings; tensors; graphs; doc_string; tp; type_protos; type'; ref_attr_name; sparse_tensor; sparse_tensors } -> serialize writer name f i s t g floats ints strings tensors graphs doc_string tp type_protos type' ref_attr_name sparse_tensor sparse_tensors

    let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
    let from_proto_exn =
      let constructor name f i s t g floats ints strings tensors graphs doc_string tp type_protos type' ref_attr_name sparse_tensor sparse_tensors = { name; f; i; s; t; g; floats; ints; strings; tensors; graphs; doc_string; tp; type_protos; type'; ref_attr_name; sparse_tensor; sparse_tensors } 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; f; i; s; t; g; floats; ints; strings; tensors; graphs; doc_string; tp; type_protos; type'; ref_attr_name; sparse_tensor; sparse_tensors } -> serialize name f i s t g floats ints strings tensors graphs doc_string tp type_protos type' ref_attr_name sparse_tensor sparse_tensors
    let from_json_exn =
      let constructor name f i s t g floats ints strings tensors graphs doc_string tp type_protos type' ref_attr_name sparse_tensor sparse_tensors = { name; f; i; s; t; g; floats; ints; strings; tensors; graphs; doc_string; tp; type_protos; type'; ref_attr_name; sparse_tensor; sparse_tensors } 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 ValueInfoProto : sig
    type t = {
    name: string option;(** This field MUST be present in this version of the IR.


    namespace Value *)
    type': TypeProto.t option;(** This field MUST be present in this version of the IR for
    inputs and outputs of the top-level graph. *)
    doc_string: string option;(** A human-readable documentation for this value. Markdown is allowed. *)
    }
    val make: ?name:string -> ?type':TypeProto.t -> ?doc_string: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:string -> ?type':TypeProto.t -> ?doc_string: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'_ = ValueInfoProto
    let name () = ".onnx.ValueInfoProto"
    type t = {
    name: string option;(** This field MUST be present in this version of the IR.


    namespace Value *)
    type': TypeProto.t option;(** This field MUST be present in this version of the IR for
    inputs and outputs of the top-level graph. *)
    doc_string: string option;(** A human-readable documentation for this value. Markdown is allowed. *)
    }
    type make_t = ?name:string -> ?type':TypeProto.t -> ?doc_string:string -> unit -> t
    let make ?name ?type' ?doc_string () = { name; type'; doc_string }
    let merge =
    let merge_name = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((1, "name", "name"), string) ) in
    let merge_type' = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((2, "type", "type"), (message (module TypeProto))) ) in
    let merge_doc_string = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((3, "doc_string", "docString"), string) ) in
    fun t1 t2 -> {
    name = (merge_name t1.name t2.name);
    type' = (merge_type' t1.type' t2.type');
    doc_string = (merge_doc_string t1.doc_string t2.doc_string);
     }
    let spec () = Runtime'.Spec.( basic_opt ((1, "name", "name"), string) ^:: basic_opt ((2, "type", "type"), (message (module TypeProto))) ^:: basic_opt ((3, "doc_string", "docString"), string) ^:: nil )
    let to_proto' =
      let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
      fun writer { name; type'; doc_string } -> serialize writer name type' doc_string

    let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
    let from_proto_exn =
      let constructor name type' doc_string = { name; type'; doc_string } 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; type'; doc_string } -> serialize name type' doc_string
    let from_json_exn =
      let constructor name type' doc_string = { name; type'; doc_string } 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 NodeProto : sig
    type t = {
    input: string list;(** namespace Value *)
    output: string list;(** namespace Value *)
    name: string option;(** An optional identifier for this node in a graph.
    This field MAY be absent in ths version of the IR.


    namespace Node *)
    op_type: string option;(** The symbolic identifier of the Operator to execute.


    namespace Operator *)
    attribute: AttributeProto.t list;(** Additional named attributes. *)
    doc_string: string option;(** A human-readable documentation for this node. Markdown is allowed. *)
    domain: string option;(** The domain of the OperatorSet that specifies the operator named by op_type.


    namespace Domain *)
    }
    val make: ?input:string list -> ?output:string list -> ?name:string -> ?op_type:string -> ?attribute:AttributeProto.t list -> ?doc_string:string -> ?domain: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 = ?input:string list -> ?output:string list -> ?name:string -> ?op_type:string -> ?attribute:AttributeProto.t list -> ?doc_string:string -> ?domain: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'_ = NodeProto
    let name () = ".onnx.NodeProto"
    type t = {
    input: string list;(** namespace Value *)
    output: string list;(** namespace Value *)
    name: string option;(** An optional identifier for this node in a graph.
    This field MAY be absent in ths version of the IR.


    namespace Node *)
    op_type: string option;(** The symbolic identifier of the Operator to execute.


    namespace Operator *)
    attribute: AttributeProto.t list;(** Additional named attributes. *)
    doc_string: string option;(** A human-readable documentation for this node. Markdown is allowed. *)
    domain: string option;(** The domain of the OperatorSet that specifies the operator named by op_type.


    namespace Domain *)
    }
    type make_t = ?input:string list -> ?output:string list -> ?name:string -> ?op_type:string -> ?attribute:AttributeProto.t list -> ?doc_string:string -> ?domain:string -> unit -> t
    let make ?(input = []) ?(output = []) ?name ?op_type ?(attribute = []) ?doc_string ?domain () = { input; output; name; op_type; attribute; doc_string; domain }
    let merge =
    let merge_input = Runtime'.Merge.merge Runtime'.Spec.( repeated ((1, "input", "input"), string, not_packed) ) in
    let merge_output = Runtime'.Merge.merge Runtime'.Spec.( repeated ((2, "output", "output"), string, not_packed) ) in
    let merge_name = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((3, "name", "name"), string) ) in
    let merge_op_type = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((4, "op_type", "opType"), string) ) in
    let merge_attribute = Runtime'.Merge.merge Runtime'.Spec.( repeated ((5, "attribute", "attribute"), (message (module AttributeProto)), not_packed) ) in
    let merge_doc_string = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((6, "doc_string", "docString"), string) ) in
    let merge_domain = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((7, "domain", "domain"), string) ) in
    fun t1 t2 -> {
    input = (merge_input t1.input t2.input);
    output = (merge_output t1.output t2.output);
    name = (merge_name t1.name t2.name);
    op_type = (merge_op_type t1.op_type t2.op_type);
    attribute = (merge_attribute t1.attribute t2.attribute);
    doc_string = (merge_doc_string t1.doc_string t2.doc_string);
    domain = (merge_domain t1.domain t2.domain);
     }
    let spec () = Runtime'.Spec.( repeated ((1, "input", "input"), string, not_packed) ^:: repeated ((2, "output", "output"), string, not_packed) ^:: basic_opt ((3, "name", "name"), string) ^:: basic_opt ((4, "op_type", "opType"), string) ^:: repeated ((5, "attribute", "attribute"), (message (module AttributeProto)), not_packed) ^:: basic_opt ((6, "doc_string", "docString"), string) ^:: basic_opt ((7, "domain", "domain"), string) ^:: nil )
    let to_proto' =
      let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
      fun writer { input; output; name; op_type; attribute; doc_string; domain } -> serialize writer input output name op_type attribute doc_string domain

    let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
    let from_proto_exn =
      let constructor input output name op_type attribute doc_string domain = { input; output; name; op_type; attribute; doc_string; domain } 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 { input; output; name; op_type; attribute; doc_string; domain } -> serialize input output name op_type attribute doc_string domain
    let from_json_exn =
      let constructor input output name op_type attribute doc_string domain = { input; output; name; op_type; attribute; doc_string; domain } 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 TrainingInfoProto : sig
    type t = {
    initialization: GraphProto.t option;(** This field describes a graph to compute the initial tensors
    upon starting the training process. Initialization graph has no input
    and can have multiple outputs. Usually, trainable tensors in neural
    networks are randomly initialized. To achieve that, for each tensor,
    the user can put a random number operator such as RandomNormal or
    RandomUniform in TrainingInfoProto.initialization.node and assign its
    random output to the specific tensor using "initialization_binding".
    This graph can also set the initializers in "algorithm" in the same
    TrainingInfoProto; a use case is resetting the number of training
    iteration to zero.

    By default, this field is an empty graph and its evaluation does not
    produce any output. Thus, no initializer would be changed by default. *)
    algorithm: GraphProto.t option;(** This field represents a training algorithm step. Given required inputs,
    it computes outputs to update initializers in its own or inference graph's
    initializer lists. In general, this field contains loss node, gradient
    node, optimizer node, increment of iteration count.

    An execution of the training algorithm step is performed by executing the
    graph obtained by combining the inference graph (namely "ModelProto.graph")
    and the "algorithm" graph. That is, the actual the actual
    input/initializer/output/node/value_info/sparse_initializer list of
    the training graph is the concatenation of
    "ModelProto.graph.input/initializer/output/node/value_info/sparse_initializer"
    and "algorithm.input/initializer/output/node/value_info/sparse_initializer"
    in that order. This combined graph must satisfy the normal ONNX conditions.
    Now, let's provide a visualization of graph combination for clarity.
    Let the inference graph (i.e., "ModelProto.graph") be
    {v
        tensor_a, tensor_b -> MatMul -> tensor_c -> Sigmoid -> tensor_d
    v}
    and the "algorithm" graph be
    {v
        tensor_d -> Add -> tensor_e
    v}
    The combination process results
    {v
        tensor_a, tensor_b -> MatMul -> tensor_c -> Sigmoid -> tensor_d -> Add
        -> tensor_e
    v}
    Notice that an input of a node in the "algorithm" graph may reference the
    output of a node in the inference graph (but not the other way round).
    Also, inference node cannot reference inputs of "algorithm". With these
    restrictions, inference graph can always be run independently without
    training information.

    By default, this field is an empty graph and its evaluation does not
    produce any output. Evaluating the default training step never
    update any initializers. *)
    initialization_binding: StringStringEntryProto.t list;(** This field specifies the bindings from the outputs of "initialization" to
    some initializers in "ModelProto.graph.initializer" and
    the "algorithm.initializer" in the same TrainingInfoProto.
    See "update_binding" below for details.

    By default, this field is empty and no initializer would be changed
    by the execution of "initialization". *)
    update_binding: StringStringEntryProto.t list;(** Gradient-based training is usually an iterative procedure. In one gradient
    descent iteration, we apply

    x = x - r * g

    where "x" is the optimized tensor, "r" stands for learning rate, and "g" is
    gradient of "x" with respect to a chosen loss. To avoid adding assignments
    into the training graph, we split the update equation into

    y = x - r * g
    x = y

    The user needs to save "y = x - r * g" into TrainingInfoProto.algorithm. To
    tell that "y" should be assigned to "x", the field "update_binding" may
    contain a key-value pair of strings, "x" (key of StringStringEntryProto)
    and "y" (value of StringStringEntryProto).
    For a neural network with multiple trainable (mutable) tensors, there can
    be multiple key-value pairs in "update_binding".

    The initializers appears as keys in "update_binding" are considered
    mutable variables. This implies some behaviors
    as described below.
    {v
      1. We have only unique keys in all "update_binding"s so that two
         variables may not have the same name. This ensures that one
         variable is assigned up to once.
      2. The keys must appear in names of "ModelProto.graph.initializer" or
         "TrainingInfoProto.algorithm.initializer".
      3. The values must be output names of "algorithm" or
      "ModelProto.graph.output".
      4. Mutable variables are initialized to the value specified by the
         corresponding initializer, and then potentially updated by
         "initializer_binding"s and "update_binding"s in "TrainingInfoProto"s.
    v}
    This field usually contains names of trainable tensors
    (in ModelProto.graph), optimizer states such as momentums in advanced
    stochastic gradient methods (in TrainingInfoProto.graph),
    and number of training iterations (in TrainingInfoProto.graph).

    By default, this field is empty and no initializer would be changed
    by the execution of "algorithm". *)
    }
    val make: ?initialization:GraphProto.t -> ?algorithm:GraphProto.t -> ?initialization_binding:StringStringEntryProto.t list -> ?update_binding:StringStringEntryProto.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 = ?initialization:GraphProto.t -> ?algorithm:GraphProto.t -> ?initialization_binding:StringStringEntryProto.t list -> ?update_binding:StringStringEntryProto.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'_ = TrainingInfoProto
    let name () = ".onnx.TrainingInfoProto"
    type t = {
    initialization: GraphProto.t option;(** This field describes a graph to compute the initial tensors
    upon starting the training process. Initialization graph has no input
    and can have multiple outputs. Usually, trainable tensors in neural
    networks are randomly initialized. To achieve that, for each tensor,
    the user can put a random number operator such as RandomNormal or
    RandomUniform in TrainingInfoProto.initialization.node and assign its
    random output to the specific tensor using "initialization_binding".
    This graph can also set the initializers in "algorithm" in the same
    TrainingInfoProto; a use case is resetting the number of training
    iteration to zero.

    By default, this field is an empty graph and its evaluation does not
    produce any output. Thus, no initializer would be changed by default. *)
    algorithm: GraphProto.t option;(** This field represents a training algorithm step. Given required inputs,
    it computes outputs to update initializers in its own or inference graph's
    initializer lists. In general, this field contains loss node, gradient
    node, optimizer node, increment of iteration count.

    An execution of the training algorithm step is performed by executing the
    graph obtained by combining the inference graph (namely "ModelProto.graph")
    and the "algorithm" graph. That is, the actual the actual
    input/initializer/output/node/value_info/sparse_initializer list of
    the training graph is the concatenation of
    "ModelProto.graph.input/initializer/output/node/value_info/sparse_initializer"
    and "algorithm.input/initializer/output/node/value_info/sparse_initializer"
    in that order. This combined graph must satisfy the normal ONNX conditions.
    Now, let's provide a visualization of graph combination for clarity.
    Let the inference graph (i.e., "ModelProto.graph") be
    {v
        tensor_a, tensor_b -> MatMul -> tensor_c -> Sigmoid -> tensor_d
    v}
    and the "algorithm" graph be
    {v
        tensor_d -> Add -> tensor_e
    v}
    The combination process results
    {v
        tensor_a, tensor_b -> MatMul -> tensor_c -> Sigmoid -> tensor_d -> Add
        -> tensor_e
    v}
    Notice that an input of a node in the "algorithm" graph may reference the
    output of a node in the inference graph (but not the other way round).
    Also, inference node cannot reference inputs of "algorithm". With these
    restrictions, inference graph can always be run independently without
    training information.

    By default, this field is an empty graph and its evaluation does not
    produce any output. Evaluating the default training step never
    update any initializers. *)
    initialization_binding: StringStringEntryProto.t list;(** This field specifies the bindings from the outputs of "initialization" to
    some initializers in "ModelProto.graph.initializer" and
    the "algorithm.initializer" in the same TrainingInfoProto.
    See "update_binding" below for details.

    By default, this field is empty and no initializer would be changed
    by the execution of "initialization". *)
    update_binding: StringStringEntryProto.t list;(** Gradient-based training is usually an iterative procedure. In one gradient
    descent iteration, we apply

    x = x - r * g

    where "x" is the optimized tensor, "r" stands for learning rate, and "g" is
    gradient of "x" with respect to a chosen loss. To avoid adding assignments
    into the training graph, we split the update equation into

    y = x - r * g
    x = y

    The user needs to save "y = x - r * g" into TrainingInfoProto.algorithm. To
    tell that "y" should be assigned to "x", the field "update_binding" may
    contain a key-value pair of strings, "x" (key of StringStringEntryProto)
    and "y" (value of StringStringEntryProto).
    For a neural network with multiple trainable (mutable) tensors, there can
    be multiple key-value pairs in "update_binding".

    The initializers appears as keys in "update_binding" are considered
    mutable variables. This implies some behaviors
    as described below.
    {v
      1. We have only unique keys in all "update_binding"s so that two
         variables may not have the same name. This ensures that one
         variable is assigned up to once.
      2. The keys must appear in names of "ModelProto.graph.initializer" or
         "TrainingInfoProto.algorithm.initializer".
      3. The values must be output names of "algorithm" or
      "ModelProto.graph.output".
      4. Mutable variables are initialized to the value specified by the
         corresponding initializer, and then potentially updated by
         "initializer_binding"s and "update_binding"s in "TrainingInfoProto"s.
    v}
    This field usually contains names of trainable tensors
    (in ModelProto.graph), optimizer states such as momentums in advanced
    stochastic gradient methods (in TrainingInfoProto.graph),
    and number of training iterations (in TrainingInfoProto.graph).

    By default, this field is empty and no initializer would be changed
    by the execution of "algorithm". *)
    }
    type make_t = ?initialization:GraphProto.t -> ?algorithm:GraphProto.t -> ?initialization_binding:StringStringEntryProto.t list -> ?update_binding:StringStringEntryProto.t list -> unit -> t
    let make ?initialization ?algorithm ?(initialization_binding = []) ?(update_binding = []) () = { initialization; algorithm; initialization_binding; update_binding }
    let merge =
    let merge_initialization = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((1, "initialization", "initialization"), (message (module GraphProto))) ) in
    let merge_algorithm = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((2, "algorithm", "algorithm"), (message (module GraphProto))) ) in
    let merge_initialization_binding = Runtime'.Merge.merge Runtime'.Spec.( repeated ((3, "initialization_binding", "initializationBinding"), (message (module StringStringEntryProto)), not_packed) ) in
    let merge_update_binding = Runtime'.Merge.merge Runtime'.Spec.( repeated ((4, "update_binding", "updateBinding"), (message (module StringStringEntryProto)), not_packed) ) in
    fun t1 t2 -> {
    initialization = (merge_initialization t1.initialization t2.initialization);
    algorithm = (merge_algorithm t1.algorithm t2.algorithm);
    initialization_binding = (merge_initialization_binding t1.initialization_binding t2.initialization_binding);
    update_binding = (merge_update_binding t1.update_binding t2.update_binding);
     }
    let spec () = Runtime'.Spec.( basic_opt ((1, "initialization", "initialization"), (message (module GraphProto))) ^:: basic_opt ((2, "algorithm", "algorithm"), (message (module GraphProto))) ^:: repeated ((3, "initialization_binding", "initializationBinding"), (message (module StringStringEntryProto)), not_packed) ^:: repeated ((4, "update_binding", "updateBinding"), (message (module StringStringEntryProto)), not_packed) ^:: nil )
    let to_proto' =
      let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
      fun writer { initialization; algorithm; initialization_binding; update_binding } -> serialize writer initialization algorithm initialization_binding update_binding

    let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
    let from_proto_exn =
      let constructor initialization algorithm initialization_binding update_binding = { initialization; algorithm; initialization_binding; update_binding } 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 { initialization; algorithm; initialization_binding; update_binding } -> serialize initialization algorithm initialization_binding update_binding
    let from_json_exn =
      let constructor initialization algorithm initialization_binding update_binding = { initialization; algorithm; initialization_binding; update_binding } 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 ModelProto : sig
    type t = {
    ir_version: int64 option;(** The version of the IR this model targets. See Version enum above.
    This field MUST be present. *)
    producer_name: string option;(** The name of the framework or tool used to generate this model.
    This field SHOULD be present to indicate which
    implementation/tool/framework emitted the model. *)
    producer_version: string option;(** The version of the framework or tool used to generate this model.
    This field SHOULD be present to indicate which
    implementation/tool/framework emitted the model. *)
    domain: string option;(** Domain name of the model.
    We use reverse domain names as name space indicators. For example:
    `com.facebook.fair` or `com.microsoft.cognitiveservices`

    Together with `model_version` and GraphProto.name, this forms the unique
    identity of the graph. *)
    model_version: int64 option;(** The version of the graph encoded. See Version enum below. *)
    doc_string: string option;(** A human-readable documentation for this model. Markdown is allowed. *)
    graph: GraphProto.t option;(** The parameterized graph that is evaluated to execute the model. *)
    opset_import: OperatorSetIdProto.t list;(** The OperatorSets this model relies on.
    All ModelProtos MUST have at least one entry that
    specifies which version of the ONNX OperatorSet is
    being imported.

    All nodes in the ModelProto's graph will bind against the operator
    with the same-domain/same-op_type operator with the HIGHEST version
    in the referenced operator sets. *)
    metadata_props: StringStringEntryProto.t list;(** Named metadata values; keys should be distinct. *)
    training_info: TrainingInfoProto.t list;(** Training-specific information. Sequentially executing all stored
    `TrainingInfoProto.algorithm`s and assigning their outputs following
    the corresponding `TrainingInfoProto.update_binding`s is one training
    iteration. Similarly, to initialize the model
    (as if training hasn't happened), the user should sequentially execute
    all stored `TrainingInfoProto.initialization`s and assigns their outputs
    using `TrainingInfoProto.initialization_binding`s.

    If this field is empty, the training behavior of the model is undefined. *)
    functions: FunctionProto.t list;(** A list of function protos local to the model.

    Name of the function "FunctionProto.name" should be unique within the
    domain "FunctionProto.domain". In case of any conflicts the behavior
    (whether the model local functions are given higher priority, or standard
    opserator sets are given higher priotity or this is treated as error) is
    defined by the runtimes.

    The operator sets imported by FunctionProto should be compatible with the
    ones imported by ModelProto and other model local FunctionProtos. Example,
    if same operator set say 'A' is imported by a FunctionProto and ModelProto
    or by 2 FunctionProtos then versions for the operator set may be different
    but, the operator schema returned for op_type, domain, version combination
    for both the versions should be same for every node in the function body.

    One FunctionProto can reference other FunctionProto in the model, however,
    recursive reference is not allowed. *)
    }
    val make: ?ir_version:int64 -> ?producer_name:string -> ?producer_version:string -> ?domain:string -> ?model_version:int64 -> ?doc_string:string -> ?graph:GraphProto.t -> ?opset_import:OperatorSetIdProto.t list -> ?metadata_props:StringStringEntryProto.t list -> ?training_info:TrainingInfoProto.t list -> ?functions:FunctionProto.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 = ?ir_version:int64 -> ?producer_name:string -> ?producer_version:string -> ?domain:string -> ?model_version:int64 -> ?doc_string:string -> ?graph:GraphProto.t -> ?opset_import:OperatorSetIdProto.t list -> ?metadata_props:StringStringEntryProto.t list -> ?training_info:TrainingInfoProto.t list -> ?functions:FunctionProto.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'_ = ModelProto
    let name () = ".onnx.ModelProto"
    type t = {
    ir_version: int64 option;(** The version of the IR this model targets. See Version enum above.
    This field MUST be present. *)
    producer_name: string option;(** The name of the framework or tool used to generate this model.
    This field SHOULD be present to indicate which
    implementation/tool/framework emitted the model. *)
    producer_version: string option;(** The version of the framework or tool used to generate this model.
    This field SHOULD be present to indicate which
    implementation/tool/framework emitted the model. *)
    domain: string option;(** Domain name of the model.
    We use reverse domain names as name space indicators. For example:
    `com.facebook.fair` or `com.microsoft.cognitiveservices`

    Together with `model_version` and GraphProto.name, this forms the unique
    identity of the graph. *)
    model_version: int64 option;(** The version of the graph encoded. See Version enum below. *)
    doc_string: string option;(** A human-readable documentation for this model. Markdown is allowed. *)
    graph: GraphProto.t option;(** The parameterized graph that is evaluated to execute the model. *)
    opset_import: OperatorSetIdProto.t list;(** The OperatorSets this model relies on.
    All ModelProtos MUST have at least one entry that
    specifies which version of the ONNX OperatorSet is
    being imported.

    All nodes in the ModelProto's graph will bind against the operator
    with the same-domain/same-op_type operator with the HIGHEST version
    in the referenced operator sets. *)
    metadata_props: StringStringEntryProto.t list;(** Named metadata values; keys should be distinct. *)
    training_info: TrainingInfoProto.t list;(** Training-specific information. Sequentially executing all stored
    `TrainingInfoProto.algorithm`s and assigning their outputs following
    the corresponding `TrainingInfoProto.update_binding`s is one training
    iteration. Similarly, to initialize the model
    (as if training hasn't happened), the user should sequentially execute
    all stored `TrainingInfoProto.initialization`s and assigns their outputs
    using `TrainingInfoProto.initialization_binding`s.

    If this field is empty, the training behavior of the model is undefined. *)
    functions: FunctionProto.t list;(** A list of function protos local to the model.

    Name of the function "FunctionProto.name" should be unique within the
    domain "FunctionProto.domain". In case of any conflicts the behavior
    (whether the model local functions are given higher priority, or standard
    opserator sets are given higher priotity or this is treated as error) is
    defined by the runtimes.

    The operator sets imported by FunctionProto should be compatible with the
    ones imported by ModelProto and other model local FunctionProtos. Example,
    if same operator set say 'A' is imported by a FunctionProto and ModelProto
    or by 2 FunctionProtos then versions for the operator set may be different
    but, the operator schema returned for op_type, domain, version combination
    for both the versions should be same for every node in the function body.

    One FunctionProto can reference other FunctionProto in the model, however,
    recursive reference is not allowed. *)
    }
    type make_t = ?ir_version:int64 -> ?producer_name:string -> ?producer_version:string -> ?domain:string -> ?model_version:int64 -> ?doc_string:string -> ?graph:GraphProto.t -> ?opset_import:OperatorSetIdProto.t list -> ?metadata_props:StringStringEntryProto.t list -> ?training_info:TrainingInfoProto.t list -> ?functions:FunctionProto.t list -> unit -> t
    let make ?ir_version ?producer_name ?producer_version ?domain ?model_version ?doc_string ?graph ?(opset_import = []) ?(metadata_props = []) ?(training_info = []) ?(functions = []) () = { ir_version; producer_name; producer_version; domain; model_version; doc_string; graph; opset_import; metadata_props; training_info; functions }
    let merge =
    let merge_ir_version = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((1, "ir_version", "irVersion"), int64) ) in
    let merge_producer_name = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((2, "producer_name", "producerName"), string) ) in
    let merge_producer_version = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((3, "producer_version", "producerVersion"), string) ) in
    let merge_domain = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((4, "domain", "domain"), string) ) in
    let merge_model_version = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((5, "model_version", "modelVersion"), int64) ) in
    let merge_doc_string = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((6, "doc_string", "docString"), string) ) in
    let merge_graph = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((7, "graph", "graph"), (message (module GraphProto))) ) in
    let merge_opset_import = Runtime'.Merge.merge Runtime'.Spec.( repeated ((8, "opset_import", "opsetImport"), (message (module OperatorSetIdProto)), not_packed) ) in
    let merge_metadata_props = Runtime'.Merge.merge Runtime'.Spec.( repeated ((14, "metadata_props", "metadataProps"), (message (module StringStringEntryProto)), not_packed) ) in
    let merge_training_info = Runtime'.Merge.merge Runtime'.Spec.( repeated ((20, "training_info", "trainingInfo"), (message (module TrainingInfoProto)), not_packed) ) in
    let merge_functions = Runtime'.Merge.merge Runtime'.Spec.( repeated ((25, "functions", "functions"), (message (module FunctionProto)), not_packed) ) in
    fun t1 t2 -> {
    ir_version = (merge_ir_version t1.ir_version t2.ir_version);
    producer_name = (merge_producer_name t1.producer_name t2.producer_name);
    producer_version = (merge_producer_version t1.producer_version t2.producer_version);
    domain = (merge_domain t1.domain t2.domain);
    model_version = (merge_model_version t1.model_version t2.model_version);
    doc_string = (merge_doc_string t1.doc_string t2.doc_string);
    graph = (merge_graph t1.graph t2.graph);
    opset_import = (merge_opset_import t1.opset_import t2.opset_import);
    metadata_props = (merge_metadata_props t1.metadata_props t2.metadata_props);
    training_info = (merge_training_info t1.training_info t2.training_info);
    functions = (merge_functions t1.functions t2.functions);
     }
    let spec () = Runtime'.Spec.( basic_opt ((1, "ir_version", "irVersion"), int64) ^:: basic_opt ((2, "producer_name", "producerName"), string) ^:: basic_opt ((3, "producer_version", "producerVersion"), string) ^:: basic_opt ((4, "domain", "domain"), string) ^:: basic_opt ((5, "model_version", "modelVersion"), int64) ^:: basic_opt ((6, "doc_string", "docString"), string) ^:: basic_opt ((7, "graph", "graph"), (message (module GraphProto))) ^:: repeated ((8, "opset_import", "opsetImport"), (message (module OperatorSetIdProto)), not_packed) ^:: repeated ((14, "metadata_props", "metadataProps"), (message (module StringStringEntryProto)), not_packed) ^:: repeated ((20, "training_info", "trainingInfo"), (message (module TrainingInfoProto)), not_packed) ^:: repeated ((25, "functions", "functions"), (message (module FunctionProto)), not_packed) ^:: nil )
    let to_proto' =
      let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
      fun writer { ir_version; producer_name; producer_version; domain; model_version; doc_string; graph; opset_import; metadata_props; training_info; functions } -> serialize writer ir_version producer_name producer_version domain model_version doc_string graph opset_import metadata_props training_info functions

    let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
    let from_proto_exn =
      let constructor ir_version producer_name producer_version domain model_version doc_string graph opset_import metadata_props training_info functions = { ir_version; producer_name; producer_version; domain; model_version; doc_string; graph; opset_import; metadata_props; training_info; functions } 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 { ir_version; producer_name; producer_version; domain; model_version; doc_string; graph; opset_import; metadata_props; training_info; functions } -> serialize ir_version producer_name producer_version domain model_version doc_string graph opset_import metadata_props training_info functions
    let from_json_exn =
      let constructor ir_version producer_name producer_version domain model_version doc_string graph opset_import metadata_props training_info functions = { ir_version; producer_name; producer_version; domain; model_version; doc_string; graph; opset_import; metadata_props; training_info; functions } 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 StringStringEntryProto : sig
    type t = {
    key: string option;
    value: string option;
    }
    val make: ?key:string -> ?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 = ?key:string -> ?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'_ = StringStringEntryProto
    let name () = ".onnx.StringStringEntryProto"
    type t = {
    key: string option;
    value: string option;
    }
    type make_t = ?key:string -> ?value:string -> unit -> t
    let make ?key ?value () = { key; value }
    let merge =
    let merge_key = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((1, "key", "key"), string) ) in
    let merge_value = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((2, "value", "value"), string) ) in
    fun t1 t2 -> {
    key = (merge_key t1.key t2.key);
    value = (merge_value t1.value t2.value);
     }
    let spec () = Runtime'.Spec.( basic_opt ((1, "key", "key"), string) ^:: basic_opt ((2, "value", "value"), string) ^:: nil )
    let to_proto' =
      let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
      fun writer { key; value } -> serialize writer key value

    let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
    let from_proto_exn =
      let constructor key value = { key; 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 { key; value } -> serialize key value
    let from_json_exn =
      let constructor key value = { key; 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 TensorAnnotation : sig
    type t = {
    tensor_name: string option;
    quant_parameter_tensor_names: StringStringEntryProto.t list;(** <key, value> pairs to annotate tensor specified by <tensor_name> above.
    The keys used in the mapping below must be pre-defined in ONNX spec.
    For example, for 8-bit linear quantization case, 'SCALE_TENSOR',
    'ZERO_POINT_TENSOR' will be pre-defined as quantization parameter keys. *)
    }
    val make: ?tensor_name:string -> ?quant_parameter_tensor_names:StringStringEntryProto.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 = ?tensor_name:string -> ?quant_parameter_tensor_names:StringStringEntryProto.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'_ = TensorAnnotation
    let name () = ".onnx.TensorAnnotation"
    type t = {
    tensor_name: string option;
    quant_parameter_tensor_names: StringStringEntryProto.t list;(** <key, value> pairs to annotate tensor specified by <tensor_name> above.
    The keys used in the mapping below must be pre-defined in ONNX spec.
    For example, for 8-bit linear quantization case, 'SCALE_TENSOR',
    'ZERO_POINT_TENSOR' will be pre-defined as quantization parameter keys. *)
    }
    type make_t = ?tensor_name:string -> ?quant_parameter_tensor_names:StringStringEntryProto.t list -> unit -> t
    let make ?tensor_name ?(quant_parameter_tensor_names = []) () = { tensor_name; quant_parameter_tensor_names }
    let merge =
    let merge_tensor_name = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((1, "tensor_name", "tensorName"), string) ) in
    let merge_quant_parameter_tensor_names = Runtime'.Merge.merge Runtime'.Spec.( repeated ((2, "quant_parameter_tensor_names", "quantParameterTensorNames"), (message (module StringStringEntryProto)), not_packed) ) in
    fun t1 t2 -> {
    tensor_name = (merge_tensor_name t1.tensor_name t2.tensor_name);
    quant_parameter_tensor_names = (merge_quant_parameter_tensor_names t1.quant_parameter_tensor_names t2.quant_parameter_tensor_names);
     }
    let spec () = Runtime'.Spec.( basic_opt ((1, "tensor_name", "tensorName"), string) ^:: repeated ((2, "quant_parameter_tensor_names", "quantParameterTensorNames"), (message (module StringStringEntryProto)), not_packed) ^:: nil )
    let to_proto' =
      let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
      fun writer { tensor_name; quant_parameter_tensor_names } -> serialize writer tensor_name quant_parameter_tensor_names

    let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
    let from_proto_exn =
      let constructor tensor_name quant_parameter_tensor_names = { tensor_name; quant_parameter_tensor_names } 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 { tensor_name; quant_parameter_tensor_names } -> serialize tensor_name quant_parameter_tensor_names
    let from_json_exn =
      let constructor tensor_name quant_parameter_tensor_names = { tensor_name; quant_parameter_tensor_names } 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 GraphProto : sig
    type t = {
    node: NodeProto.t list;(** The nodes in the graph, sorted topologically. *)
    name: string option;(** The name of the graph.


    namespace Graph *)
    initializer': TensorProto.t list;(** A list of named tensor values, used to specify constant inputs of the
    graph. Each initializer (both TensorProto as well SparseTensorProto) MUST
    have a name. The name MUST be unique across both initializer and
    sparse_initializer, but the name MAY also appear in the input list. *)
    doc_string: string option;(** A human-readable documentation for this graph. Markdown is allowed. *)
    input: ValueInfoProto.t list;(** The inputs and outputs of the graph. *)
    output: ValueInfoProto.t list;
    value_info: ValueInfoProto.t list;(** Information for the values in the graph. The ValueInfoProto.name's
    must be distinct. It is optional for a value to appear in value_info list. *)
    quantization_annotation: TensorAnnotation.t list;(** This field carries information to indicate the mapping among a tensor and
    its quantization parameter tensors. For example: For tensor 'a', it may
    have \{'SCALE_TENSOR', 'a_scale'\} and \{'ZERO_POINT_TENSOR', 'a_zero_point'\}
    annotated, which means, tensor 'a_scale' and tensor 'a_zero_point' are
    scale and zero point of tensor 'a' in the model. *)
    sparse_initializer: SparseTensorProto.t list;(** Initializers (see above) stored in sparse format. *)
    }
    val make: ?node:NodeProto.t list -> ?name:string -> ?initializer':TensorProto.t list -> ?doc_string:string -> ?input:ValueInfoProto.t list -> ?output:ValueInfoProto.t list -> ?value_info:ValueInfoProto.t list -> ?quantization_annotation:TensorAnnotation.t list -> ?sparse_initializer:SparseTensorProto.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 = ?node:NodeProto.t list -> ?name:string -> ?initializer':TensorProto.t list -> ?doc_string:string -> ?input:ValueInfoProto.t list -> ?output:ValueInfoProto.t list -> ?value_info:ValueInfoProto.t list -> ?quantization_annotation:TensorAnnotation.t list -> ?sparse_initializer:SparseTensorProto.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'_ = GraphProto
    let name () = ".onnx.GraphProto"
    type t = {
    node: NodeProto.t list;(** The nodes in the graph, sorted topologically. *)
    name: string option;(** The name of the graph.


    namespace Graph *)
    initializer': TensorProto.t list;(** A list of named tensor values, used to specify constant inputs of the
    graph. Each initializer (both TensorProto as well SparseTensorProto) MUST
    have a name. The name MUST be unique across both initializer and
    sparse_initializer, but the name MAY also appear in the input list. *)
    doc_string: string option;(** A human-readable documentation for this graph. Markdown is allowed. *)
    input: ValueInfoProto.t list;(** The inputs and outputs of the graph. *)
    output: ValueInfoProto.t list;
    value_info: ValueInfoProto.t list;(** Information for the values in the graph. The ValueInfoProto.name's
    must be distinct. It is optional for a value to appear in value_info list. *)
    quantization_annotation: TensorAnnotation.t list;(** This field carries information to indicate the mapping among a tensor and
    its quantization parameter tensors. For example: For tensor 'a', it may
    have \{'SCALE_TENSOR', 'a_scale'\} and \{'ZERO_POINT_TENSOR', 'a_zero_point'\}
    annotated, which means, tensor 'a_scale' and tensor 'a_zero_point' are
    scale and zero point of tensor 'a' in the model. *)
    sparse_initializer: SparseTensorProto.t list;(** Initializers (see above) stored in sparse format. *)
    }
    type make_t = ?node:NodeProto.t list -> ?name:string -> ?initializer':TensorProto.t list -> ?doc_string:string -> ?input:ValueInfoProto.t list -> ?output:ValueInfoProto.t list -> ?value_info:ValueInfoProto.t list -> ?quantization_annotation:TensorAnnotation.t list -> ?sparse_initializer:SparseTensorProto.t list -> unit -> t
    let make ?(node = []) ?name ?(initializer' = []) ?doc_string ?(input = []) ?(output = []) ?(value_info = []) ?(quantization_annotation = []) ?(sparse_initializer = []) () = { node; name; initializer'; doc_string; input; output; value_info; quantization_annotation; sparse_initializer }
    let merge =
    let merge_node = Runtime'.Merge.merge Runtime'.Spec.( repeated ((1, "node", "node"), (message (module NodeProto)), not_packed) ) in
    let merge_name = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((2, "name", "name"), string) ) in
    let merge_initializer' = Runtime'.Merge.merge Runtime'.Spec.( repeated ((5, "initializer", "initializer"), (message (module TensorProto)), not_packed) ) in
    let merge_doc_string = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((10, "doc_string", "docString"), string) ) in
    let merge_input = Runtime'.Merge.merge Runtime'.Spec.( repeated ((11, "input", "input"), (message (module ValueInfoProto)), not_packed) ) in
    let merge_output = Runtime'.Merge.merge Runtime'.Spec.( repeated ((12, "output", "output"), (message (module ValueInfoProto)), not_packed) ) in
    let merge_value_info = Runtime'.Merge.merge Runtime'.Spec.( repeated ((13, "value_info", "valueInfo"), (message (module ValueInfoProto)), not_packed) ) in
    let merge_quantization_annotation = Runtime'.Merge.merge Runtime'.Spec.( repeated ((14, "quantization_annotation", "quantizationAnnotation"), (message (module TensorAnnotation)), not_packed) ) in
    let merge_sparse_initializer = Runtime'.Merge.merge Runtime'.Spec.( repeated ((15, "sparse_initializer", "sparseInitializer"), (message (module SparseTensorProto)), not_packed) ) in
    fun t1 t2 -> {
    node = (merge_node t1.node t2.node);
    name = (merge_name t1.name t2.name);
    initializer' = (merge_initializer' t1.initializer' t2.initializer');
    doc_string = (merge_doc_string t1.doc_string t2.doc_string);
    input = (merge_input t1.input t2.input);
    output = (merge_output t1.output t2.output);
    value_info = (merge_value_info t1.value_info t2.value_info);
    quantization_annotation = (merge_quantization_annotation t1.quantization_annotation t2.quantization_annotation);
    sparse_initializer = (merge_sparse_initializer t1.sparse_initializer t2.sparse_initializer);
     }
    let spec () = Runtime'.Spec.( repeated ((1, "node", "node"), (message (module NodeProto)), not_packed) ^:: basic_opt ((2, "name", "name"), string) ^:: repeated ((5, "initializer", "initializer"), (message (module TensorProto)), not_packed) ^:: basic_opt ((10, "doc_string", "docString"), string) ^:: repeated ((11, "input", "input"), (message (module ValueInfoProto)), not_packed) ^:: repeated ((12, "output", "output"), (message (module ValueInfoProto)), not_packed) ^:: repeated ((13, "value_info", "valueInfo"), (message (module ValueInfoProto)), not_packed) ^:: repeated ((14, "quantization_annotation", "quantizationAnnotation"), (message (module TensorAnnotation)), not_packed) ^:: repeated ((15, "sparse_initializer", "sparseInitializer"), (message (module SparseTensorProto)), not_packed) ^:: nil )
    let to_proto' =
      let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
      fun writer { node; name; initializer'; doc_string; input; output; value_info; quantization_annotation; sparse_initializer } -> serialize writer node name initializer' doc_string input output value_info quantization_annotation sparse_initializer

    let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
    let from_proto_exn =
      let constructor node name initializer' doc_string input output value_info quantization_annotation sparse_initializer = { node; name; initializer'; doc_string; input; output; value_info; quantization_annotation; sparse_initializer } 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 { node; name; initializer'; doc_string; input; output; value_info; quantization_annotation; sparse_initializer } -> serialize node name initializer' doc_string input output value_info quantization_annotation sparse_initializer
    let from_json_exn =
      let constructor node name initializer' doc_string input output value_info quantization_annotation sparse_initializer = { node; name; initializer'; doc_string; input; output; value_info; quantization_annotation; sparse_initializer } 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 TensorProto : sig
    module rec DataType : sig
      type t =
        | UNDEFINED
        | FLOAT
        (**
          Basic types.


          float
        *)
        | UINT8
        (** uint8_t *)
        | INT8
        (** int8_t *)
        | UINT16
        (** uint16_t *)
        | INT16
        (** int16_t *)
        | INT32
        (** int32_t *)
        | INT64
        (** int64_t *)
        | STRING
        (** string *)
        | BOOL
        (** bool *)
        | FLOAT16
        (**
          IEEE754 half-precision floating-point format (16 bits wide).
          This format has 1 sign bit, 5 exponent bits, and 10 mantissa bits.
        *)
        | DOUBLE
        | UINT32
        | UINT64
        | COMPLEX64
        (** complex with float32 real and imaginary components *)
        | COMPLEX128
        (** complex with float64 real and imaginary components *)
        | BFLOAT16
        (**
          Non-IEEE floating-point format based on IEEE754 single-precision
          floating-point number truncated to 16 bits.
          This format has 1 sign bit, 8 exponent bits, and 7 mantissa bits.
        *)

      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

    (**
      Location of the data for this tensor. MUST be one of:
      - DEFAULT - data stored inside the protobuf message. Data is stored in
      raw_data (if set) otherwise in type-specified field.
      - EXTERNAL - data stored in an external location as described by
      external_data field.
    *)
    and DataLocation : sig
      type t =
        | DEFAULT
        | EXTERNAL

      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

    (**
      For very large tensors, we may want to store them in chunks, in which
      case the following fields will specify the segment that is stored in
      the current TensorProto.
    *)
    and Segment : sig
      type t = {
      begin': int64 option;
      end': int64 option;
      }
      val make: ?begin':int64 -> ?end':int64 -> 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 = ?begin':int64 -> ?end':int64 -> 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 = {
    dims: int64 list;(** The shape of the tensor. *)
    data_type: DataType.t option;(** The data type of the tensor.
    This field MUST have a valid TensorProto.DataType value *)
    segment: Segment.t option;
    float_data: float list;(** For float and complex64 values
    Complex64 tensors are encoded as a single array of floats,
    with the real components appearing in odd numbered positions,
    and the corresponding imaginary component appearing in the
    subsequent even numbered position. (e.g., \[1.0 + 2.0i, 3.0 + 4.0i\]
    is encoded as \[1.0, 2.0 ,3.0 ,4.0\]
    When this field is present, the data_type field MUST be FLOAT or COMPLEX64. *)
    int32_data: int32 list;(** For int32, uint8, int8, uint16, int16, bool, and float16 values
    float16 values must be bit-wise converted to an uint16_t prior
    to writing to the buffer.
    When this field is present, the data_type field MUST be
    INT32, INT16, INT8, UINT16, UINT8, BOOL, or FLOAT16 *)
    string_data: bytes list;(** For strings.
    Each element of string_data is a UTF-8 encoded Unicode
    string. No trailing null, no leading BOM. The protobuf "string"
    scalar type is not used to match ML community conventions.
    When this field is present, the data_type field MUST be STRING *)
    int64_data: int64 list;(** For int64.
    When this field is present, the data_type field MUST be INT64 *)
    name: string option;(** Optionally, a name for the tensor.


    namespace Value *)
    raw_data: bytes option;(** Serializations can either use one of the fields above, or use this
    raw bytes field. The only exception is the string case, where one is
    required to store the content in the repeated bytes string_data field.

    When this raw_data field is used to store tensor value, elements MUST
    be stored in as fixed-width, little-endian order.
    Floating-point data types MUST be stored in IEEE 754 format.
    Complex64 elements must be written as two consecutive FLOAT values, real
    component first. Complex128 elements must be written as two consecutive
    DOUBLE values, real component first. Boolean type MUST be written one byte
    per tensor element (00000001 for true, 00000000 for false).

    Note: the advantage of specific field rather than the raw_data field is
    that in some cases (e.g. int data), protobuf does a better packing via
    variable length storage, and may lead to smaller binary footprint.
    When this field is present, the data_type field MUST NOT be STRING or
    UNDEFINED *)
    double_data: float list;(** For double
    Complex128 tensors are encoded as a single array of doubles,
    with the real components appearing in odd numbered positions,
    and the corresponding imaginary component appearing in the
    subsequent even numbered position. (e.g., \[1.0 + 2.0i, 3.0 + 4.0i\]
    is encoded as \[1.0, 2.0 ,3.0 ,4.0\]
    When this field is present, the data_type field MUST be DOUBLE or
    COMPLEX128 *)
    uint64_data: int64 list;(** For uint64 and uint32 values
    When this field is present, the data_type field MUST be
    UINT32 or UINT64 *)
    doc_string: string option;(** A human-readable documentation for this tensor. Markdown is allowed. *)
    external_data: StringStringEntryProto.t list;(** Data can be stored inside the protobuf file using type-specific fields or
    raw_data. Alternatively, raw bytes data can be stored in an external file,
    using the external_data field. external_data stores key-value pairs
    describing data location. Recognized keys are:
    - "location" (required) - POSIX filesystem path relative to the directory
    where the ONNX
    {v
                               protobuf model was stored
    v}
    - "offset" (optional) - position of byte at which stored data begins.
    Integer stored as string.
    {v
                             Offset values SHOULD be multiples 4096 (page size)
                             to enable mmap support.
    v}
    - "length" (optional) - number of bytes containing data. Integer stored as
    string.
    - "checksum" (optional) - SHA1 digest of file specified in under 'location'
    key. *)
    data_location: DataLocation.t option;(** If value not set, data is stored in raw_data (if set) otherwise in
    type-specified field. *)
    }
    val make: ?dims:int64 list -> ?data_type:DataType.t -> ?segment:Segment.t -> ?float_data:float list -> ?int32_data:int32 list -> ?string_data:bytes list -> ?int64_data:int64 list -> ?name:string -> ?raw_data:bytes -> ?double_data:float list -> ?uint64_data:int64 list -> ?doc_string:string -> ?external_data:StringStringEntryProto.t list -> ?data_location:DataLocation.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 = ?dims:int64 list -> ?data_type:DataType.t -> ?segment:Segment.t -> ?float_data:float list -> ?int32_data:int32 list -> ?string_data:bytes list -> ?int64_data:int64 list -> ?name:string -> ?raw_data:bytes -> ?double_data:float list -> ?uint64_data:int64 list -> ?doc_string:string -> ?external_data:StringStringEntryProto.t list -> ?data_location:DataLocation.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'_ = TensorProto
    module rec DataType : sig
      type t =
        | UNDEFINED
        | FLOAT
        (**
          Basic types.


          float
        *)
        | UINT8
        (** uint8_t *)
        | INT8
        (** int8_t *)
        | UINT16
        (** uint16_t *)
        | INT16
        (** int16_t *)
        | INT32
        (** int32_t *)
        | INT64
        (** int64_t *)
        | STRING
        (** string *)
        | BOOL
        (** bool *)
        | FLOAT16
        (**
          IEEE754 half-precision floating-point format (16 bits wide).
          This format has 1 sign bit, 5 exponent bits, and 10 mantissa bits.
        *)
        | DOUBLE
        | UINT32
        | UINT64
        | COMPLEX64
        (** complex with float32 real and imaginary components *)
        | COMPLEX128
        (** complex with float64 real and imaginary components *)
        | BFLOAT16
        (**
          Non-IEEE floating-point format based on IEEE754 single-precision
          floating-point number truncated to 16 bits.
          This format has 1 sign bit, 8 exponent bits, and 7 mantissa bits.
        *)

      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'_ = DataType
      type t =
        | UNDEFINED
        | FLOAT
        (**
          Basic types.


          float
        *)
        | UINT8
        (** uint8_t *)
        | INT8
        (** int8_t *)
        | UINT16
        (** uint16_t *)
        | INT16
        (** int16_t *)
        | INT32
        (** int32_t *)
        | INT64
        (** int64_t *)
        | STRING
        (** string *)
        | BOOL
        (** bool *)
        | FLOAT16
        (**
          IEEE754 half-precision floating-point format (16 bits wide).
          This format has 1 sign bit, 5 exponent bits, and 10 mantissa bits.
        *)
        | DOUBLE
        | UINT32
        | UINT64
        | COMPLEX64
        (** complex with float32 real and imaginary components *)
        | COMPLEX128
        (** complex with float64 real and imaginary components *)
        | BFLOAT16
        (**
          Non-IEEE floating-point format based on IEEE754 single-precision
          floating-point number truncated to 16 bits.
          This format has 1 sign bit, 8 exponent bits, and 7 mantissa bits.
        *)

      let name () = ".onnx.TensorProto.DataType"
      let to_int = function
        | UNDEFINED -> 0
        | FLOAT -> 1
        | UINT8 -> 2
        | INT8 -> 3
        | UINT16 -> 4
        | INT16 -> 5
        | INT32 -> 6
        | INT64 -> 7
        | STRING -> 8
        | BOOL -> 9
        | FLOAT16 -> 10
        | DOUBLE -> 11
        | UINT32 -> 12
        | UINT64 -> 13
        | COMPLEX64 -> 14
        | COMPLEX128 -> 15
        | BFLOAT16 -> 16
      let from_int_exn = function
        | 0 -> UNDEFINED
        | 1 -> FLOAT
        | 2 -> UINT8
        | 3 -> INT8
        | 4 -> UINT16
        | 5 -> INT16
        | 6 -> INT32
        | 7 -> INT64
        | 8 -> STRING
        | 9 -> BOOL
        | 10 -> FLOAT16
        | 11 -> DOUBLE
        | 12 -> UINT32
        | 13 -> UINT64
        | 14 -> COMPLEX64
        | 15 -> COMPLEX128
        | 16 -> BFLOAT16
        | n -> Runtime'.Result.raise (`Unknown_enum_value n)
      let from_int e = Runtime'.Result.catch (fun () -> from_int_exn e)
      let to_string = function
        | UNDEFINED -> "UNDEFINED"
        | FLOAT -> "FLOAT"
        | UINT8 -> "UINT8"
        | INT8 -> "INT8"
        | UINT16 -> "UINT16"
        | INT16 -> "INT16"
        | INT32 -> "INT32"
        | INT64 -> "INT64"
        | STRING -> "STRING"
        | BOOL -> "BOOL"
        | FLOAT16 -> "FLOAT16"
        | DOUBLE -> "DOUBLE"
        | UINT32 -> "UINT32"
        | UINT64 -> "UINT64"
        | COMPLEX64 -> "COMPLEX64"
        | COMPLEX128 -> "COMPLEX128"
        | BFLOAT16 -> "BFLOAT16"
      let from_string_exn = function
        | "UNDEFINED" -> UNDEFINED
        | "FLOAT" -> FLOAT
        | "UINT8" -> UINT8
        | "INT8" -> INT8
        | "UINT16" -> UINT16
        | "INT16" -> INT16
        | "INT32" -> INT32
        | "INT64" -> INT64
        | "STRING" -> STRING
        | "BOOL" -> BOOL
        | "FLOAT16" -> FLOAT16
        | "DOUBLE" -> DOUBLE
        | "UINT32" -> UINT32
        | "UINT64" -> UINT64
        | "COMPLEX64" -> COMPLEX64
        | "COMPLEX128" -> COMPLEX128
        | "BFLOAT16" -> BFLOAT16
        | s -> Runtime'.Result.raise (`Unknown_enum_name s)

    end
    and DataLocation : sig
      type t =
        | DEFAULT
        | EXTERNAL

      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'_ = DataLocation
      type t =
        | DEFAULT
        | EXTERNAL

      let name () = ".onnx.TensorProto.DataLocation"
      let to_int = function
        | DEFAULT -> 0
        | EXTERNAL -> 1
      let from_int_exn = function
        | 0 -> DEFAULT
        | 1 -> EXTERNAL
        | 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 -> "DEFAULT"
        | EXTERNAL -> "EXTERNAL"
      let from_string_exn = function
        | "DEFAULT" -> DEFAULT
        | "EXTERNAL" -> EXTERNAL
        | s -> Runtime'.Result.raise (`Unknown_enum_name s)

    end
    and Segment : sig
      type t = {
      begin': int64 option;
      end': int64 option;
      }
      val make: ?begin':int64 -> ?end':int64 -> 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 = ?begin':int64 -> ?end':int64 -> 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'_ = Segment
      let name () = ".onnx.TensorProto.Segment"
      type t = {
      begin': int64 option;
      end': int64 option;
      }
      type make_t = ?begin':int64 -> ?end':int64 -> unit -> t
      let make ?begin' ?end' () = { begin'; end' }
      let merge =
      let merge_begin' = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((1, "begin", "begin"), int64) ) in
      let merge_end' = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((2, "end", "end"), int64) ) in
      fun t1 t2 -> {
      begin' = (merge_begin' t1.begin' t2.begin');
      end' = (merge_end' t1.end' t2.end');
       }
      let spec () = Runtime'.Spec.( basic_opt ((1, "begin", "begin"), int64) ^:: basic_opt ((2, "end", "end"), int64) ^:: nil )
      let to_proto' =
        let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
        fun writer { begin'; end' } -> serialize writer begin' end'

      let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
      let from_proto_exn =
        let constructor begin' end' = { begin'; 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 { begin'; end' } -> serialize begin' end'
      let from_json_exn =
        let constructor begin' end' = { begin'; 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 () = ".onnx.TensorProto"
    type t = {
    dims: int64 list;(** The shape of the tensor. *)
    data_type: DataType.t option;(** The data type of the tensor.
    This field MUST have a valid TensorProto.DataType value *)
    segment: Segment.t option;
    float_data: float list;(** For float and complex64 values
    Complex64 tensors are encoded as a single array of floats,
    with the real components appearing in odd numbered positions,
    and the corresponding imaginary component appearing in the
    subsequent even numbered position. (e.g., \[1.0 + 2.0i, 3.0 + 4.0i\]
    is encoded as \[1.0, 2.0 ,3.0 ,4.0\]
    When this field is present, the data_type field MUST be FLOAT or COMPLEX64. *)
    int32_data: int32 list;(** For int32, uint8, int8, uint16, int16, bool, and float16 values
    float16 values must be bit-wise converted to an uint16_t prior
    to writing to the buffer.
    When this field is present, the data_type field MUST be
    INT32, INT16, INT8, UINT16, UINT8, BOOL, or FLOAT16 *)
    string_data: bytes list;(** For strings.
    Each element of string_data is a UTF-8 encoded Unicode
    string. No trailing null, no leading BOM. The protobuf "string"
    scalar type is not used to match ML community conventions.
    When this field is present, the data_type field MUST be STRING *)
    int64_data: int64 list;(** For int64.
    When this field is present, the data_type field MUST be INT64 *)
    name: string option;(** Optionally, a name for the tensor.


    namespace Value *)
    raw_data: bytes option;(** Serializations can either use one of the fields above, or use this
    raw bytes field. The only exception is the string case, where one is
    required to store the content in the repeated bytes string_data field.

    When this raw_data field is used to store tensor value, elements MUST
    be stored in as fixed-width, little-endian order.
    Floating-point data types MUST be stored in IEEE 754 format.
    Complex64 elements must be written as two consecutive FLOAT values, real
    component first. Complex128 elements must be written as two consecutive
    DOUBLE values, real component first. Boolean type MUST be written one byte
    per tensor element (00000001 for true, 00000000 for false).

    Note: the advantage of specific field rather than the raw_data field is
    that in some cases (e.g. int data), protobuf does a better packing via
    variable length storage, and may lead to smaller binary footprint.
    When this field is present, the data_type field MUST NOT be STRING or
    UNDEFINED *)
    double_data: float list;(** For double
    Complex128 tensors are encoded as a single array of doubles,
    with the real components appearing in odd numbered positions,
    and the corresponding imaginary component appearing in the
    subsequent even numbered position. (e.g., \[1.0 + 2.0i, 3.0 + 4.0i\]
    is encoded as \[1.0, 2.0 ,3.0 ,4.0\]
    When this field is present, the data_type field MUST be DOUBLE or
    COMPLEX128 *)
    uint64_data: int64 list;(** For uint64 and uint32 values
    When this field is present, the data_type field MUST be
    UINT32 or UINT64 *)
    doc_string: string option;(** A human-readable documentation for this tensor. Markdown is allowed. *)
    external_data: StringStringEntryProto.t list;(** Data can be stored inside the protobuf file using type-specific fields or
    raw_data. Alternatively, raw bytes data can be stored in an external file,
    using the external_data field. external_data stores key-value pairs
    describing data location. Recognized keys are:
    - "location" (required) - POSIX filesystem path relative to the directory
    where the ONNX
    {v
                               protobuf model was stored
    v}
    - "offset" (optional) - position of byte at which stored data begins.
    Integer stored as string.
    {v
                             Offset values SHOULD be multiples 4096 (page size)
                             to enable mmap support.
    v}
    - "length" (optional) - number of bytes containing data. Integer stored as
    string.
    - "checksum" (optional) - SHA1 digest of file specified in under 'location'
    key. *)
    data_location: DataLocation.t option;(** If value not set, data is stored in raw_data (if set) otherwise in
    type-specified field. *)
    }
    type make_t = ?dims:int64 list -> ?data_type:DataType.t -> ?segment:Segment.t -> ?float_data:float list -> ?int32_data:int32 list -> ?string_data:bytes list -> ?int64_data:int64 list -> ?name:string -> ?raw_data:bytes -> ?double_data:float list -> ?uint64_data:int64 list -> ?doc_string:string -> ?external_data:StringStringEntryProto.t list -> ?data_location:DataLocation.t -> unit -> t
    let make ?(dims = []) ?data_type ?segment ?(float_data = []) ?(int32_data = []) ?(string_data = []) ?(int64_data = []) ?name ?raw_data ?(double_data = []) ?(uint64_data = []) ?doc_string ?(external_data = []) ?data_location () = { dims; data_type; segment; float_data; int32_data; string_data; int64_data; name; raw_data; double_data; uint64_data; doc_string; external_data; data_location }
    let merge =
    let merge_dims = Runtime'.Merge.merge Runtime'.Spec.( repeated ((1, "dims", "dims"), int64, not_packed) ) in
    let merge_data_type = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((2, "data_type", "dataType"), (enum (module DataType))) ) in
    let merge_segment = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((3, "segment", "segment"), (message (module Segment))) ) in
    let merge_float_data = Runtime'.Merge.merge Runtime'.Spec.( repeated ((4, "float_data", "floatData"), float, packed) ) in
    let merge_int32_data = Runtime'.Merge.merge Runtime'.Spec.( repeated ((5, "int32_data", "int32Data"), int32, packed) ) in
    let merge_string_data = Runtime'.Merge.merge Runtime'.Spec.( repeated ((6, "string_data", "stringData"), bytes, not_packed) ) in
    let merge_int64_data = Runtime'.Merge.merge Runtime'.Spec.( repeated ((7, "int64_data", "int64Data"), int64, packed) ) in
    let merge_name = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((8, "name", "name"), string) ) in
    let merge_raw_data = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((9, "raw_data", "rawData"), bytes) ) in
    let merge_double_data = Runtime'.Merge.merge Runtime'.Spec.( repeated ((10, "double_data", "doubleData"), double, packed) ) in
    let merge_uint64_data = Runtime'.Merge.merge Runtime'.Spec.( repeated ((11, "uint64_data", "uint64Data"), uint64, packed) ) in
    let merge_doc_string = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((12, "doc_string", "docString"), string) ) in
    let merge_external_data = Runtime'.Merge.merge Runtime'.Spec.( repeated ((13, "external_data", "externalData"), (message (module StringStringEntryProto)), not_packed) ) in
    let merge_data_location = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((14, "data_location", "dataLocation"), (enum (module DataLocation))) ) in
    fun t1 t2 -> {
    dims = (merge_dims t1.dims t2.dims);
    data_type = (merge_data_type t1.data_type t2.data_type);
    segment = (merge_segment t1.segment t2.segment);
    float_data = (merge_float_data t1.float_data t2.float_data);
    int32_data = (merge_int32_data t1.int32_data t2.int32_data);
    string_data = (merge_string_data t1.string_data t2.string_data);
    int64_data = (merge_int64_data t1.int64_data t2.int64_data);
    name = (merge_name t1.name t2.name);
    raw_data = (merge_raw_data t1.raw_data t2.raw_data);
    double_data = (merge_double_data t1.double_data t2.double_data);
    uint64_data = (merge_uint64_data t1.uint64_data t2.uint64_data);
    doc_string = (merge_doc_string t1.doc_string t2.doc_string);
    external_data = (merge_external_data t1.external_data t2.external_data);
    data_location = (merge_data_location t1.data_location t2.data_location);
     }
    let spec () = Runtime'.Spec.( repeated ((1, "dims", "dims"), int64, not_packed) ^:: basic_opt ((2, "data_type", "dataType"), (enum (module DataType))) ^:: basic_opt ((3, "segment", "segment"), (message (module Segment))) ^:: repeated ((4, "float_data", "floatData"), float, packed) ^:: repeated ((5, "int32_data", "int32Data"), int32, packed) ^:: repeated ((6, "string_data", "stringData"), bytes, not_packed) ^:: repeated ((7, "int64_data", "int64Data"), int64, packed) ^:: basic_opt ((8, "name", "name"), string) ^:: basic_opt ((9, "raw_data", "rawData"), bytes) ^:: repeated ((10, "double_data", "doubleData"), double, packed) ^:: repeated ((11, "uint64_data", "uint64Data"), uint64, packed) ^:: basic_opt ((12, "doc_string", "docString"), string) ^:: repeated ((13, "external_data", "externalData"), (message (module StringStringEntryProto)), not_packed) ^:: basic_opt ((14, "data_location", "dataLocation"), (enum (module DataLocation))) ^:: nil )
    let to_proto' =
      let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
      fun writer { dims; data_type; segment; float_data; int32_data; string_data; int64_data; name; raw_data; double_data; uint64_data; doc_string; external_data; data_location } -> serialize writer dims data_type segment float_data int32_data string_data int64_data name raw_data double_data uint64_data doc_string external_data data_location

    let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
    let from_proto_exn =
      let constructor dims data_type segment float_data int32_data string_data int64_data name raw_data double_data uint64_data doc_string external_data data_location = { dims; data_type; segment; float_data; int32_data; string_data; int64_data; name; raw_data; double_data; uint64_data; doc_string; external_data; data_location } 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 { dims; data_type; segment; float_data; int32_data; string_data; int64_data; name; raw_data; double_data; uint64_data; doc_string; external_data; data_location } -> serialize dims data_type segment float_data int32_data string_data int64_data name raw_data double_data uint64_data doc_string external_data data_location
    let from_json_exn =
      let constructor dims data_type segment float_data int32_data string_data int64_data name raw_data double_data uint64_data doc_string external_data data_location = { dims; data_type; segment; float_data; int32_data; string_data; int64_data; name; raw_data; double_data; uint64_data; doc_string; external_data; data_location } 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 SparseTensorProto : sig
    type t = {
    values: TensorProto.t option;(** The sequence of non-default values are encoded as a tensor of shape \[NNZ\].
    The default-value is zero for numeric tensors, and empty-string for string
    tensors. values must have a non-empty name present which serves as a name
    for SparseTensorProto when used in sparse_initializer list. *)
    indices: TensorProto.t option;(** The indices of the non-default values, which may be stored in one of two
    formats. (a) Indices can be a tensor of shape \[NNZ, rank\] with the \[i,j\]-th
    value corresponding to the j-th index of the i-th value (in the values
    tensor). (b) Indices can be a tensor of shape \[NNZ\], in which case the i-th
    value must be the linearized-index of the i-th value (in the values
    tensor). The linearized-index can be converted into an index tuple
    (k_1,...,k_rank) using the shape provided below. The indices must appear in
    ascending order without duplication. In the first format, the ordering is
    lexicographic-ordering: e.g., index-value \[1,4\] must appear before \[2,1\] *)
    dims: int64 list;(** The shape of the underlying dense-tensor: \[dim_1, dim_2, ... dim_rank\] *)
    }
    val make: ?values:TensorProto.t -> ?indices:TensorProto.t -> ?dims:int64 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 = ?values:TensorProto.t -> ?indices:TensorProto.t -> ?dims:int64 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'_ = SparseTensorProto
    let name () = ".onnx.SparseTensorProto"
    type t = {
    values: TensorProto.t option;(** The sequence of non-default values are encoded as a tensor of shape \[NNZ\].
    The default-value is zero for numeric tensors, and empty-string for string
    tensors. values must have a non-empty name present which serves as a name
    for SparseTensorProto when used in sparse_initializer list. *)
    indices: TensorProto.t option;(** The indices of the non-default values, which may be stored in one of two
    formats. (a) Indices can be a tensor of shape \[NNZ, rank\] with the \[i,j\]-th
    value corresponding to the j-th index of the i-th value (in the values
    tensor). (b) Indices can be a tensor of shape \[NNZ\], in which case the i-th
    value must be the linearized-index of the i-th value (in the values
    tensor). The linearized-index can be converted into an index tuple
    (k_1,...,k_rank) using the shape provided below. The indices must appear in
    ascending order without duplication. In the first format, the ordering is
    lexicographic-ordering: e.g., index-value \[1,4\] must appear before \[2,1\] *)
    dims: int64 list;(** The shape of the underlying dense-tensor: \[dim_1, dim_2, ... dim_rank\] *)
    }
    type make_t = ?values:TensorProto.t -> ?indices:TensorProto.t -> ?dims:int64 list -> unit -> t
    let make ?values ?indices ?(dims = []) () = { values; indices; dims }
    let merge =
    let merge_values = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((1, "values", "values"), (message (module TensorProto))) ) in
    let merge_indices = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((2, "indices", "indices"), (message (module TensorProto))) ) in
    let merge_dims = Runtime'.Merge.merge Runtime'.Spec.( repeated ((3, "dims", "dims"), int64, not_packed) ) in
    fun t1 t2 -> {
    values = (merge_values t1.values t2.values);
    indices = (merge_indices t1.indices t2.indices);
    dims = (merge_dims t1.dims t2.dims);
     }
    let spec () = Runtime'.Spec.( basic_opt ((1, "values", "values"), (message (module TensorProto))) ^:: basic_opt ((2, "indices", "indices"), (message (module TensorProto))) ^:: repeated ((3, "dims", "dims"), int64, not_packed) ^:: nil )
    let to_proto' =
      let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
      fun writer { values; indices; dims } -> serialize writer values indices dims

    let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
    let from_proto_exn =
      let constructor values indices dims = { values; indices; dims } 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 { values; indices; dims } -> serialize values indices dims
    let from_json_exn =
      let constructor values indices dims = { values; indices; dims } 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 TensorShapeProto : sig
    module rec Dimension : sig
      type t = {
      value: [ `not_set | `Dim_value of int64 | `Dim_param of string ];
      denotation: string option;(** Standard denotation can optionally be used to denote tensor
      dimensions with standard semantic descriptions to ensure
      that operations are applied to the correct axis of a tensor.
      Refer to
      https://github.com/onnx/onnx/blob/master/docs/DimensionDenotation.md#denotation-definition
      for pre-defined dimension denotations. *)
      }
      val make: ?value:[ `not_set | `Dim_value of int64 | `Dim_param of string ] -> ?denotation: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 = ?value:[ `not_set | `Dim_value of int64 | `Dim_param of string ] -> ?denotation: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 = (Dimension.t list)
    val make: ?dim:Dimension.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 = ?dim:Dimension.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'_ = TensorShapeProto
    module rec Dimension : sig
      type t = {
      value: [ `not_set | `Dim_value of int64 | `Dim_param of string ];
      denotation: string option;(** Standard denotation can optionally be used to denote tensor
      dimensions with standard semantic descriptions to ensure
      that operations are applied to the correct axis of a tensor.
      Refer to
      https://github.com/onnx/onnx/blob/master/docs/DimensionDenotation.md#denotation-definition
      for pre-defined dimension denotations. *)
      }
      val make: ?value:[ `not_set | `Dim_value of int64 | `Dim_param of string ] -> ?denotation: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 = ?value:[ `not_set | `Dim_value of int64 | `Dim_param of string ] -> ?denotation: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'_ = Dimension
      let name () = ".onnx.TensorShapeProto.Dimension"
      type t = {
      value: [ `not_set | `Dim_value of int64 | `Dim_param of string ];
      denotation: string option;(** Standard denotation can optionally be used to denote tensor
      dimensions with standard semantic descriptions to ensure
      that operations are applied to the correct axis of a tensor.
      Refer to
      https://github.com/onnx/onnx/blob/master/docs/DimensionDenotation.md#denotation-definition
      for pre-defined dimension denotations. *)
      }
      type make_t = ?value:[ `not_set | `Dim_value of int64 | `Dim_param of string ] -> ?denotation:string -> unit -> t
      let make ?(value = `not_set) ?denotation () = { value; denotation }
      let merge =
      let merge_oneof_value__Dim_value = Runtime'.Merge.merge Runtime'.Spec.( basic_req ((0, "", ""), int64) ) in
      let merge_oneof_value__Dim_param = Runtime'.Merge.merge Runtime'.Spec.( basic_req ((0, "", ""), string) ) in
      let merge_denotation = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((3, "denotation", "denotation"), string) ) in
      fun t1 t2 -> {
      value = (match (t1.value, t2.value) with
      | (`Dim_value v1, `Dim_value v2) -> `Dim_value (merge_oneof_value__Dim_value v1 v2)
      | (`Dim_param v1, `Dim_param v2) -> `Dim_param (merge_oneof_value__Dim_param v1 v2)
      | (v1, `not_set) -> v1
      | (_, v2) -> v2);
      denotation = (merge_denotation t1.denotation t2.denotation);
       }
      let spec () = Runtime'.Spec.( oneof (([ oneof_elem ((1, "dim_value", "dimValue"), int64, ((fun v -> `Dim_value v), (function `Dim_value v -> v | _ -> raise (Invalid_argument "Cannot destruct given oneof")))); oneof_elem ((2, "dim_param", "dimParam"), string, ((fun v -> `Dim_param v), (function `Dim_param v -> v | _ -> raise (Invalid_argument "Cannot destruct given oneof")))) ], (function | `not_set -> failwith "Impossible case" | `Dim_value _ -> 0 | `Dim_param _ -> 1))) ^:: basic_opt ((3, "denotation", "denotation"), string) ^:: nil )
      let to_proto' =
        let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
        fun writer { value; denotation } -> serialize writer value denotation

      let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
      let from_proto_exn =
        let constructor value denotation = { value; denotation } 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; denotation } -> serialize value denotation
      let from_json_exn =
        let constructor value denotation = { value; denotation } 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 () = ".onnx.TensorShapeProto"
    type t = (Dimension.t list)
    type make_t = ?dim:Dimension.t list -> unit -> t
    let make ?(dim = []) () = (dim)
    let merge =
    let merge_dim = Runtime'.Merge.merge Runtime'.Spec.( repeated ((1, "dim", "dim"), (message (module Dimension)), not_packed) ) in
    fun (t1_dim) (t2_dim) -> merge_dim t1_dim t2_dim
    let spec () = Runtime'.Spec.( repeated ((1, "dim", "dim"), (message (module Dimension)), not_packed) ^:: nil )
    let to_proto' =
      let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
      fun writer (dim) -> serialize writer dim

    let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
    let from_proto_exn =
      let constructor dim = (dim) 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 (dim) -> serialize dim
    let from_json_exn =
      let constructor dim = (dim) 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 TypeProto : sig
    module rec Tensor : sig
      type t = {
      elem_type: TensorProto.DataType.t option;(** This field MUST NOT have the value of UNDEFINED
      This field MUST have a valid TensorProto.DataType value
      This field MUST be present for this version of the IR. *)
      shape: TensorShapeProto.t option;
      }
      val make: ?elem_type:TensorProto.DataType.t -> ?shape:TensorShapeProto.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 = ?elem_type:TensorProto.DataType.t -> ?shape:TensorShapeProto.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

    (** repeated T *)
    and Sequence : sig
      type t = (TypeProto.t option)
      (**
      The type and optional shape of each element of the sequence.
      This field MUST be present for this version of the IR.
      *)

      val make: ?elem_type:TypeProto.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 = ?elem_type:TypeProto.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

    (** map<K,V> *)
    and Map : sig
      type t = {
      key_type: TensorProto.DataType.t option;(** This field MUST have a valid TensorProto.DataType value
      This field MUST be present for this version of the IR.
      This field MUST refer to an integral type (\[U\]INT\{8|16|32|64\}) or STRING *)
      value_type: TypeProto.t option;(** This field MUST be present for this version of the IR. *)
      }
      val make: ?key_type:TensorProto.DataType.t -> ?value_type:TypeProto.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 = ?key_type:TensorProto.DataType.t -> ?value_type:TypeProto.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

    (** wrapper for Tensor, Sequence, or Map *)
    and Optional : sig
      type t = (TypeProto.t option)
      (**
      The type and optional shape of the element wrapped.
      This field MUST be present for this version of the IR.
      Possible values correspond to OptionalProto.DataType enum
      *)

      val make: ?elem_type:TypeProto.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 = ?elem_type:TypeProto.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 SparseTensor : sig
      type t = {
      elem_type: TensorProto.DataType.t option;(** This field MUST NOT have the value of UNDEFINED
      This field MUST have a valid TensorProto.DataType value
      This field MUST be present for this version of the IR. *)
      shape: TensorShapeProto.t option;
      }
      val make: ?elem_type:TensorProto.DataType.t -> ?shape:TensorShapeProto.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 = ?elem_type:TensorProto.DataType.t -> ?shape:TensorShapeProto.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 = {
    value: [ `not_set | `Tensor_type of Tensor.t | `Sequence_type of Sequence.t | `Map_type of Map.t | `Sparse_tensor_type of SparseTensor.t | `Optional_type of Optional.t ];
    denotation: string option;(** An optional denotation can be used to denote the whole
    type with a standard semantic description as to what is
    stored inside. Refer to
    https://github.com/onnx/onnx/blob/master/docs/TypeDenotation.md#type-denotation-definition
    for pre-defined type denotations. *)
    }
    val make: ?value:[ `not_set | `Tensor_type of Tensor.t | `Sequence_type of Sequence.t | `Map_type of Map.t | `Sparse_tensor_type of SparseTensor.t | `Optional_type of Optional.t ] -> ?denotation: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 = ?value:[ `not_set | `Tensor_type of Tensor.t | `Sequence_type of Sequence.t | `Map_type of Map.t | `Sparse_tensor_type of SparseTensor.t | `Optional_type of Optional.t ] -> ?denotation: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'_ = TypeProto
    module rec Tensor : sig
      type t = {
      elem_type: TensorProto.DataType.t option;(** This field MUST NOT have the value of UNDEFINED
      This field MUST have a valid TensorProto.DataType value
      This field MUST be present for this version of the IR. *)
      shape: TensorShapeProto.t option;
      }
      val make: ?elem_type:TensorProto.DataType.t -> ?shape:TensorShapeProto.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 = ?elem_type:TensorProto.DataType.t -> ?shape:TensorShapeProto.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'_ = Tensor
      let name () = ".onnx.TypeProto.Tensor"
      type t = {
      elem_type: TensorProto.DataType.t option;(** This field MUST NOT have the value of UNDEFINED
      This field MUST have a valid TensorProto.DataType value
      This field MUST be present for this version of the IR. *)
      shape: TensorShapeProto.t option;
      }
      type make_t = ?elem_type:TensorProto.DataType.t -> ?shape:TensorShapeProto.t -> unit -> t
      let make ?elem_type ?shape () = { elem_type; shape }
      let merge =
      let merge_elem_type = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((1, "elem_type", "elemType"), (enum (module TensorProto.DataType))) ) in
      let merge_shape = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((2, "shape", "shape"), (message (module TensorShapeProto))) ) in
      fun t1 t2 -> {
      elem_type = (merge_elem_type t1.elem_type t2.elem_type);
      shape = (merge_shape t1.shape t2.shape);
       }
      let spec () = Runtime'.Spec.( basic_opt ((1, "elem_type", "elemType"), (enum (module TensorProto.DataType))) ^:: basic_opt ((2, "shape", "shape"), (message (module TensorShapeProto))) ^:: nil )
      let to_proto' =
        let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
        fun writer { elem_type; shape } -> serialize writer elem_type shape

      let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
      let from_proto_exn =
        let constructor elem_type shape = { elem_type; shape } 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 { elem_type; shape } -> serialize elem_type shape
      let from_json_exn =
        let constructor elem_type shape = { elem_type; shape } 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 Sequence : sig
      type t = (TypeProto.t option)
      (**
      The type and optional shape of each element of the sequence.
      This field MUST be present for this version of the IR.
      *)

      val make: ?elem_type:TypeProto.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 = ?elem_type:TypeProto.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'_ = Sequence
      let name () = ".onnx.TypeProto.Sequence"
      type t = (TypeProto.t option)
      (**
      The type and optional shape of each element of the sequence.
      This field MUST be present for this version of the IR.
      *)

      type make_t = ?elem_type:TypeProto.t -> unit -> t
      let make ?elem_type () = (elem_type)
      let merge =
      let merge_elem_type = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((1, "elem_type", "elemType"), (message (module TypeProto))) ) in
      fun (t1_elem_type) (t2_elem_type) -> merge_elem_type t1_elem_type t2_elem_type
      let spec () = Runtime'.Spec.( basic_opt ((1, "elem_type", "elemType"), (message (module TypeProto))) ^:: nil )
      let to_proto' =
        let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
        fun writer (elem_type) -> serialize writer elem_type

      let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
      let from_proto_exn =
        let constructor elem_type = (elem_type) 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 (elem_type) -> serialize elem_type
      let from_json_exn =
        let constructor elem_type = (elem_type) 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 Map : sig
      type t = {
      key_type: TensorProto.DataType.t option;(** This field MUST have a valid TensorProto.DataType value
      This field MUST be present for this version of the IR.
      This field MUST refer to an integral type (\[U\]INT\{8|16|32|64\}) or STRING *)
      value_type: TypeProto.t option;(** This field MUST be present for this version of the IR. *)
      }
      val make: ?key_type:TensorProto.DataType.t -> ?value_type:TypeProto.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 = ?key_type:TensorProto.DataType.t -> ?value_type:TypeProto.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'_ = Map
      let name () = ".onnx.TypeProto.Map"
      type t = {
      key_type: TensorProto.DataType.t option;(** This field MUST have a valid TensorProto.DataType value
      This field MUST be present for this version of the IR.
      This field MUST refer to an integral type (\[U\]INT\{8|16|32|64\}) or STRING *)
      value_type: TypeProto.t option;(** This field MUST be present for this version of the IR. *)
      }
      type make_t = ?key_type:TensorProto.DataType.t -> ?value_type:TypeProto.t -> unit -> t
      let make ?key_type ?value_type () = { key_type; value_type }
      let merge =
      let merge_key_type = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((1, "key_type", "keyType"), (enum (module TensorProto.DataType))) ) in
      let merge_value_type = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((2, "value_type", "valueType"), (message (module TypeProto))) ) in
      fun t1 t2 -> {
      key_type = (merge_key_type t1.key_type t2.key_type);
      value_type = (merge_value_type t1.value_type t2.value_type);
       }
      let spec () = Runtime'.Spec.( basic_opt ((1, "key_type", "keyType"), (enum (module TensorProto.DataType))) ^:: basic_opt ((2, "value_type", "valueType"), (message (module TypeProto))) ^:: nil )
      let to_proto' =
        let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
        fun writer { key_type; value_type } -> serialize writer key_type value_type

      let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
      let from_proto_exn =
        let constructor key_type value_type = { key_type; value_type } 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 { key_type; value_type } -> serialize key_type value_type
      let from_json_exn =
        let constructor key_type value_type = { key_type; value_type } 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 Optional : sig
      type t = (TypeProto.t option)
      (**
      The type and optional shape of the element wrapped.
      This field MUST be present for this version of the IR.
      Possible values correspond to OptionalProto.DataType enum
      *)

      val make: ?elem_type:TypeProto.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 = ?elem_type:TypeProto.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'_ = Optional
      let name () = ".onnx.TypeProto.Optional"
      type t = (TypeProto.t option)
      (**
      The type and optional shape of the element wrapped.
      This field MUST be present for this version of the IR.
      Possible values correspond to OptionalProto.DataType enum
      *)

      type make_t = ?elem_type:TypeProto.t -> unit -> t
      let make ?elem_type () = (elem_type)
      let merge =
      let merge_elem_type = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((1, "elem_type", "elemType"), (message (module TypeProto))) ) in
      fun (t1_elem_type) (t2_elem_type) -> merge_elem_type t1_elem_type t2_elem_type
      let spec () = Runtime'.Spec.( basic_opt ((1, "elem_type", "elemType"), (message (module TypeProto))) ^:: nil )
      let to_proto' =
        let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
        fun writer (elem_type) -> serialize writer elem_type

      let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
      let from_proto_exn =
        let constructor elem_type = (elem_type) 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 (elem_type) -> serialize elem_type
      let from_json_exn =
        let constructor elem_type = (elem_type) 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 SparseTensor : sig
      type t = {
      elem_type: TensorProto.DataType.t option;(** This field MUST NOT have the value of UNDEFINED
      This field MUST have a valid TensorProto.DataType value
      This field MUST be present for this version of the IR. *)
      shape: TensorShapeProto.t option;
      }
      val make: ?elem_type:TensorProto.DataType.t -> ?shape:TensorShapeProto.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 = ?elem_type:TensorProto.DataType.t -> ?shape:TensorShapeProto.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'_ = SparseTensor
      let name () = ".onnx.TypeProto.SparseTensor"
      type t = {
      elem_type: TensorProto.DataType.t option;(** This field MUST NOT have the value of UNDEFINED
      This field MUST have a valid TensorProto.DataType value
      This field MUST be present for this version of the IR. *)
      shape: TensorShapeProto.t option;
      }
      type make_t = ?elem_type:TensorProto.DataType.t -> ?shape:TensorShapeProto.t -> unit -> t
      let make ?elem_type ?shape () = { elem_type; shape }
      let merge =
      let merge_elem_type = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((1, "elem_type", "elemType"), (enum (module TensorProto.DataType))) ) in
      let merge_shape = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((2, "shape", "shape"), (message (module TensorShapeProto))) ) in
      fun t1 t2 -> {
      elem_type = (merge_elem_type t1.elem_type t2.elem_type);
      shape = (merge_shape t1.shape t2.shape);
       }
      let spec () = Runtime'.Spec.( basic_opt ((1, "elem_type", "elemType"), (enum (module TensorProto.DataType))) ^:: basic_opt ((2, "shape", "shape"), (message (module TensorShapeProto))) ^:: nil )
      let to_proto' =
        let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
        fun writer { elem_type; shape } -> serialize writer elem_type shape

      let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
      let from_proto_exn =
        let constructor elem_type shape = { elem_type; shape } 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 { elem_type; shape } -> serialize elem_type shape
      let from_json_exn =
        let constructor elem_type shape = { elem_type; shape } 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 () = ".onnx.TypeProto"
    type t = {
    value: [ `not_set | `Tensor_type of Tensor.t | `Sequence_type of Sequence.t | `Map_type of Map.t | `Sparse_tensor_type of SparseTensor.t | `Optional_type of Optional.t ];
    denotation: string option;(** An optional denotation can be used to denote the whole
    type with a standard semantic description as to what is
    stored inside. Refer to
    https://github.com/onnx/onnx/blob/master/docs/TypeDenotation.md#type-denotation-definition
    for pre-defined type denotations. *)
    }
    type make_t = ?value:[ `not_set | `Tensor_type of Tensor.t | `Sequence_type of Sequence.t | `Map_type of Map.t | `Sparse_tensor_type of SparseTensor.t | `Optional_type of Optional.t ] -> ?denotation:string -> unit -> t
    let make ?(value = `not_set) ?denotation () = { value; denotation }
    let merge =
    let merge_oneof_value__Tensor_type = Runtime'.Merge.merge Runtime'.Spec.( basic_req ((0, "", ""), (message (module Tensor))) ) in
    let merge_oneof_value__Sequence_type = Runtime'.Merge.merge Runtime'.Spec.( basic_req ((0, "", ""), (message (module Sequence))) ) in
    let merge_oneof_value__Map_type = Runtime'.Merge.merge Runtime'.Spec.( basic_req ((0, "", ""), (message (module Map))) ) in
    let merge_oneof_value__Sparse_tensor_type = Runtime'.Merge.merge Runtime'.Spec.( basic_req ((0, "", ""), (message (module SparseTensor))) ) in
    let merge_oneof_value__Optional_type = Runtime'.Merge.merge Runtime'.Spec.( basic_req ((0, "", ""), (message (module Optional))) ) in
    let merge_denotation = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((6, "denotation", "denotation"), string) ) in
    fun t1 t2 -> {
    value = (match (t1.value, t2.value) with
    | (`Tensor_type v1, `Tensor_type v2) -> `Tensor_type (merge_oneof_value__Tensor_type v1 v2)
    | (`Sequence_type v1, `Sequence_type v2) -> `Sequence_type (merge_oneof_value__Sequence_type v1 v2)
    | (`Map_type v1, `Map_type v2) -> `Map_type (merge_oneof_value__Map_type v1 v2)
    | (`Sparse_tensor_type v1, `Sparse_tensor_type v2) -> `Sparse_tensor_type (merge_oneof_value__Sparse_tensor_type v1 v2)
    | (`Optional_type v1, `Optional_type v2) -> `Optional_type (merge_oneof_value__Optional_type v1 v2)
    | (v1, `not_set) -> v1
    | (_, v2) -> v2);
    denotation = (merge_denotation t1.denotation t2.denotation);
     }
    let spec () = Runtime'.Spec.( oneof (([ oneof_elem ((1, "tensor_type", "tensorType"), (message (module Tensor)), ((fun v -> `Tensor_type v), (function `Tensor_type v -> v | _ -> raise (Invalid_argument "Cannot destruct given oneof")))); oneof_elem ((4, "sequence_type", "sequenceType"), (message (module Sequence)), ((fun v -> `Sequence_type v), (function `Sequence_type v -> v | _ -> raise (Invalid_argument "Cannot destruct given oneof")))); oneof_elem ((5, "map_type", "mapType"), (message (module Map)), ((fun v -> `Map_type v), (function `Map_type v -> v | _ -> raise (Invalid_argument "Cannot destruct given oneof")))); oneof_elem ((8, "sparse_tensor_type", "sparseTensorType"), (message (module SparseTensor)), ((fun v -> `Sparse_tensor_type v), (function `Sparse_tensor_type v -> v | _ -> raise (Invalid_argument "Cannot destruct given oneof")))); oneof_elem ((9, "optional_type", "optionalType"), (message (module Optional)), ((fun v -> `Optional_type v), (function `Optional_type v -> v | _ -> raise (Invalid_argument "Cannot destruct given oneof")))) ], (function | `not_set -> failwith "Impossible case" | `Tensor_type _ -> 0 | `Sequence_type _ -> 1 | `Map_type _ -> 2 | `Sparse_tensor_type _ -> 3 | `Optional_type _ -> 4))) ^:: basic_opt ((6, "denotation", "denotation"), string) ^:: nil )
    let to_proto' =
      let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
      fun writer { value; denotation } -> serialize writer value denotation

    let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
    let from_proto_exn =
      let constructor value denotation = { value; denotation } 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; denotation } -> serialize value denotation
    let from_json_exn =
      let constructor value denotation = { value; denotation } 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 OperatorSetIdProto : sig
    type t = {
    domain: string option;(** The domain of the operator set being identified.
    The empty string ("") or absence of this field implies the operator
    set that is defined as part of the ONNX specification.
    This field MUST be present in this version of the IR when referring to any
    other operator set. *)
    version: int64 option;(** The version of the operator set being identified.
    This field MUST be present in this version of the IR. *)
    }
    val make: ?domain:string -> ?version:int64 -> 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 = ?domain:string -> ?version:int64 -> 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'_ = OperatorSetIdProto
    let name () = ".onnx.OperatorSetIdProto"
    type t = {
    domain: string option;(** The domain of the operator set being identified.
    The empty string ("") or absence of this field implies the operator
    set that is defined as part of the ONNX specification.
    This field MUST be present in this version of the IR when referring to any
    other operator set. *)
    version: int64 option;(** The version of the operator set being identified.
    This field MUST be present in this version of the IR. *)
    }
    type make_t = ?domain:string -> ?version:int64 -> unit -> t
    let make ?domain ?version () = { domain; version }
    let merge =
    let merge_domain = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((1, "domain", "domain"), string) ) in
    let merge_version = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((2, "version", "version"), int64) ) in
    fun t1 t2 -> {
    domain = (merge_domain t1.domain t2.domain);
    version = (merge_version t1.version t2.version);
     }
    let spec () = Runtime'.Spec.( basic_opt ((1, "domain", "domain"), string) ^:: basic_opt ((2, "version", "version"), int64) ^:: nil )
    let to_proto' =
      let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
      fun writer { domain; version } -> serialize writer domain version

    let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
    let from_proto_exn =
      let constructor domain version = { domain; version } 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 { domain; version } -> serialize domain version
    let from_json_exn =
      let constructor domain version = { domain; version } 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 FunctionProto : sig
    type t = {
    name: string option;(** The name of the function, similar usage of op_type in OperatorProto.
    Combined with FunctionProto.domain, this forms the unique identity of
    the FunctionProto. *)
    input: string list;(** The inputs and outputs of the function. *)
    output: string list;
    attribute: string list;(** The attributes of the function. *)
    node: NodeProto.t list;(** The nodes in the function. *)
    doc_string: string option;(** A human-readable documentation for this function. Markdown is allowed. *)
    opset_import: OperatorSetIdProto.t list;
    domain: string option;(** The domain which this function belongs to. Combined with
    FunctionProto.name, this forms the unique identity of the FunctionProto. *)
    }
    val make: ?name:string -> ?input:string list -> ?output:string list -> ?attribute:string list -> ?node:NodeProto.t list -> ?doc_string:string -> ?opset_import:OperatorSetIdProto.t list -> ?domain: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:string -> ?input:string list -> ?output:string list -> ?attribute:string list -> ?node:NodeProto.t list -> ?doc_string:string -> ?opset_import:OperatorSetIdProto.t list -> ?domain: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'_ = FunctionProto
    let name () = ".onnx.FunctionProto"
    type t = {
    name: string option;(** The name of the function, similar usage of op_type in OperatorProto.
    Combined with FunctionProto.domain, this forms the unique identity of
    the FunctionProto. *)
    input: string list;(** The inputs and outputs of the function. *)
    output: string list;
    attribute: string list;(** The attributes of the function. *)
    node: NodeProto.t list;(** The nodes in the function. *)
    doc_string: string option;(** A human-readable documentation for this function. Markdown is allowed. *)
    opset_import: OperatorSetIdProto.t list;
    domain: string option;(** The domain which this function belongs to. Combined with
    FunctionProto.name, this forms the unique identity of the FunctionProto. *)
    }
    type make_t = ?name:string -> ?input:string list -> ?output:string list -> ?attribute:string list -> ?node:NodeProto.t list -> ?doc_string:string -> ?opset_import:OperatorSetIdProto.t list -> ?domain:string -> unit -> t
    let make ?name ?(input = []) ?(output = []) ?(attribute = []) ?(node = []) ?doc_string ?(opset_import = []) ?domain () = { name; input; output; attribute; node; doc_string; opset_import; domain }
    let merge =
    let merge_name = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((1, "name", "name"), string) ) in
    let merge_input = Runtime'.Merge.merge Runtime'.Spec.( repeated ((4, "input", "input"), string, not_packed) ) in
    let merge_output = Runtime'.Merge.merge Runtime'.Spec.( repeated ((5, "output", "output"), string, not_packed) ) in
    let merge_attribute = Runtime'.Merge.merge Runtime'.Spec.( repeated ((6, "attribute", "attribute"), string, not_packed) ) in
    let merge_node = Runtime'.Merge.merge Runtime'.Spec.( repeated ((7, "node", "node"), (message (module NodeProto)), not_packed) ) in
    let merge_doc_string = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((8, "doc_string", "docString"), string) ) in
    let merge_opset_import = Runtime'.Merge.merge Runtime'.Spec.( repeated ((9, "opset_import", "opsetImport"), (message (module OperatorSetIdProto)), not_packed) ) in
    let merge_domain = Runtime'.Merge.merge Runtime'.Spec.( basic_opt ((10, "domain", "domain"), string) ) in
    fun t1 t2 -> {
    name = (merge_name t1.name t2.name);
    input = (merge_input t1.input t2.input);
    output = (merge_output t1.output t2.output);
    attribute = (merge_attribute t1.attribute t2.attribute);
    node = (merge_node t1.node t2.node);
    doc_string = (merge_doc_string t1.doc_string t2.doc_string);
    opset_import = (merge_opset_import t1.opset_import t2.opset_import);
    domain = (merge_domain t1.domain t2.domain);
     }
    let spec () = Runtime'.Spec.( basic_opt ((1, "name", "name"), string) ^:: repeated ((4, "input", "input"), string, not_packed) ^:: repeated ((5, "output", "output"), string, not_packed) ^:: repeated ((6, "attribute", "attribute"), string, not_packed) ^:: repeated ((7, "node", "node"), (message (module NodeProto)), not_packed) ^:: basic_opt ((8, "doc_string", "docString"), string) ^:: repeated ((9, "opset_import", "opsetImport"), (message (module OperatorSetIdProto)), not_packed) ^:: basic_opt ((10, "domain", "domain"), string) ^:: nil )
    let to_proto' =
      let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
      fun writer { name; input; output; attribute; node; doc_string; opset_import; domain } -> serialize writer name input output attribute node doc_string opset_import domain

    let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
    let from_proto_exn =
      let constructor name input output attribute node doc_string opset_import domain = { name; input; output; attribute; node; doc_string; opset_import; domain } 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; output; attribute; node; doc_string; opset_import; domain } -> serialize name input output attribute node doc_string opset_import domain
    let from_json_exn =
      let constructor name input output attribute node doc_string opset_import domain = { name; input; output; attribute; node; doc_string; opset_import; domain } 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