sig
  type 'a t = 'a t
  module Tag_internal :
    sig
      type ('variant, 'args) create =
          Args of ('args -> 'variant)
        | Const of 'variant
      type ('variant, 'args) t = {
        label : string;
        rep : 'args t;
        arity : int;
        index : int;
        ocaml_repr : int;
        tyid : 'args Typename.t;
        create : ('variant, 'args) create;
      }
    end
  module Tag :
    sig
      type ('variant, 'args) create =
          Args of ('args -> 'variant)
        | Const of 'variant
      type ('variant, 'args) t
      val label : ('a, 'b) t -> string
      val arity : ('a, 'b) t -> int
      val index : ('a, 'b) t -> int
      val ocaml_repr : ('a, 'b) t -> int
      val create : ('variant, 'args) t -> ('variant, 'args) create
      val tyid : ('a, 'args) t -> 'args Typename.t
      val traverse : ('a, 'args) t -> 'args t
      val internal_use_only : ('a, 'b) Tag_internal.t -> ('a, 'b) t
    end
  module Variant_internal :
    sig
      type _ tag = Tag : ('variant, 'a) Tag.t -> 'variant tag
      type _ value = Value : ('variant, 'a) Tag.t * '-> 'variant value
      type 'a t = {
        typename : 'Typename.t;
        tags : 'a tag array;
        polymorphic : bool;
        value : '-> 'a value;
      }
    end
  module Variant :
    sig
      type _ tag = Tag : ('variant, 'args) Tag.t -> 'variant tag
      type _ value =
          Value : ('variant, 'args) Tag.t * 'args -> 'variant value
      type 'a t
      val typename_of_t : 'a t -> 'Typename.t
      val length : 'a t -> int
      val tag : 'a t -> int -> 'a tag
      val is_polymorphic : 'a t -> bool
      val value : 'a t -> '-> 'a value
      val fold : 'a t -> init:'acc -> f:('acc -> 'a tag -> 'acc) -> 'acc
      val internal_use_only : 'Variant_internal.t -> 'a t
    end
  module Field_internal :
    sig
      type ('record, 'field) t = {
        label : string;
        rep : 'field t;
        index : int;
        tyid : 'field Typename.t;
        get : 'record -> 'field;
      }
    end
  module Field :
    sig
      type ('record, 'field) t
      val label : ('a, 'b) t -> string
      val index : ('a, 'b) t -> int
      val get : ('record, 'field) t -> 'record -> 'field
      val tyid : ('a, 'field) t -> 'field Typename.t
      val traverse : ('a, 'field) t -> 'field t
      val internal_use_only : ('a, 'b) Field_internal.t -> ('a, 'b) t
    end
  module Record_internal :
    sig
      type _ field = Field : ('record, 'a) Field.t -> 'record field
      type 'record fields = {
        get : 'field. ('record, 'field) Field.t -> 'field;
      }
      type 'a t = {
        typename : 'Typename.t;
        fields : 'a field array;
        has_double_array_tag : bool;
        create : 'a fields -> 'a;
      }
    end
  module Record :
    sig
      type _ field = Field : ('record, 'a) Field.t -> 'record field
      type 'record fields = {
        get : 'field. ('record, 'field) Field.t -> 'field;
      }
      type 'a t
      val typename_of_t : 'a t -> 'Typename.t
      val length : 'a t -> int
      val field : 'a t -> int -> 'a field
      val has_double_array_tag : 'a t -> bool
      val create : 'a t -> 'a fields -> 'a
      val fold : 'a t -> init:'acc -> f:('acc -> 'a field -> 'acc) -> 'acc
      val internal_use_only : 'Record_internal.t -> 'a t
    end
  val int : int t
  val int32 : int32 t
  val int64 : int64 t
  val nativeint : nativeint t
  val char : char t
  val float : float t
  val string : string t
  val bool : bool t
  val unit : unit t
  val option : 'a t -> 'a option t
  val list : 'a t -> 'a list t
  val array : 'a t -> 'a array t
  val lazy_t : 'a t -> 'a lazy_t t
  val ref_ : 'a t -> 'a ref t
  val function_ : 'a t -> 'b t -> ('-> 'b) t
  val tuple2 : 'a t -> 'b t -> ('a * 'b) t
  val tuple3 : 'a t -> 'b t -> 'c t -> ('a * 'b * 'c) t
  val tuple4 : 'a t -> 'b t -> 'c t -> 'd t -> ('a * 'b * 'c * 'd) t
  val tuple5 :
    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> ('a * 'b * 'c * 'd * 'e) t
  val record : 'Record.t -> 'a t
  val variant : 'Variant.t -> 'a t
  module Named :
    sig
      module Context : sig type t val create : unit -> t end
      type 'a t
      val init : Context.t -> 'Typename.t -> 'a t
      val get_wip_computation : 'a t -> 'a t
      val set_final_computation : 'a t -> 'a t -> 'a t
      val share : 'Std_internal.Typerep.t -> bool
    end
end