sig
  module Types :
    sig
      module type TYPE =
        sig
          type 'a typ
          val void : unit typ
          val char : char typ
          val schar : int typ
          val short : int typ
          val int : int typ
          val long : Signed.long typ
          val llong : Signed.llong typ
          val nativeint : nativeint typ
          val int8_t : int typ
          val int16_t : int typ
          val int32_t : int32 typ
          val int64_t : int64 typ
          module Intptr : Signed.S
          val intptr_t : Intptr.t typ
          module Ptrdiff : Signed.S
          val ptrdiff_t : Ptrdiff.t typ
          val camlint : int typ
          val uchar : Unsigned.uchar typ
          val bool : bool typ
          val uint8_t : Unsigned.uint8 typ
          val uint16_t : Unsigned.uint16 typ
          val uint32_t : Unsigned.uint32 typ
          val uint64_t : Unsigned.uint64 typ
          val size_t : Unsigned.size_t typ
          val ushort : Unsigned.ushort typ
          val sint : Signed.sint typ
          val uint : Unsigned.uint typ
          val ulong : Unsigned.ulong typ
          val ullong : Unsigned.ullong typ
          module Uintptr : Unsigned.S
          val uintptr_t : Uintptr.t typ
          val float : float typ
          val double : float typ
          val ldouble : LDouble.t typ
          val complex32 : Complex.t typ
          val complex64 : Complex.t typ
          val complexld : ComplexL.t typ
          val ptr : 'a typ -> 'a Ctypes_static.ptr typ
          val ptr_opt : 'a typ -> 'a Ctypes_static.ptr option typ
          val string : string typ
          val string_opt : string option typ
          val ocaml_string : string Ctypes_static.ocaml typ
          val ocaml_bytes : Bytes.t Ctypes_static.ocaml typ
          val array : int -> 'a typ -> 'a Ctypes_static.carray typ
          val bigarray :
            < ba_repr : 'b; bigarray : 'bigarray; carray : 'c; dims : 'dims;
              element : 'a; layout : Bigarray.c_layout >
            Ctypes_static.bigarray_class ->
            'dims -> ('a, 'b) Bigarray.kind -> 'bigarray typ
          val fortran_bigarray :
            < ba_repr : 'b; bigarray : 'bigarray; carray : 'c; dims : 'dims;
              element : 'a; layout : Bigarray.fortran_layout >
            Ctypes_static.bigarray_class ->
            'dims -> ('a, 'b) Bigarray.kind -> 'bigarray typ
          val typ_of_bigarray_kind : ('a, 'b) Bigarray.kind -> 'a typ
          type ('a, 't) field
          val structure : string -> 's Ctypes_static.structure typ
          val union : string -> 's Ctypes_static.union typ
          val field :
            ('s, [< `Struct | `Union ] as 'b) Ctypes_static.structured typ ->
            string -> 'a typ -> ('a, ('s, 'b) Ctypes_static.structured) field
          val seal :
            ('a, [< `Struct | `Union ]) Ctypes_static.structured typ -> unit
          val view :
            ?format_typ:((Format.formatter -> unit) ->
                         Format.formatter -> unit) ->
            ?format:(Format.formatter -> 'b -> unit) ->
            read:('a -> 'b) -> write:('b -> 'a) -> 'a typ -> 'b typ
          val typedef : 'a typ -> string -> 'a typ
          val abstract :
            name:string ->
            size:int -> alignment:int -> 'a Ctypes_static.abstract typ
          val lift_typ : 'a Ctypes_static.typ -> 'a typ
          type 'a fn = 'a Ctypes_static.fn
          val ( @-> ) : 'a typ -> 'b fn -> ('a -> 'b) fn
          val returning : 'a typ -> 'a fn
          type 'a static_funptr = 'a Ctypes_static.static_funptr
          val static_funptr : 'a fn -> 'a Ctypes_static.static_funptr typ
          type 'a const
          val constant : string -> 'a typ -> 'a Cstubs.Types.TYPE.const
          val enum :
            string ->
            ?typedef:bool ->
            ?unexpected:(int64 -> 'a) ->
            ('a * int64 Cstubs.Types.TYPE.const) list -> 'a typ
        end
      module type BINDINGS = functor (F : TYPE) -> sig  end
      val write_c :
        Format.formatter -> (module Cstubs.Types.BINDINGS) -> unit
    end
  module type FOREIGN = Ctypes.FOREIGN
  module type BINDINGS =
    functor
      (F : sig
             type 'a fn
             type 'a return
             val ( @-> ) : 'a Ctypes.typ -> 'b fn -> ('a -> 'b) fn
             val returning : 'a Ctypes.typ -> 'a return fn
             type 'a result = unit
             val foreign : string -> ('a -> 'b) fn -> ('a -> 'b) result
             val foreign_value :
               string -> 'a Ctypes.typ -> 'a Ctypes.ptr result
           end) ->
      sig  end
  type errno_policy
  val ignore_errno : Cstubs.errno_policy
  val return_errno : Cstubs.errno_policy
  type concurrency_policy
  val sequential : Cstubs.concurrency_policy
  val unlocked : Cstubs.concurrency_policy
  val lwt_preemptive : Cstubs.concurrency_policy
  val lwt_jobs : Cstubs.concurrency_policy
  val write_c :
    ?concurrency:Cstubs.concurrency_policy ->
    ?errno:Cstubs.errno_policy ->
    Format.formatter -> prefix:string -> (module Cstubs.BINDINGS) -> unit
  val write_ml :
    ?concurrency:Cstubs.concurrency_policy ->
    ?errno:Cstubs.errno_policy ->
    Format.formatter -> prefix:string -> (module Cstubs.BINDINGS) -> unit
end