type loc =
  Hgen_types.loc = {
  file : string;
  line : int;
  offset : int;
  bol : int;
}
exception Lexical_error of loc * string
exception Syntax_error of loc
exception Other_error of loc * string
exception Noloc_error of string
module CiString :
  sig
    type t = string
    val equal : string -> string -> bool
    val hash : string -> int
    val compare : string -> string -> int
  end
module CiHashtbl :
  sig
    type key = CiString.t
    type 'a t = 'a Hashtbl.Make(CiString).t
    val create : int -> 'a t
    val clear : 'a t -> unit
    val copy : 'a t -> 'a t
    val add : 'a t -> key -> 'a -> unit
    val remove : 'a t -> key -> unit
    val find : 'a t -> key -> 'a
    val find_all : 'a t -> key -> 'a list
    val replace : 'a t -> key -> 'a -> unit
    val mem : 'a t -> key -> bool
    val iter : (key -> 'a -> unit) -> 'a t -> unit
    val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
    val length : 'a t -> int
  end
module StrSet :
  sig
    type elt = String.t
    type t = Set.Make(String).t
    val empty : t
    val is_empty : t -> bool
    val mem : elt -> t -> bool
    val add : elt -> t -> t
    val singleton : elt -> t
    val remove : elt -> t -> t
    val union : t -> t -> t
    val inter : t -> t -> t
    val diff : t -> t -> t
    val compare : t -> t -> int
    val equal : t -> t -> bool
    val subset : t -> t -> bool
    val iter : (elt -> unit) -> t -> unit
    val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
    val for_all : (elt -> bool) -> t -> bool
    val exists : (elt -> bool) -> t -> bool
    val filter : (elt -> bool) -> t -> t
    val partition : (elt -> bool) -> t -> t * t
    val cardinal : t -> int
    val elements : t -> elt list
    val min_elt : t -> elt
    val max_elt : t -> elt
    val choose : t -> elt
    val split : elt -> t -> t * bool * t
  end
module CiSet :
  sig
    type elt = CiString.t
    type t = Set.Make(CiString).t
    val empty : t
    val is_empty : t -> bool
    val mem : elt -> t -> bool
    val add : elt -> t -> t
    val singleton : elt -> t
    val remove : elt -> t -> t
    val union : t -> t -> t
    val inter : t -> t -> t
    val diff : t -> t -> t
    val compare : t -> t -> int
    val equal : t -> t -> bool
    val subset : t -> t -> bool
    val iter : (elt -> unit) -> t -> unit
    val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
    val for_all : (elt -> bool) -> t -> bool
    val exists : (elt -> bool) -> t -> bool
    val filter : (elt -> bool) -> t -> t
    val partition : (elt -> bool) -> t -> t * t
    val cardinal : t -> int
    val elements : t -> elt list
    val min_elt : t -> elt
    val max_elt : t -> elt
    val choose : t -> elt
    val split : elt -> t -> t * bool * t
  end
module CiMap :
  sig
    type key = CiString.t
    type 'a t = 'a Map.Make(CiString).t
    val empty : 'a t
    val is_empty : 'a t -> bool
    val add : key -> 'a -> 'a t -> 'a t
    val find : key -> 'a t -> 'a
    val remove : key -> 'a t -> 'a t
    val mem : key -> 'a t -> bool
    val iter : (key -> 'a -> unit) -> 'a t -> unit
    val map : ('a -> 'b) -> 'a t -> 'b t
    val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
    val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
    val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
    val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
  end
type single_meta_def =
    [ `Global_default_immutable
    | `Global_default_int
    | `Global_default_int32
    | `Global_default_mutable
    | `Global_defmapping of string * string * string * string
    | `Global_reserve_structprefix of string
    | `Local_equals of string
    | `Local_immutable
    | `Local_int
    | `Local_int32
    | `Local_mapping of string
    | `Local_mutable
    | `Local_name of string
    | `Local_structprefix of string
    | `Local_tuple
    | `Nonmutating
    | `Other of string ]
module AST :
  sig
    type def =
        [ `Class of class_def
        | `Const of const_def
        | `Dict of dict_def
        | `Enum of enum_def
        | `Exn of exn_def
        | `GMeta of meta_def
        | `Intf of intf_def
        | `Module of module_def
        | `Seq of seq_def
        | `Struct of struct_def ]
    and module_def =
        < loc : loc; meta : meta_def; name : string; term : def list >
    and class_def =
        < loc : loc; local : bool; meta : meta_def; name : string;
          term : class_term option >
    and class_term =
        < data_members : data_member list; extends : name option;
          implements : name list; operations : operation list >
    and intf_def =
        < loc : loc; local : bool; meta : meta_def; name : string;
          term : intf_term option >
    and intf_term = < extends : name list; operations : operation list >
    and exn_def =
        < loc : loc; local : bool; meta : meta_def; name : string;
          term : exn_term option >
    and exn_term = < data_members : data_member list; extends : name option >
    and struct_def =
        < loc : loc; local : bool; meta : meta_def; name : string;
          term : struct_term option >
    and struct_term = < data_members : data_member list >
    and seq_def =
        < arg_meta : meta_def; arg_typ : typ; loc : loc; local : bool;
          meta : meta_def; name : string >
    and dict_def =
        < arg_meta1 : meta_def; arg_meta2 : meta_def; arg_typ1 : typ;
          arg_typ2 : typ; loc : loc; local : bool; meta : meta_def;
          name : string >
    and enum_def =
        < loc : loc; local : bool; meta : meta_def; name : string;
          term : string list >
    and const_def =
        < arg_meta : meta_def; arg_typ : typ; arg_value : value; loc : 
          loc; meta : meta_def; name : string >
    and data_member =
        < loc : loc; meta : meta_def; name : string; typ : typ >
    and operation =
        < idempotent : bool; loc : loc; meta : meta_def; name : string;
          params : param list; throws : name list; typ : typ >
    and param =
        < loc : loc; meta : meta_def; name : string; out : bool; typ : typ >
    and typ =
        [ `Bool
        | `Byte
        | `Double
        | `Float
        | `Int
        | `Long
        | `Name of name
        | `Proxy of name
        | `Short
        | `String
        | `Void ]
    and value =
        [ `Bool of bool
        | `Float of float
        | `Int of int64
        | `Name of name
        | `String of string ]
    and meta_def = single_meta_def list
    and name = [ `Absolute of string list | `Relative of string list ]
  end
module TS :
  sig
    type name = [ `Absolute of string list ]
    type meta_def = single_meta_def list
    type ty =
        [ `Bool
        | `Byte
        | `Byteseq
        | `Dictionary of ty * ty
        | `Double
        | `Enum of string array
        | `Float
        | `Int
        | `Int32
        | `Long
        | `Named of htype
        | `Object of name
        | `Proxy of name
        | `Sequence of ty
        | `Short
        | `String
        | `Struct of (string * string * ty * bool) array * string option
        | `Struct_tuple of (string * ty) array
        | `User_mapping of ty * string * string * string
        | `Void ]
    and hnamed =
        < defflag : bool; local : bool; mapped_name : string;
          meta : meta_def; name : name >
    and htype =
        < defflag : bool; local : bool; mapped_name : string;
          meta : meta_def; name : name; term : ty >
    and hexn =
        < data_elements : (string * string * ty) array; defflag : bool;
          local : bool; mapped_name : string; meta : meta_def; name : 
          name; super : hexn option >
    and hobject =
        < data_elements : (string * string * ty) array; defflag : bool;
          imported_from : string option; local : bool; mapped_name : 
          string; meta : meta_def; name : name;
          objtype : [ `Class | `Interface ]; op_elements : hfunction list;
          super : hobject option; super_intf : hobject list >
    and hfunction =
        < in_args : (string * string * ty) array; in_classes : bool;
          mapped_name : string; meta : meta_def; mode : op_mode;
          name : string; out_args : (string * string * ty) array;
          out_classes : bool; result : ty; throws : hexn list >
    and hmodule = < mapped_name : string; meta : meta_def; name : name >
    and hconst =
        [ `Bool of bool
        | `Float of float
        | `Int of int
        | `Int32 of int32
        | `Int64 of int64
        | `String of string ]
    and op_mode = [ `Idempotent | `Nonmutating | `Normal ]
    type entity =
        [ `Const of name * string * hconst
        | `Exn of hexn
        | `Module of hmodule
        | `Object of hobject
        | `Type of htype ]
  end
module IL :
  sig
    type type_term =
        [ `Alist of type_term * type_term
        | `Array of type_term
        | `Bool
        | `Char
        | `Float
        | `Fun of type_term * type_term
        | `Int
        | `Int32
        | `Int64
        | `Named of string
        | `Named_arg1 of type_term * string
        | `Object of string list * (