pub(all) suberror ParseError {
  InvalidHeader(line~ : Int, column~ : Int, message~ : String)
  InvalidRecord(line~ : Int, column~ : Int, field~ : String, message~ : String)
  InvalidValue(line~ : Int, column~ : Int, field~ : String, value~ : String, message~ : String)
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum Cardinality {
  Fixed(Int)
  PerAlt
  PerAllele
  PerGenotype
  Variable
  Unknown(String)
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct ContigDef {
  id : String
  length : Int?
  attributes : Array[(String, String)]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct Diagnostic {
  severity : DiagnosticSeverity
  code : String
  line : Int
  column : Int
  field : String
  message : String
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum DiagnosticSeverity {
  Error
  Warning
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct FilterDef {
  id : String
  description : String
  attributes : Array[(String, String)]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct FormatDef {
  id : String
  number : Cardinality
  value_type : ValueType
  description : String
  attributes : Array[(String, String)]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct GenomicInterval {
  start : Int
  end : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct GenotypeCall {
  alleles : Array[Int?]
  phased : Bool
  invalid : Bool
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum GenotypeClass {
  Missing
  Reference
  Heterozygous
  HomozygousAlternate
  MultiAlternate
  Invalid
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct InfoDef {
  id : String
  number : Cardinality
  value_type : ValueType
  description : String
  attributes : Array[(String, String)]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum MetaLine {
  FileFormat(String)
  Info(InfoDef)
  Format(FormatDef)
  Filter(FilterDef)
  Contig(ContigDef)
  Generic(key~ : String, value~ : String)
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum NormalizationOutcome {
  Changed(VcfRecord)
  Unchanged(VcfRecord)
  Invalid(String)
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct QualitySummary {
  count : Int
  missing : Int
  minimum : Double?
  maximum : Double?
  mean : Double?
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct RecordDiff {
  kind : RecordDiffKind
  key : String
  left : VcfRecord?
  right : VcfRecord?
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum RecordDiffKind {
  Added
  Removed
  Changed
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct SampleCall {
  name : String
  values : Array[(String, VcfValue)]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct SampleStats {
  sample_count : Int
  called_count : Int
  missing_count : Int
  invalid_count : Int
  alt_allele_count : Int
  total_dosage : Int?
  heterozygous_count : Int
  homozygous_reference_count : Int
  homozygous_alternate_count : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct ValidationOptions {
  strict : Bool
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct ValidationReport {
  issues : Array[Diagnostic]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum ValueType {
  Integer
  Float
  Flag
  Character
  String
  Unknown(String)
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum VariantClass {
  Empty
  SNV
  MNV
  Insertion
  Deletion
  Mixed
  Symbolic
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct VcfDocument {
  header : VcfHeader
  records : Array[VcfRecord]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct VcfHeader {
  fileformat : String
  meta : Array[MetaLine]
  columns : Array[String]
  samples : Array[String]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct VcfIndex {
  entries : Array[(String, Int, VcfRecord)]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct VcfRecord {
  chrom : String
  pos : Int
  ids : Array[String]
  ref_allele : String
  alt_alleles : Array[String]
  qual : Double?
  filters : Array[String]
  info : Array[(String, VcfValue)]
  format_keys : Array[String]
  samples : Array[SampleCall]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct VcfStats {
  record_count : Int
  contig_counts : Array[(String, Int)]
  filter_counts : Array[(String, Int)]
  info_counts : Array[(String, Int)]
  variant_type_counts : Array[(String, Int)]
  sample_count : Int
  multiallelic_count : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum VcfValue {
  Missing
  Flag
  Integer(Int)
  Float(Double)
  String(String)
  List(Array[VcfValue])
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct WindowSummary {
  chrom : String
  interval : GenomicInterval?
  record_count : Int
  snv_count : Int
  indel_count : Int
  filtered_count : Int
  mean_qual : Double?
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

fn analyze_alt_count(records : Array[VcfRecord]) -> Int

fn analyze_class_counts(records : Array[VcfRecord]) -> Array[(VariantClass, Int)]

fn analyze_contig_span(records : Array[VcfRecord], chrom : String) -> GenomicInterval?

fn analyze_duplicate_keys(records : Array[VcfRecord]) -> Int

fn analyze_filter_rate(records : Array[VcfRecord]) -> Double

fn analyze_id_count(records : Array[VcfRecord]) -> Int

fn analyze_info_presence(records : Array[VcfRecord], key : String) -> Int

fn analyze_quality(records : Array[VcfRecord]) -> QualitySummary

fn analyze_record_length(record : VcfRecord) -> Int

fn analyze_sample_count(records : Array[VcfRecord]) -> Int

fn analyze_total_bases(records : Array[VcfRecord]) -> Int

fn analyze_transitions(records : Array[VcfRecord]) -> Int

fn analyze_transversions(records : Array[VcfRecord]) -> Int

fn build_index(document : VcfDocument) -> VcfIndex

fn codec_escape_description(value : String) -> String

fn codec_format_bool(value : Bool) -> String

fn codec_format_float_list(values : Array[Double?]) -> String

fn codec_format_int_list(values : Array[Int?]) -> String

fn codec_is_missing(value : String) -> Bool

fn codec_join_escaped(values : Array[String], sep : Char) -> String

fn codec_join_nonempty(values : Array[String], sep : String) -> String

fn codec_normalize_missing(value : String) -> String

fn codec_pad(values : Array[String], width : Int, filler : String) -> Array[String]

fn codec_parse_bool(value : String) -> Bool?

fn codec_parse_float_list(value : String) -> Array[Double?]

fn codec_parse_int_list(value : String) -> Array[Int?]

fn codec_quote(value : String) -> String

fn codec_split_escaped(value : String, sep : Char) -> Array[String]

fn codec_truncate(values : Array[String], width : Int) -> Array[String]

fn codec_unescape_description(value : String) -> String

fn codec_unquote(value : String) -> String

fn collect_alternate_bases(records : Array[VcfRecord]) -> Array[(String, Int)]

fn collect_reference_bases(records : Array[VcfRecord]) -> Array[(String, Int)]

fn decode_genotype(raw : String) -> GenotypeCall

fn diff_documents(left : VcfDocument, right : VcfDocument) -> Array[RecordDiff]

fn format_document(document : VcfDocument) -> String

fn format_genotype(call : GenotypeCall) -> String

fn format_header(header : VcfHeader) -> String

fn format_interval(interval : GenomicInterval?) -> String

fn format_record(record : VcfRecord) -> String

fn format_stats(stats : VcfStats) -> String

fn format_window_summary(summary : WindowSummary) -> String

fn genotype_alt_count(call : GenotypeCall) -> Int

fn genotype_alt_indexes(call : GenotypeCall) -> Array[Int]

fn genotype_class(call : GenotypeCall) -> GenotypeClass

fn genotype_dosage(call : GenotypeCall) -> Int?

fn genotype_has_allele(call : GenotypeCall, wanted : Int) -> Bool

fn genotype_is_called(call : GenotypeCall) -> Bool

fn genotype_is_het(call : GenotypeCall) -> Bool

fn genotype_is_hom_alt(call : GenotypeCall) -> Bool

fn genotype_is_hom_ref(call : GenotypeCall) -> Bool

fn genotype_is_missing(call : GenotypeCall) -> Bool

fn group_record_counts(records : Array[VcfRecord]) -> Array[(String, Int)]

fn interval_clip(interval : GenomicInterval?, lower : Int, upper : Int) -> GenomicInterval?

fn interval_contains(interval : GenomicInterval?, position : Int) -> Bool

fn interval_distance(left : GenomicInterval?, right : GenomicInterval?) -> Int

fn interval_expand(interval : GenomicInterval?, padding : Int) -> GenomicInterval?

fn interval_intersection(left : GenomicInterval?, right : GenomicInterval?) -> GenomicInterval?

fn interval_merge(intervals : Array[GenomicInterval?]) -> Array[GenomicInterval?]

fn interval_overlaps(left : GenomicInterval?, right : GenomicInterval?) -> Bool

fn interval_shift(interval : GenomicInterval?, offset : Int) -> GenomicInterval?

fn interval_subtract(source : GenomicInterval?, removed : GenomicInterval?) -> Array[GenomicInterval?]

fn interval_width(interval : GenomicInterval?) -> Int

fn make_interval(start : Int, end : Int) -> GenomicInterval?

fn merge_documents(left : VcfDocument, right : VcfDocument) -> VcfDocument raise ParseError

fn merge_sample_stats(left : SampleStats, right : SampleStats) -> SampleStats

fn normalize_basic(record : VcfRecord) -> VcfRecord

fn normalize_record(record : VcfRecord) -> NormalizationOutcome

fn parse_document(text : String) -> VcfDocument raise ParseError

fn parse_header(text : String) -> VcfHeader raise ParseError

fn parse_meta_line(line : String, line_number~ : Int) -> MetaLine raise ParseError

fn parse_record(line : String, header~ : VcfHeader) -> VcfRecord raise ParseError

fn patch_alt(record : VcfRecord, alts : Array[String]) -> VcfRecord

fn patch_clear_info(record : VcfRecord) -> VcfRecord

fn patch_filters(record : VcfRecord, filters : Array[String]) -> VcfRecord

fn patch_ids(record : VcfRecord, ids : Array[String]) -> VcfRecord

fn patch_info(record : VcfRecord, key : String, value : VcfValue) -> VcfRecord

fn patch_position(record : VcfRecord, chrom : String, pos : Int) -> VcfRecord

fn patch_qual(record : VcfRecord, qual : Double?) -> VcfRecord

fn patch_remove_info(record : VcfRecord, key : String) -> VcfRecord

fn patch_sample(record : VcfRecord, sample : SampleCall) -> VcfRecord

fn patch_sample_value(sample : SampleCall, key : String, value : VcfValue) -> SampleCall

fn pipeline_apply_normalization(document : VcfDocument) -> VcfDocument

fn pipeline_concat(documents : Array[VcfDocument]) -> VcfDocument?

fn pipeline_contigs(document : VcfDocument) -> Array[String]

fn pipeline_count(document : VcfDocument) -> Int

fn pipeline_dedupe(document : VcfDocument) -> VcfDocument

fn pipeline_drop(document : VcfDocument, count : Int) -> VcfDocument

fn pipeline_filter(document : VcfDocument, keep : (VcfRecord) -> Bool) -> VcfDocument

fn pipeline_filters(document : VcfDocument) -> Array[String]

fn pipeline_first(document : VcfDocument) -> VcfRecord?

fn pipeline_format(document : VcfDocument) -> String

fn pipeline_info_keys(document : VcfDocument) -> Array[String]

fn pipeline_is_empty(document : VcfDocument) -> Bool

fn pipeline_last(document : VcfDocument) -> VcfRecord?

fn pipeline_limit_by_contig(document : VcfDocument, chrom : String) -> VcfDocument

fn pipeline_limit_by_interval(document : VcfDocument, chrom : String, interval : GenomicInterval?) -> VcfDocument

fn pipeline_map(document : VcfDocument, transform : (VcfRecord) -> VcfRecord) -> VcfDocument

fn pipeline_merge(left : VcfDocument, right : VcfDocument) -> VcfDocument raise ParseError

fn pipeline_pairwise(left : VcfDocument, right : VcfDocument) -> Array[RecordDiff]

fn pipeline_project_info(document : VcfDocument, keys : Array[String]) -> VcfDocument

fn pipeline_project_samples(document : VcfDocument, names : Array[String]) -> VcfDocument raise ParseError

fn pipeline_query(document : VcfDocument, chrom : String, start : Int, end : Int) -> Array[VcfRecord]

fn pipeline_record_counts_by_class(document : VcfDocument) -> Array[(VariantClass, Int)]

fn pipeline_round_trip(document : VcfDocument) -> VcfDocument raise ParseError

fn pipeline_sort(document : VcfDocument) -> VcfDocument

fn pipeline_split_by_filter(document : VcfDocument, filter : String) -> (VcfDocument, VcfDocument)

fn pipeline_split_by_qualification(document : VcfDocument, threshold : Double) -> (VcfDocument, VcfDocument)

fn pipeline_split_multiallelic(document : VcfDocument) -> VcfDocument

fn pipeline_stats(document : VcfDocument) -> VcfStats

fn pipeline_take(document : VcfDocument, count : Int) -> VcfDocument

fn pipeline_validate(document : VcfDocument, strict : Bool) -> ValidationReport

fn quality_missing_rate(summary : QualitySummary) -> Double

fn quality_passes(summary : QualitySummary, threshold : Double) -> Bool

fn quality_range(summary : QualitySummary) -> Double?

fn query_index(index : VcfIndex, chrom : String, start : Int, end : Int) -> Array[VcfRecord]

fn record_alt_count(record : VcfRecord) -> Int

fn record_has_info(record : VcfRecord, key : String) -> Bool

fn record_info_float(record : VcfRecord, key : String) -> Double?

fn record_info_int(record : VcfRecord, key : String) -> Int?

fn record_info_value(record : VcfRecord, key : String) -> VcfValue?

fn record_is_indel(record : VcfRecord) -> Bool

fn record_is_snv(record : VcfRecord) -> Bool

fn record_key(record : VcfRecord) -> String

fn record_sample(record : VcfRecord, name : String) -> SampleCall?

fn record_sort_key(record : VcfRecord) -> String

fn record_variant_class(record : VcfRecord) -> VariantClass

fn sample_alt_frequency(stats : SampleStats) -> Double?

fn sample_call_rate(stats : SampleStats) -> Double

fn sample_is_high_quality(stats : SampleStats, minimum_call_rate : Double) -> Bool

fn sample_missing_rate(stats : SampleStats) -> Double

fn sample_value(sample : SampleCall, key : String) -> VcfValue?

fn schema_contig(header : VcfHeader, key : String) -> ContigDef?

fn schema_contig_length(header : VcfHeader, key : String) -> Int?

fn schema_expected_cardinality(number : Cardinality, alt_count : Int) -> Int?

fn schema_filter(header : VcfHeader, key : String) -> FilterDef?