sig
  type unix = [ `Unix of string ]
  val bin_size_unix : unix Core.Std.Bin_prot.Size.sizer
  val bin_write_unix : unix Core.Std.Bin_prot.Write_ml.writer
  val bin_write_unix_ : unix Core.Std.Bin_prot.Unsafe_write_c.writer
  val bin_writer_unix : unix Core.Std.Bin_prot.Type_class.writer
  val bin_read_unix : unix Core.Std.Bin_prot.Read_ml.reader
  val bin_read_unix_ : unix Core.Std.Bin_prot.Unsafe_read_c.reader
  val bin_read_unix__ : (int -> unix) Core.Std.Bin_prot.Unsafe_read_c.reader
  val bin_reader_unix : unix Core.Std.Bin_prot.Type_class.reader
  val bin_unix : unix Core.Std.Bin_prot.Type_class.t
  val sexp_of_unix : unix -> Sexplib.Sexp.t
  val unix_of_sexp : Sexplib.Sexp.t -> unix
  val unix_of_sexp__ : Sexplib.Sexp.t -> unix
  type inet = [ `Inet of Unix_syscalls.Inet_addr.t * int ]
  val bin_size_inet : inet Core.Std.Bin_prot.Size.sizer
  val bin_write_inet : inet Core.Std.Bin_prot.Write_ml.writer
  val bin_write_inet_ : inet Core.Std.Bin_prot.Unsafe_write_c.writer
  val bin_writer_inet : inet Core.Std.Bin_prot.Type_class.writer
  val bin_read_inet : inet Core.Std.Bin_prot.Read_ml.reader
  val bin_read_inet_ : inet Core.Std.Bin_prot.Unsafe_read_c.reader
  val bin_read_inet__ : (int -> inet) Core.Std.Bin_prot.Unsafe_read_c.reader
  val bin_reader_inet : inet Core.Std.Bin_prot.Type_class.reader
  val bin_inet : inet Core.Std.Bin_prot.Type_class.t
  val sexp_of_inet : inet -> Sexplib.Sexp.t
  val inet_of_sexp : Sexplib.Sexp.t -> inet
  val inet_of_sexp__ : Sexplib.Sexp.t -> inet
  type 'a addr = 'a
    constraint 'a =
      [< `Inet of Unix_syscalls.Inet_addr.t * int | `Unix of string ]
  val bin_size_addr :
    ([< `Inet of Unix_syscalls.Inet_addr.t * int | `Unix of string ] as 'a)
    Core.Std.Bin_prot.Size.sizer -> 'a addr Core.Std.Bin_prot.Size.sizer
  val bin_write_addr :
    ([< `Inet of Unix_syscalls.Inet_addr.t * int | `Unix of string ] as 'a)
    Core.Std.Bin_prot.Unsafe_write_c.writer ->
    'a addr Core.Std.Bin_prot.Write_ml.writer
  val bin_write_addr_ :
    ([< `Inet of Unix_syscalls.Inet_addr.t * int | `Unix of string ] as 'a)
    Core.Std.Bin_prot.Unsafe_write_c.writer ->
    'a addr Core.Std.Bin_prot.Unsafe_write_c.writer
  val bin_writer_addr :
    ([< `Inet of Unix_syscalls.Inet_addr.t * int | `Unix of string ] as 'a)
    Core.Std.Bin_prot.Type_class.writer ->
    'a addr Core.Std.Bin_prot.Type_class.writer
  val bin_read_addr :
    ([< `Inet of Unix_syscalls.Inet_addr.t * int | `Unix of string ] as 'a)
    Core.Std.Bin_prot.Unsafe_read_c.reader ->
    'a addr Core.Std.Bin_prot.Read_ml.reader
  val bin_read_addr_ :
    ([< `Inet of Unix_syscalls.Inet_addr.t * int | `Unix of string ] as 'a)
    Core.Std.Bin_prot.Unsafe_read_c.reader ->
    'a addr Core.Std.Bin_prot.Unsafe_read_c.reader
  val bin_read_addr__ :
    ([< `Inet of Unix_syscalls.Inet_addr.t * int | `Unix of string ] as 'a)
    Core.Std.Bin_prot.Unsafe_read_c.reader ->
    (int -> 'a addr) Core.Std.Bin_prot.Unsafe_read_c.reader
  val bin_reader_addr :
    ([< `Inet of Unix_syscalls.Inet_addr.t * int | `Unix of string ] as 'a)
    Core.Std.Bin_prot.Type_class.reader ->
    'a addr Core.Std.Bin_prot.Type_class.reader
  val bin_addr :
    ([< `Inet of Unix_syscalls.Inet_addr.t * int | `Unix of string ] as 'a)
    Core.Std.Bin_prot.Type_class.t -> 'a addr Core.Std.Bin_prot.Type_class.t
  val sexp_of_addr :
    (([< `Inet of Unix_syscalls.Inet_addr.t * int | `Unix of string ] as 'a) ->
     Sexplib.Sexp.t) ->
    'a addr -> Sexplib.Sexp.t
  val addr_of_sexp :
    (Sexplib.Sexp.t ->
     ([< `Inet of Unix_syscalls.Inet_addr.t * int | `Unix of string ] as 'a)) ->
    Sexplib.Sexp.t -> 'a addr
  val address_string_of_inet : inet -> string
  val string_of_inet : inet -> string
  val string_of_unix : unix -> string
  module Address :
    sig
      type t = [ `Inet of Unix_syscalls.Inet_addr.t * int | `Unix of string ]
      val bin_size_t : t Core.Std.Bin_prot.Size.sizer
      val bin_write_t : t Core.Std.Bin_prot.Write_ml.writer
      val bin_write_t_ : t Core.Std.Bin_prot.Unsafe_write_c.writer
      val bin_writer_t : t Core.Std.Bin_prot.Type_class.writer
      val bin_read_t : t Core.Std.Bin_prot.Read_ml.reader
      val bin_read_t_ : t Core.Std.Bin_prot.Unsafe_read_c.reader
      val bin_read_t__ : (int -> t) Core.Std.Bin_prot.Unsafe_read_c.reader
      val bin_reader_t : t Core.Std.Bin_prot.Type_class.reader
      val bin_t : t Core.Std.Bin_prot.Type_class.t
      val sexp_of_t : t -> Sexplib.Sexp.t
      val t_of_sexp : Sexplib.Sexp.t -> t
      val t_of_sexp__ : Sexplib.Sexp.t -> t
      val unix : string -> unix
      val inet : Unix_syscalls.Inet_addr.t -> port:int -> inet
      val inet_addr_any : port:int -> inet
      val to_string :
        [< `Inet of Unix_syscalls.Inet_addr.t * int | `Unix of string ] addr ->
        string
      val to_unix :
        [< `Inet of Unix_syscalls.Inet_addr.t * int | `Unix of string ] addr ->
        Core.Std.Unix.sockaddr
    end
  module Family :
    sig
      type 'a t = 'a Unix_syscalls.Socket.Family.t
        constraint 'a =
          [< `Inet of Unix_syscalls.Inet_addr.t * int | `Unix of string ]
      val unix : unix t
      val inet : inet t
    end
  type ('a, 'b) t = ('a, 'b) Unix_syscalls.Socket.t
    constraint 'a = [< `Active | `Bound | `Passive | `Unconnected ]
    constraint 'b =
      [< `Inet of Unix_syscalls.Inet_addr.t * int | `Unix of string ]
  module Type :
    sig
      type 'a t = 'a Unix_syscalls.Socket.Type.t
        constraint 'a =
          [< `Inet of Unix_syscalls.Inet_addr.t * int | `Unix of string ]
      val tcp : inet t
      val udp : inet t
      val unix : unix t
    end
  val create :
    ([< `Inet of Unix_syscalls.Inet_addr.t * int | `Unix of string ] as 'a)
    Type.t -> ([ `Unconnected ], 'a) t
  val connect :
    ([ `Unconnected ],
     [< `Inet of Unix_syscalls.Inet_addr.t * int | `Unix of string ] as 'a)
    t -> 'a -> ([ `Active ], 'a) t Import.Deferred.t
  val connect_interruptible :
    ([ `Unconnected ],
     [< `Inet of Unix_syscalls.Inet_addr.t * int | `Unix of string ] as 'a)
    t ->
    'a ->
    interrupt:unit Import.Deferred.t ->
    [ `Interrupted | `Ok of ([ `Active ], 'a) t ] Import.Deferred.t
  val bind :
    ([ `Unconnected ],
     [< `Inet of Unix_syscalls.Inet_addr.t * int | `Unix of string ] as 'a)
    t -> 'a -> ([ `Bound ], 'a) t Import.Deferred.t
  val listen :
    ?max_pending_connections:int ->
    ([ `Bound ],
     [< `Inet of Unix_syscalls.Inet_addr.t * int | `Unix of string ] as 'a)
    t -> ([ `Passive ], 'a) t
  val accept :
    ([ `Passive ],
     [< `Inet of Unix_syscalls.Inet_addr.t * int | `Unix of string ] as 'a)
    t -> (([ `Active ], 'a) t * 'a) Import.Deferred.t
  val accept_interruptible :
    ([ `Passive ],
     [< `Inet of Unix_syscalls.Inet_addr.t * int | `Unix of string ] as 'a)
    t ->
    interrupt:unit Import.Deferred.t ->
    [ `Interrupted | `Ok of ([ `Active ], 'a) t * 'a ] Import.Deferred.t
  val shutdown :
    ([< `Active | `Bound | `Passive | `Unconnected ],
     [< `Inet of Unix_syscalls.Inet_addr.t * int | `Unix of string ])
    t -> [ `Both | `Receive | `Send ] -> unit
  val fd :
    ([< `Active | `Bound | `Passive | `Unconnected ],
     [< `Inet of Unix_syscalls.Inet_addr.t * int | `Unix of string ])
    t -> Fd.t
  val of_fd :
    Fd.t ->
    ([< `Inet of Unix_syscalls.Inet_addr.t * int | `Unix of string ] as 'a)
    Type.t -> ([< `Active | `Bound | `Passive | `Unconnected ], 'a) t
  val getsockname :
    ([< `Active | `Bound | `Passive | `Unconnected ],
     [< `Inet of Unix_syscalls.Inet_addr.t * int | `Unix of string ] as 'a)
    t -> 'a
  val getpeername :
    ([< `Active | `Bound | `Passive | `Unconnected ],
     [< `Inet of Unix_syscalls.Inet_addr.t * int | `Unix of string ] as 'a)
    t -> 'a
  module Opt :
    sig
      type 'a t = 'a Unix_syscalls.Socket.Opt.t
      val debug : bool t
      val broadcast : bool t
      val reuseaddr : bool t
      val keepalive : bool t
      val dontroute : bool t
      val oobinline : bool t
      val acceptconn : bool t
      val nodelay : bool t
      val sndbuf : int t
      val rcvbuf : int t
      val error : int t
      val typ : int t
      val rcvlowat : int t
      val sndlowat : int t
      val linger : int option t
      val rcvtimeo : float t
      val sndtimeo : float t
    end
  val getopt :
    ([< `Active | `Bound | `Passive | `Unconnected ],
     [< `Inet of Unix_syscalls.Inet_addr.t * int | `Unix of string ])
    t -> 'c Opt.t -> 'c
  val setopt :
    ([< `Active | `Bound | `Passive | `Unconnected ],
     [< `Inet of Unix_syscalls.Inet_addr.t * int | `Unix of string ])
    t -> 'c Opt.t -> 'c -> unit
end