sig
  type act_semantics = Sequential | Synchronous
  type fsm_config = {
    mutable act_sep : string;
    mutable act_sem : Fsm.act_semantics;
  }
  val cfg : Fsm.fsm_config
  exception Undef_symbol of string * string * string
  exception Invalid_state of string * string
  exception Typing_error of string * string * Types.typ * Types.typ
  module State :
    sig
      type t = string
      val compare : Fsm.State.t -> Fsm.State.t -> int
      val to_string : Fsm.State.t -> Fsm.State.t
    end
  module TransLabel :
    sig
      type t = Condition.t * Action.t list * int * bool
      val compare : Fsm.TransLabel.t -> Fsm.TransLabel.t -> int
      val to_string : Fsm.TransLabel.t -> string
      val rename : (string -> string) -> Fsm.TransLabel.t -> Fsm.TransLabel.t
      val subst : Eval.env -> Fsm.TransLabel.t -> Fsm.TransLabel.t
      val is_rtl : Fsm.TransLabel.t -> bool
    end
  module Repr :
    sig
      type state = State.t
      type label = TransLabel.t
      module Repr :
        sig
          type state = state
          type label = label
          type attr = unit
          type transition = state * label * state
          type itransition = label * state
          type t
          module State :
            sig
              type t = state
              val compare : t -> t -> int
              val to_string : t -> string
            end
          module Label :
            sig
              type t = label
              val compare : t -> t -> int
              val to_string : t -> string
            end
          module Attr : sig type t = attr val to_string : t -> string end
          module States :
            sig
              type elt = state
              type 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 min_elt_opt : t -> elt option
              val max_elt : t -> elt
              val max_elt_opt : t -> elt option
              val choose : t -> elt
              val choose_opt : t -> elt option
              val split : elt -> t -> t * bool * t
              val find : elt -> t -> elt
              val find_opt : elt -> t -> elt option
              val find_first : (elt -> bool) -> t -> elt
              val find_first_opt : (elt -> bool) -> t -> elt option
              val find_last : (elt -> bool) -> t -> elt
              val find_last_opt : (elt -> bool) -> t -> elt option
              val of_list : elt list -> t
              module Elt :
                sig
                  type t = elt
                  val compare : t -> t -> int
                  val to_string : t -> string
                end
              val map : (elt -> elt) -> t -> t
              val power : t -> t list
              val extract : t -> elt * t
              val to_string : t -> string
            end
          module Attrs :
            sig
              type key = state
              type +'a t
              val empty : 'a t
              val is_empty : 'a t -> bool
              val mem : key -> 'a t -> bool
              val add : key -> 'a -> 'a t -> 'a t
              val update : key -> ('a option -> 'a option) -> 'a t -> 'a t
              val singleton : key -> 'a -> 'a t
              val remove : key -> 'a t -> 'a t
              val merge :
                (key -> 'a option -> 'b option -> 'c option) ->
                'a t -> 'b t -> 'c t
              val union :
                (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
              val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
              val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
              val iter : (key -> 'a -> unit) -> 'a t -> unit
              val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
              val for_all : (key -> 'a -> bool) -> 'a t -> bool
              val exists : (key -> 'a -> bool) -> 'a t -> bool
              val filter : (key -> 'a -> bool) -> 'a t -> 'a t
              val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
              val cardinal : 'a t -> int
              val bindings : 'a t -> (key * 'a) list
              val min_binding : 'a t -> key * 'a
              val min_binding_opt : 'a t -> (key * 'a) option
              val max_binding : 'a t -> key * 'a
              val max_binding_opt : 'a t -> (key * 'a) option
              val choose : 'a t -> key * 'a
              val choose_opt : 'a t -> (key * 'a) option
              val split : key -> 'a t -> 'a t * 'a option * 'a t
              val find : key -> 'a t -> 'a
              val find_opt : key -> 'a t -> 'a option
              val find_first : (key -> bool) -> 'a t -> key * 'a
              val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
              val find_last : (key -> bool) -> 'a t -> key * 'a
              val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
              val map : ('a -> 'b) -> 'a t -> 'b t
              val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
            end
          module Tree :
            sig
              type node = state
              type edge = label
              type t = Empty | Node of node * (t * edge) list
              val fold : (node -> node -> node) -> node -> t -> node
              val dot_output :
                string ->
                string -> ?options:Utils.Dot.graph_style list -> t -> unit
              val dot_view :
                string ->
                ?options:Utils.Dot.graph_style list ->
                ?dir:string -> ?cmd:string -> t -> int
            end
          val states : t -> States.t
          val states' : t -> (state * attr) list
          val istates : t -> States.t
          val istates' : t -> state list
          val transitions : t -> transition list
          val itransitions : t -> itransition list
          val string_of_state : state -> string
          val string_of_label : label -> string
          val string_of_attr : attr -> string
          val is_state : t -> state -> bool
          val is_init_state : t -> state -> bool
          val is_reachable : t -> state -> bool
          val is_transition : t -> transition -> bool
          val succs : t -> state -> States.t
          val succs' : t -> state -> (state * label) list
          val preds : t -> state -> States.t
          val preds' : t -> state -> (state * label) list
          val succs_hat : t -> state -> States.t
          val preds_hat : t -> state -> States.t
          val attr_of : t -> state -> attr
          val empty : t
          val create :
            states:(state * attr) list ->
            itrans:(label * state) list ->
            trans:(state * label * state) list -> t
          val add_state : state * attr -> t -> t
          exception Invalid_state of state
          val add_transition : state * label * state -> t -> t
          val add_itransition : label * state -> t -> t
          val remove_state : state -> t -> t
          val iter_states : (state -> attr -> unit) -> t -> unit
          val fold_states : (state -> attr -> 'a -> 'a) -> t -> 'a -> 'a
          val iter_transitions : (transition -> unit) -> t -> unit
          val fold_transitions : (transition -> 'a -> 'a) -> t -> 'a -> 'a
          val iter_itransitions : (itransition -> unit) -> t -> unit
          val fold_itransitions : (itransition -> 'a -> 'a) -> t -> 'a -> 'a
          val fold_succs :
            t -> state -> (state -> label -> 'a -> 'a) -> 'a -> 'a
          val iter_succs : t -> state -> (state -> label -> unit) -> unit
          val fold_preds :
            t -> state -> (state -> label -> 'a -> 'a) -> 'a -> 'a
          val iter_preds : t -> state -> (state -> label -> unit) -> unit
          val map_state : (state -> state) -> t -> t
          val map_attr : (attr -> attr) -> t -> t
          val map_label : (label -> label) -> t -> t
          val clean : t -> t
          val unwind : int -> t -> Tree.t list
          val dot_output :
            string ->
            ?fname:string ->
            ?options:Utils.Dot.graph_style list ->
            ?marked_states:(state * Utils.Dot.node_style) list ->
            ?extra_nodes:(string * Utils.Dot.node_style) list ->
            ?implicit_transitions:transition list -> t -> unit
          val dot_output_oc :
            string ->
            out_channel ->
            ?options:Utils.Dot.graph_style list ->
            ?marked_states:(state * Utils.Dot.node_style) list ->
            ?extra_nodes:(string * Utils.Dot.node_style) list ->
            ?implicit_transitions:transition list -> t -> unit
          val dot_output_execs :
            string ->
            ?fname:string ->
            ?options:Utils.Dot.graph_style list -> int -> t -> unit
          val tex_output :
            string ->
            ?fname:string ->
            ?listed_transitions:label list option -> t -> unit
        end
      type t = Repr.t
      val repr_of : t -> Repr.t
      val of_repr : Repr.t -> t
      type transition = state * label * state
      type itransition = label * state
      module State :
        sig
          type t = state
          val compare : t -> t -> int
          val to_string : t -> string
        end
      module Label :
        sig
          type t = label
          val compare : t -> t -> int
          val to_string : t -> string
        end
      module States :
        sig
          type elt = state
          type 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 map : (elt -> elt) -> t -> t
          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 min_elt_opt : t -> elt option
          val max_elt : t -> elt
          val max_elt_opt : t -> elt option
          val choose : t -> elt
          val choose_opt : t -> elt option
          val split : elt -> t -> t * bool * t
          val find : elt -> t -> elt
          val find_opt : elt -> t -> elt option
          val find_first : (elt -> bool) -> t -> elt
          val find_first_opt : (elt -> bool) -> t -> elt option
          val find_last : (elt -> bool) -> t -> elt
          val find_last_opt : (elt -> bool) -> t -> elt option
          val of_list : elt list -> t
        end
      val states : t -> States.t
      val states' : t -> state list
      val istates : t -> States.t
      val istates' : t -> state list
      val transitions : t -> transition list
      val itransitions : t -> itransition list
      val string_of_state : state -> string
      val string_of_label : label -> string
      val string_of_transition : transition -> string
      val is_state : t -> state -> bool
      val is_init_state : t -> state -> bool
      val is_reachable : t -> state -> bool
      val is_transition : t -> transition -> bool
      val succs : t -> state -> States.t
      val succs' : t -> state -> (state * label) list
      val preds : t -> state -> States.t
      val preds' : t -> state -> (state * label) list
      val succs_hat : t -> state -> States.t
      val preds_hat : t -> state -> States.t
      val empty : t
      val create :
        states:state list ->
        itrans:(label * state) list ->
        trans:(state * label * state) list -> t
      val add_state : state -> t -> t
      exception Invalid_state of state
      val add_transition : state * label * state -> t -> t
      val add_itransition : label * state -> t -> t
      val remove_state : state -> t -> t
      val iter_states : (state -> unit) -> t -> unit
      val fold_states : (state -> 'a -> 'a) -> t -> 'a -> 'a
      val iter_transitions : (transition -> unit) -> t -> unit
      val fold_transitions : (transition -> 'a -> 'a) -> t -> 'a -> 'a
      val iter_itransitions : (itransition -> unit) -> t -> unit
      val fold_itransitions : (itransition -> 'a -> 'a) -> t -> 'a -> 'a
      val fold_succs : t -> state -> (state -> label -> 'a -> 'a) -> 'a -> 'a
      val iter_succs : t -> state -> (state -> label -> unit) -> unit
      val fold_preds : t -> state -> (state -> label -> 'a -> 'a) -> 'a -> 'a
      val iter_preds : t -> state -> (state -> label -> unit) -> unit
      val map_label : (label -> label) -> t -> t
      val clean : t -> t
      val dot_output :
        string ->
        ?fname:string ->
        ?options:Utils.Dot.graph_style list ->
        ?marked_states:(state * Utils.Dot.node_style) list ->
        ?extra_nodes:(string * Utils.Dot.node_style) list ->
        ?implicit_transitions:transition list -> t -> unit
      val dot_output_oc :
        string ->
        out_channel ->
        ?options:Utils.Dot.graph_style list ->
        ?marked_states:(state * Utils.Dot.node_style) list ->
        ?extra_nodes:(string * Utils.Dot.node_style) list ->
        ?implicit_transitions:transition list -> t -> unit
      val dot_output_execs :
        string ->
        ?fname:string ->
        ?options:Utils.Dot.graph_style list -> int -> t -> unit
      val tex_output :
        string ->
        ?fname:string -> ?listed_transitions:label list option -> t -> unit
    end
  type state = Fsm.State.t
  type transition = Fsm.State.t * Fsm.TransLabel.t * Fsm.State.t
  type itransition = Fsm.TransLabel.t * Fsm.State.t
  val string_of_transition : Fsm.transition -> string
  val string_of_state : Fsm.state -> string
  type model = {
    fm_name : string;
    fm_params : (string * Types.typ) list;
    fm_ios : (string * (Types.dir * Types.typ)) list;
    fm_vars : (string * Types.typ) list;
    fm_repr : Fsm.Repr.t;
  }
  type inst = {
    f_name : string;
    f_model : Fsm.model;
    f_params : (string * (Types.typ * Expr.value)) list;
    f_inps : (string * (Types.typ * Global.global)) list;
    f_outps : (string * (Types.typ * Global.global)) list;
    f_inouts : (string * (Types.typ * Global.global)) list;
    f_vars : (string * Types.typ) list;
    f_repr : Fsm.Repr.t;
    f_l2g : string -> string;
  }
  val build_model :
    name:string ->
    states:Fsm.state list ->
    params:(string * Types.typ) list ->
    ios:(Types.dir * string * Types.typ) list ->
    vars:(string * Types.typ) list ->
    trans:(Fsm.state * (Condition.event * Condition.guard list) *
           Action.t list * Fsm.state * int)
          list ->
    itrans:Fsm.state * Action.t list -> Fsm.model
  val build_instance :
    name:string ->
    model:Fsm.model ->
    params:(string * Expr.value) list -> ios:Global.global list -> Fsm.inst
  val states_of : Fsm.inst -> Fsm.state list
  val istate_of : Fsm.inst -> Fsm.state option
  val transitions_of : Fsm.inst -> Fsm.transition list
  val itransitions_of : Fsm.inst -> Fsm.itransition list
  val succs : Fsm.inst -> Fsm.state -> (Fsm.state * Fsm.TransLabel.t) list
  val input_events_of : Fsm.inst -> string list
  val output_events_of : Fsm.inst -> string list
  val is_rtl : Fsm.inst -> bool
  exception Binding_mismatch of string * string * string
  exception Invalid_parameter of string * string
  exception Uninstanciated_type_vars of string * string * string *
              string list
  type dot_options = OmitImplicitTransitions | GlobalNames | NoCaption
  val dot_output_oc :
    Pervasives.out_channel ->
    ?dot_options:Utils.Dot.graph_style list ->
    ?options:Fsm.dot_options list -> Fsm.inst -> unit
  val dot_output :
    ?fname:string ->
    ?dot_options:Utils.Dot.graph_style list ->
    ?options:Fsm.dot_options list -> dir:string -> Fsm.inst -> string
  val dot_output_model :
    ?fname:string ->
    ?dot_options:Utils.Dot.graph_style list ->
    ?options:Fsm.dot_options list -> dir:string -> Fsm.model -> string
  val dump_model : Pervasives.out_channel -> Fsm.model -> unit
  val dump_inst : Pervasives.out_channel -> Fsm.inst -> unit
end