sig
  type osm_id = OSMId of string
  module StringMap : Core.Std.Map.S
  type osm_tags = string StringMap.t
  val empty_tags : Types.osm_tags
  val add_tag : Types.osm_tags -> string -> string -> Types.osm_tags
  val find_tag : Types.osm_tags -> string -> string option
  module OSMId_Comparator :
    sig
      type t = osm_id
      type comparator_witness
      val comparator : (t, comparator_witness) Core.Std.Comparator.comparator
    end
  module OSMMap :
    sig
      module Key :
        sig
          type t = OSMId_Comparator.t
          type comparator_witness = OSMId_Comparator.comparator_witness
          val comparator :
            (t, comparator_witness) Core_kernel.Comparator.comparator
        end
      module Tree :
        sig
          type 'a t = (Key.t, 'a, Key.comparator_witness) Core.Std.Map.Tree.t
          val empty : 'a t
          val singleton : Key.t -> 'a -> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
          val of_alist_or_error :
            (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
          val of_alist_exn : (Key.t * 'a) list -> 'a t
          val of_alist_multi : (Key.t * 'a) list -> 'a list t
          val of_alist_fold :
            (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
          val of_alist_reduce :
            (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
          val of_sorted_array :
            (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
          val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
          val of_tree : 'a t -> 'a t
          val invariants : 'a t -> bool
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val add : 'a t -> key:Key.t -> data:'a -> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
          val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
          val find : 'a t -> Key.t -> 'a option
          val find_exn : 'a t -> Key.t -> 'a
          val remove : 'a t -> Key.t -> 'a t
          val mem : 'a t -> Key.t -> bool
          val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('a -> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
          val fold :
            'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val fold_right :
            'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
          val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
          val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
          val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
          val keys : 'a t -> Key.t list
          val data : 'a t -> 'a list
          val to_alist : 'a t -> (Key.t * 'a) list
          val validate :
            name:(Key.t -> string) ->
            'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('a -> 'a -> bool) ->
            (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
            Core_kernel.Sequence.t
          val min_elt : 'a t -> (Key.t * 'a) option
          val min_elt_exn : 'a t -> Key.t * 'a
          val max_elt : 'a t -> (Key.t * 'a) option
          val max_elt_exn : 'a t -> Key.t * 'a
          val for_all : 'a t -> f:('a -> bool) -> bool
          val exists : 'a t -> f:('a -> bool) -> bool
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
          val next_key : 'a t -> Key.t -> (Key.t * 'a) option
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'a t
          val to_sequence :
            ?keys_in:[ `Decreasing_order
                     | `Decreasing_order_less_than_or_equal_to of Key.t
                     | `Increasing_order
                     | `Increasing_order_greater_than_or_equal_to of Key.t ] ->
            'a t -> (Key.t * 'a) Core_kernel.Sequence.t
          val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
          val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
        end
      type 'a t = (Key.t, 'a, Key.comparator_witness) Core.Std.Map.t
      val empty : 'a t
      val singleton : Key.t -> 'a -> 'a t
      val of_alist :
        (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
      val of_alist_or_error :
        (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
      val of_alist_exn : (Key.t * 'a) list -> 'a t
      val of_alist_multi : (Key.t * 'a) list -> 'a list t
      val of_alist_fold :
        (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
      val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
      val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
      val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
      val of_tree : 'a Tree.t -> 'a t
      val invariants : 'a t -> bool
      val is_empty : 'a t -> bool
      val length : 'a t -> int
      val add : 'a t -> key:Key.t -> data:'a -> 'a t
      val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
      val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
      val find : 'a t -> Key.t -> 'a option
      val find_exn : 'a t -> Key.t -> 'a
      val remove : 'a t -> Key.t -> 'a t
      val mem : 'a t -> Key.t -> bool
      val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
      val iter2 :
        'a t ->
        'b t ->
        f:(key:Key.t ->
           data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) ->
        unit
      val map : 'a t -> f:('a -> 'b) -> 'b t
      val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
      val fold :
        'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
      val fold_right :
        'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
      val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
      val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
      val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
      val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
      val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
      val keys : 'a t -> Key.t list
      val data : 'a t -> 'a list
      val to_alist : 'a t -> (Key.t * 'a) list
      val validate :
        name:(Key.t -> string) ->
        'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check
      val merge :
        'a t ->
        'b t ->
        f:(key:Key.t ->
           [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
        'c t
      val symmetric_diff :
        'a t ->
        'a t ->
        data_equal:('a -> 'a -> bool) ->
        (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
        Core_kernel.Sequence.t
      val min_elt : 'a t -> (Key.t * 'a) option
      val min_elt_exn : 'a t -> Key.t * 'a
      val max_elt : 'a t -> (Key.t * 'a) option
      val max_elt_exn : 'a t -> Key.t * 'a
      val for_all : 'a t -> f:('a -> bool) -> bool
      val exists : 'a t -> f:('a -> bool) -> bool
      val fold_range_inclusive :
        'a t ->
        min:Key.t ->
        max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
      val range_to_alist :
        'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
      val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
      val next_key : 'a t -> Key.t -> (Key.t * 'a) option
      val rank : 'a t -> Key.t -> int option
      val to_tree : 'a t -> 'a Tree.t
      val to_sequence :
        ?keys_in:[ `Decreasing_order
                 | `Decreasing_order_less_than_or_equal_to of Key.t
                 | `Increasing_order
                 | `Increasing_order_greater_than_or_equal_to of Key.t ] ->
        'a t -> (Key.t * 'a) Core_kernel.Sequence.t
      val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
      val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
      val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
    end
  type osm_node = OSMNode of Types.osm_node_t
  and osm_node_t = {
    id : Types.osm_id;
    latitude : float;
    longitude : float;
    version : string;
    changeset : string;
    user : string;
    uid : string;
    timestamp : string;
    tags : Types.osm_tags;
  }
  type osm_way = OSMWay of Types.osm_way_t
  and osm_way_t = {
    id : Types.osm_id;
    version : string;
    changeset : string;
    user : string;
    uid : string;
    timestamp : string;
    tags : Types.osm_tags;
    nodes : Types.osm_id list;
  }
  type osm_relation_member = OSMRelationMember of Types.osm_relation_member_t
  and osm_relation_member_t = {
    ref : Types.osm_id;
    type_ : string;
    role : string;
  }
  type osm_relation = OSMRelation of Types.osm_relation_t
  and osm_relation_t = {
    id : Types.osm_id;
    version : string;
    changeset : string;
    user : string;
    uid : string;
    timestamp : string;
    tags : Types.osm_tags;
    members : Types.osm_relation_member list;
  }
  type osm = OSM of Types.osm_t
  and osm_t = {
    nodes : Types.osm_node Types.OSMMap.t;
    ways : Types.osm_way Types.OSMMap.t;
    relations : Types.osm_relation Types.OSMMap.t;
  }
  val empty_osm : Types.osm
end