sig
  module SMap :
    sig
      type key = LogtkSymbol.t
      type +'a t
      val empty : 'a t
      val is_empty : 'a t -> bool
      val mem : key -> 'a t -> bool
      val add : key -> '-> 'a t -> 'a t
      val singleton : key -> '-> '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 compare : ('-> '-> int) -> 'a t -> 'a t -> int
      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
      val iter : (key -> '-> unit) -> 'a t -> unit
      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
      val for_all : (key -> '-> bool) -> 'a t -> bool
      val exists : (key -> '-> bool) -> 'a t -> bool
      val filter : (key -> '-> bool) -> 'a t -> 'a t
      val partition : (key -> '-> 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 max_binding : 'a t -> key * 'a
      val choose : 'a t -> key * 'a
      val split : key -> 'a t -> 'a t * 'a option * 'a t
      val find : key -> 'a t -> 'a
      val map : ('-> 'b) -> 'a t -> 'b t
      val mapi : (key -> '-> 'b) -> 'a t -> 'b t
      val to_seq : 'a t -> (key * 'a) Sequence.sequence
      val of_seq : (key * 'a) Sequence.sequence -> 'a t
      val keys : 'a t -> key Sequence.sequence
      val values : 'a t -> 'Sequence.sequence
      val to_list : 'a t -> (key * 'a) list
      val of_list : (key * 'a) list -> 'a t
    end
  type t = private LogtkType.t LogtkSignature.SMap.t
  val empty : LogtkSignature.t
  val is_empty : LogtkSignature.t -> bool
  val singleton : LogtkSymbol.t -> LogtkType.t -> LogtkSignature.t
  val mem : LogtkSignature.t -> LogtkSymbol.t -> bool
  val declare :
    LogtkSignature.t -> LogtkSymbol.t -> LogtkType.t -> LogtkSignature.t
  val find : LogtkSignature.t -> LogtkSymbol.t -> LogtkType.t option
  val find_exn : LogtkSignature.t -> LogtkSymbol.t -> LogtkType.t
  val arity : LogtkSignature.t -> LogtkSymbol.t -> int * int
  val cardinal : LogtkSignature.t -> int
  val is_ground : LogtkSignature.t -> bool
  val merge : LogtkSignature.t -> LogtkSignature.t -> LogtkSignature.t
  val filter :
    LogtkSignature.t ->
    (LogtkSymbol.t -> LogtkType.t -> bool) -> LogtkSignature.t
  val diff : LogtkSignature.t -> LogtkSignature.t -> LogtkSignature.t
  val well_founded : LogtkSignature.t -> bool
  module Seq :
    sig
      val symbols : LogtkSignature.t -> LogtkSymbol.t Sequence.t
      val types : LogtkSignature.t -> LogtkType.t Sequence.t
      val to_seq :
        LogtkSignature.t -> (LogtkSymbol.t * LogtkType.t) Sequence.t
      val of_seq :
        (LogtkSymbol.t * LogtkType.t) Sequence.t -> LogtkSignature.t
    end
  val to_set : LogtkSignature.t -> LogtkSymbol.Set.t
  val to_list : LogtkSignature.t -> (LogtkSymbol.t * LogtkType.t) list
  val of_list : (LogtkSymbol.t * LogtkType.t) list -> LogtkSignature.t
  val iter :
    LogtkSignature.t -> (LogtkSymbol.t -> LogtkType.t -> unit) -> unit
  val fold :
    LogtkSignature.t ->
    '-> ('-> LogtkSymbol.t -> LogtkType.t -> 'a) -> 'a
  val pp : Buffer.t -> t -> unit
  val to_string : t -> string
  val fmt : Format.formatter -> t -> unit
  module TPTP :
    sig
      val base : LogtkSignature.t
      val is_base_symbol : LogtkSymbol.t -> bool
      val base_symbols : LogtkSymbol.Set.t
      val is_bool : LogtkSignature.t -> LogtkSymbol.t -> bool
      val is_not_bool : LogtkSignature.t -> LogtkSymbol.t -> bool
      val pp_no_base : Buffer.t -> LogtkSignature.t -> unit
      module Arith :
        sig
          val operators : LogtkSymbol.Set.t
          val is_operator : LogtkSymbol.t -> bool
          val base : LogtkSignature.t
          val full : LogtkSignature.t
        end
    end
end