sig
  type 'a matrix = 'a array array
  val map : ('a -> 'b) -> 'a array array -> 'b array array
  val mapi : (int -> int -> 'a -> 'b) -> 'a array array -> 'b array array
  type info = {
    mainNode : Diagrams.Node.info;
    common : Diagrams.Node.Transfo.Style.t list;
    nodes : Diagrams.Node.info Diagrams.Matrix.matrix;
    placement : Diagrams.Matrix.info -> int -> int -> Diagrams.Point.t;
  }
  type t = Diagrams.Matrix.info
  module Transfo :
    sig
      module rec Style :
        sig
          type t = { pet : Pet.t; transfo : transfo; }
          and transfo = info -> info
        end
      and Pet :
        sig
          type t
          val name : t -> string
          val append : t -> Style.t list -> Style.t -> Style.t list
          val ( = ) : t -> t -> bool
          val register :
            ?depends:t list ->
            ?codepends:t list ->
            ?append:(Style.t list -> Style.t -> Style.t list) ->
            string -> (t -> 'a) -> 'a * t
          module Map :
            sig
              type key = t
              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 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
        end
      val transform : Style.t list -> info -> info
    end
  module T = Transfo
  module S = T.Style
  val default_matrix_node_anchor : [> `Base ]
  val default_matrix_node_style :
    Document.environment -> Diagrams.Node.Transfo.Style.t list
  val between_centers : float -> float -> 'a -> int -> int -> float * float
  val default : Document.environment -> Diagrams.Matrix.info
  val nodes_contents : Diagrams.Matrix.info -> RawContent.raw list
  val to_contents : Diagrams.Matrix.info -> RawContent.raw list
  val allNodes : Node.Transfo.Style.t list -> S.t
  val all_nodes_pet : T.Pet.t
  val make_node_array :
    Diagrams.Node.Transfo.Style.t list ->
    int ->
    int ->
    Diagrams.Node.Transfo.Style.t list list list ->
    Diagrams.Node.info array array
  val makeNodes : Node.Transfo.Style.t list list list -> S.t
  val make_nodes_pet : T.Pet.t
  val contents_output :
    (Diagrams.Node.Transfo.Style.t list * RawContent.raw list) list list ->
    S.t
  val contents_box :
    Document.environment ->
    (Diagrams.Node.Transfo.Style.t list * Box.box list) list list -> S.t
  val contents :
    Document.environment ->
    (Diagrams.Node.Transfo.Style.t list * Document.content list) list list ->
    S.t
  val placement : (info -> int -> int -> Point.t) -> S.t
  val placement_pet : T.Pet.t
  val makePlacement : S.t
  val make_placement_pet : T.Pet.t
  val setZ : (Node.info -> int -> int -> float) -> S.t
  val set_z_pet : T.Pet.t
  val mk_matrix_anchor :
    (Diagrams.Matrix.info -> float * float) ->
    Diagrams.Matrix.info -> float * float
  val matrixAnchor :
    int -> int -> Diagrams.anchor -> Diagrams.Matrix.info -> Diagrams.Point.t
  val matrixLine : Diagrams.Matrix.info -> float * float
  val matrixFirstLine : Diagrams.Matrix.info -> float * float
  val matrixBase : Diagrams.Matrix.info -> float * float
  val matrixCenter : Diagrams.Matrix.info -> float * float
  val mainNode :
    ?matrix_anchor:(info -> Point.t) -> Node.Transfo.Style.t list -> S.t
  val main_node_pet : T.Pet.t
  val mainAnchor : (info -> float * float) -> S.t
  val main_anchor_pet : T.Pet.t
  val centers : float -> float -> S.t
  val transform_matrix :
    Document.environment ->
    T.Style.t list ->
    (Diagrams.Node.Transfo.Style.t list * Document.content list) list list ->
    Diagrams.Matrix.info -> Diagrams.Matrix.info
  val make :
    Document.environment ->
    T.Style.t list ->
    (Diagrams.Node.Transfo.Style.t list * Document.content list) list list ->
    Diagrams.Matrix.info
  val make_simple :
    Document.environment ->
    T.Style.t list ->
    (Diagrams.Node.Transfo.Style.t list * Document.content list) list list ->
    Diagrams.Node.info * Diagrams.Node.info Diagrams.Matrix.matrix
  val translate :
    float * float -> Diagrams.Matrix.info -> Diagrams.Matrix.info
end