sig
  external ( |> ) : 'a -> ('a -> 'b) -> 'b = "%revapply"
  val fprintf : out_channel -> ('a, out_channel, unit) format -> 'a
  val printf : ('a, out_channel, unit) format -> 'a
  val eprintf : ('a, out_channel, unit) format -> 'a
  val sprintf : ('a, unit, string) format -> 'a
  val bprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a
  val ifprintf : 'a -> ('b, 'a, unit) format -> 'b
  val kfprintf :
    (out_channel -> 'a) ->
    out_channel -> ('b, out_channel, unit, 'a) format4 -> 'b
  val ikfprintf :
    (out_channel -> 'a) ->
    out_channel -> ('b, out_channel, unit, 'a) format4 -> 'b
  val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b
  val kbprintf :
    (Buffer.t -> 'a) -> Buffer.t -> ('b, Buffer.t, unit, 'a) format4 -> 'b
  val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b
  module List = Nonstd.List
  module Array = Nonstd.Array
  module Option = Nonstd.Option
  module Int = Nonstd.Int
  module Float = Nonstd.Float
  module String :
    sig
      type character = char
      type t = string
      val max_string_length : int option
      val empty : string
      val is_empty : string -> bool
      val make : int -> char -> string
      val length : string -> int
      val of_character : char -> string
      val of_character_list : char list -> string
      val to_character_list : string -> char list
      val get : string -> index:int -> char option
      val set : string -> index:int -> v:char -> string option
      val get_exn : string -> index:int -> char
      val set_exn : string -> index:int -> v:char -> string
      val concat : ?sep:string -> string list -> string
      val of_native_string :
        string -> (string, [> `wrong_char_at of int ]) Sosa.Api.result
      val of_native_substring :
        string ->
        offset:int ->
        length:int ->
        (string, [> `out_of_bounds | `wrong_char_at of int ]) Sosa.Api.result
      val to_native_string : string -> string
      val to_string_hum : string -> string
      val fold : string -> init:'a -> f:('a -> char -> 'a) -> 'a
      val foldi : string -> init:'a -> f:(int -> 'a -> char -> 'a) -> 'a
      val fold2_exn :
        string -> string -> init:'a -> f:('a -> char -> char -> 'a) -> 'a
      val compare : string -> string -> int
      val sub : string -> index:int -> length:int -> string option
      val sub_exn : string -> index:int -> length:int -> string
      val slice : ?start:int -> ?finish:int -> string -> string option
      val slice_exn : ?start:int -> ?finish:int -> string -> string
      val is_prefix : string -> prefix:string -> bool
      val is_suffix : string -> suffix:string -> bool
      val chop_prefix_exn : string -> prefix:string -> string
      val chop_prefix : string -> prefix:string -> string option
      val chop_suffix_exn : string -> suffix:string -> string
      val chop_suffix : string -> suffix:string -> string option
      val split_at : string -> index:int -> string * string
      val take : string -> index:int -> string
      val drop : string -> index:int -> string
      val compare_substring : string * int * int -> string * int * int -> int
      val compare_substring_strict :
        string * int * int -> string * int * int -> int option
      val iter : string -> f:(char -> unit) -> unit
      val iteri : string -> f:(int -> char -> unit) -> unit
      val iter_reverse : string -> f:(char -> unit) -> unit
      val rev : string -> string
      val map : string -> f:(char -> char) -> string
      val mapi : string -> f:(int -> char -> char) -> string
      val map2_exn : string -> string -> f:(char -> char -> char) -> string
      val for_all : string -> f:(char -> bool) -> bool
      val exists : string -> f:(char -> bool) -> bool
      val take_while : string -> f:(char -> bool) -> string
      val take_while_with_index : string -> f:(int -> char -> bool) -> string
      val index_of_character : string -> ?from:int -> char -> int option
      val index_of_character_reverse :
        string -> ?from:int -> char -> int option
      val index_of_string :
        ?from:int ->
        ?sub_index:int ->
        ?sub_length:int -> string -> sub:string -> int option
      val index_of_string_reverse :
        ?from:int ->
        ?sub_index:int ->
        ?sub_length:int -> string -> sub:string -> int option
      val find :
        ?from:int -> ?length:int -> string -> f:(char -> bool) -> int option
      val find_reverse :
        ?from:int -> ?length:int -> string -> f:(char -> bool) -> int option
      val filter_map :
        ?from:int ->
        ?length:int -> string -> f:(char -> char option) -> string
      val filter :
        ?from:int -> ?length:int -> string -> f:(char -> bool) -> string
      val split :
        string ->
        on:[ `Character of char | `String of string ] -> string list
      val strip :
        ?on:[ `Both | `Left | `Right ] ->
        ?whitespace:(char -> bool) -> string -> string
      module Make_output = Sosa.Native_string.Make_output
    end
  val ( // ) : string -> string -> string
  val debug_mode : bool Pervasives.ref
  val dbg : ('a, unit, string, unit) Pervasives.format4 -> 'a
  val failwithf : ('a, unit, string, 'b) Pervasives.format4 -> 'a
  module Unique_id :
    sig
      type t = string
      val to_yojson : t -> Yojson.Safe.json
      val of_yojson : Yojson.Safe.json -> [ `Error of string | `Ok of t ]
      val create : unit -> string
    end
  module KEDSL :
    sig
      module Host = Ketrew.EDSL.Host
      module Program = Ketrew.EDSL.Program
      module Condition = Ketrew.EDSL.Condition
      module Build_process = Ketrew.EDSL.Build_process
      val daemonize :
        ?starting_timeout:float ->
        ?call_script:(string -> string list) ->
        ?using:[ `Nohup_setsid | `Python_daemon ] ->
        ?host:Host.t -> ?no_log_is_ok:bool -> Program.t -> Build_process.t
      val lsf :
        ?host:Host.t ->
        ?queue:string ->
        ?name:string ->
        ?wall_limit:string ->
        ?processors:[ `Min of int | `Min_max of int * int ] ->
        ?project:string ->
        ?request_memory:[ `GB of int | `MB of int ] ->
        ?raw_options:string list -> Program.t -> Build_process.t
      val pbs :
        ?host:Host.t ->
        ?queue:string ->
        ?name:string ->
        ?wall_limit:[ `Hours of float ] ->
        ?processors:int ->
        ?email_user:[ `Always of string | `Never ] ->
        ?shell:string -> Program.t -> Build_process.t
      val yarn_application :
        ?host:Host.t ->
        ?daemonize_using:[ `Nohup_setsid | `Python_daemon ] ->
        ?daemon_start_timeout:float -> Program.t -> Build_process.t
      val yarn_distributed_shell :
        ?host:Host.t ->
        ?daemonize_using:[ `Nohup_setsid | `Python_daemon ] ->
        ?daemon_start_timeout:float ->
        ?hadoop_bin:string ->
        ?distributed_shell_shell_jar:string ->
        ?container_vcores:int ->
        container_memory:[ `GB of int | `MB of int | `Raw of string ] ->
        timeout:[ `Raw of string | `Seconds of int ] ->
        application_name:string -> Program.t -> Build_process.t
      module Internal_representation = Ketrew.EDSL.Internal_representation
      type 'a product = 'a
        constraint 'a = < is_done : Condition.t option; .. >
      type 'a workflow_node =
          < product : 'a product; render : Internal_representation.t >
        constraint 'a = < is_done : Condition.t option; .. >
      type workflow_edge = Ketrew.EDSL.workflow_edge
      val depends_on :
        < is_done : Condition.t option; .. > workflow_node -> workflow_edge
      val on_success_activate :
        < is_done : Condition.t option; .. > workflow_node -> workflow_edge
      val on_failure_activate :
        < is_done : Condition.t option; .. > workflow_node -> workflow_edge
      type done_when_option =
          [ `Dependencies_are | `Is_verified of Condition.t | `Product_is ]
      val workflow_node :
        ?name:string ->
        ?active:bool ->
        ?make:Build_process.t ->
        ?done_when:done_when_option ->
        ?metadata:[ `String of string ] ->
        ?equivalence:Ketrew_pure.Target.Equivalence.t ->
        ?tags:string list ->
        ?edges:workflow_edge list ->
        (< is_done : Condition.t option; .. > as 'a) product ->
        'a workflow_node
      type not_already_done = < is_done : Condition.t option >
      val without_product : not_already_done
      type single_file =
          < exists : Ketrew_pure.Target.Condition.t;
            is_bigger_than : int -> Ketrew_pure.Target.Condition.t;
            is_done : Ketrew_pure.Target.Condition.t option; path : string >
      val single_file : ?host:Host.t -> string -> single_file product
      type list_of_files =
          < is_done : Ketrew_pure.Target.Condition.t option;
            paths : string list >
      val list_of_files :
        ?host:Host.t -> string list -> list_of_files product
      type unknown_product = < is_done : Condition.t option >
      val forget_product :
        < is_done : Condition.t option; .. > workflow_node ->
        unknown_product workflow_node
      val workflow_to_string :
        ?ansi_colors:bool ->
        ?indentation:int ->
        < is_done : Condition.t option; .. > workflow_node -> string
      val add_tags :
        ?recursive:bool ->
        < is_done : Condition.t option; .. > workflow_node ->
        string list -> unit
      val node_id :
        < is_done : Condition.t option; .. > workflow_node -> string
      val node_name :
        < is_done : Condition.t option; .. > workflow_node -> string
      class type user_artifact =
        object
          method exists : Ketrew_pure.Target.Condition.t
          method is_bigger_than : int -> Ketrew_pure.Target.Condition.t
          method path : string
        end
      val file : ?host:Host.t -> string -> user_artifact
      val unit : user_artifact
      class type user_target =
        object
          method activate : unit
          method add_recursive_tags : string list -> unit
          method add_tags : string list -> unit
          method depends_on : user_target list
          method get_recursive_tags : string list
          method id : Ketrew_pure.Internal_pervasives.Unique_id.t
          method is_active : bool
          method metadata : [ `String of string ] option
          method name : string
          method on_failure_activate : user_target list
          method on_success_activate : user_target list
          method product : user_artifact
          method render : Ketrew_pure.Target.t
        end
      val to_display_string :
        ?ansi_colors:bool -> ?indentation:int -> user_target -> string
      module Command = Ketrew_pure.Target.Command
      type nothing = < is_done : Condition.t option >
      val nothing : < is_done : 'a option >
      val target : 'a -> [> `Please_KEDSL_workflow ]
      val file_target : 'a -> [> `Please_KEDSL_workflow ]
      type file_workflow = single_file workflow_node
      type phony_workflow =
          Biokepi_run_environment.Common.KEDSL.nothing workflow_node
      type fastq_reads =
          < escaped_sample_name : string; fragment_id : string option;
            fragment_id_forced : string;
            is_done : Ketrew_pure.Target.Condition.t option;
            paths : string * string option; r1 : single_file workflow_node;
            r2 : single_file workflow_node option; sample_name : string >
      val fastq_reads :
        ?host:Host.t ->
        ?name:string ->
        ?fragment_id:string ->
        string ->
        string option -> Biokepi_run_environment.Common.KEDSL.fastq_reads
      val fastq_node_of_single_file_nodes :
        host:Host.t ->
        name:string ->
        ?fragment_id:string ->
        < is_done : Condition.t option; path : string; .. > product
        workflow_node ->
        < is_done : Condition.t option; path : string; .. > workflow_node
        option ->
        < escaped_sample_name : string; fragment_id : string option;
          fragment_id_forced : string; is_done : Condition.t option;
          paths : string * string option; r1 : single_file workflow_node;
          r2 : single_file workflow_node option; sample_name : string >
        workflow_node
      type bam_file =
          < host : Host.t; is_done : Ketrew_pure.Target.Condition.t option;
            path : string; reference_build : string;
            sorting : [ `Coordinate | `Read_name ] option >
      val bam_file :
        host:Host.t ->
        ?sorting:[ `Coordinate | `Read_name ] ->
        reference_build:string ->
        string -> Biokepi_run_environment.Common.KEDSL.bam_file
      val transform_bam :
        ?change_sorting:[ `Coordinate | `Read_name ] ->
        Biokepi_run_environment.Common.KEDSL.bam_file ->
        path:string -> Biokepi_run_environment.Common.KEDSL.bam_file
      type bam_list =
          < bams : Biokepi_run_environment.Common.KEDSL.bam_file list;
            is_done : Ketrew_pure.Target.Condition.t option >
      val bam_list :
        Biokepi_run_environment.Common.KEDSL.bam_file list ->
        Biokepi_run_environment.Common.KEDSL.bam_list
      val explode_bam_list_node :
        Biokepi_run_environment.Common.KEDSL.bam_list workflow_node ->
        < host : Host.t; is_done : Condition.t option; path : string;
          reference_build : string;
          sorting : [ `Coordinate | `Read_name ] option >
        workflow_node list
      type _ bam_or_bams =
          Single_bam :
            Biokepi_run_environment.Common.KEDSL.bam_file workflow_node -> 
            Biokepi_run_environment.Common.KEDSL.bam_file workflow_node
            Biokepi_run_environment.Common.KEDSL.bam_or_bams
        | Bam_workflow_list :
            Biokepi_run_environment.Common.KEDSL.bam_file workflow_node list -> 
            Biokepi_run_environment.Common.KEDSL.bam_list workflow_node
            Biokepi_run_environment.Common.KEDSL.bam_or_bams
      val submit :
        < is_done : Ketrew.EDSL.Condition.t option; .. > Ketrew.EDSL.product
        Ketrew.EDSL.workflow_node -> unit
    end
  module Ketrew : sig  end
  module Target_tags :
    sig
      val aligner : string
      val variant_caller : string
      val clean_up : string
    end
end