pub(all) struct BloomFilter {
  size : Int
  hashes : Int
  inserted : Int
  bits : Array[Bool]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct BloomStats {
  size : Int
  hashes : Int
  inserted : Int
  set_bits : Int
  fill_ratio : Double
  estimated_false_positive_rate : Double
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct CountMinError {
  key : String
  exact : Int
  estimated : Int
  overestimate : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct CountMinErrorReport {
  total : Int
  max_overestimate : Int
  average_overestimate : Double
  rows : Array[CountMinError]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct CountMinSketch {
  width : Int
  depth : Int
  total : Int
  cells : Array[Int]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct EventWindow {
  index : Int
  label : String
  events : Array[String]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct ExactCounter {
  keys : Array[String]
  counts : Array[Int]
  total : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

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

pub(all) struct HistogramStats {
  total : Int
  underflow : Int
  overflow : Int
  non_empty_buckets : Int
  mode_bucket : Int
  mode_count : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct HyperLogLogLite {
  buckets : Int
  registers : Array[Int]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct IntHistogram {
  min : Int
  max : Int
  buckets : Int
  counts : Array[Int]
  underflow : Int
  overflow : Int
  total : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct MinHashSignature {
  seeds : Int
  values : Array[Int]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct NumericSummary {
  count : Int
  min : Int?
  max : Int?
  sum : Int
  mean : Double?
  p50 : Int?
  p90 : Int?
  p99 : Int?
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct QuantileSummary {
  values : Array[Int]
  sorted : Bool
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct ReservoirSampler {
  capacity : Int
  seen : Int
  samples : Array[String]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct SketchBudgetPlan {
  expected_events : Int
  expected_unique : Int
  accuracy_level : Int
  count_min_width : Int
  count_min_depth : Int
  bloom_bits : Int
  bloom_hashes : Int
  hll_buckets : Int
  topk_capacity : Int
  reservoir_size : Int
  estimated_cells : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct SketchGateIssue {
  severity : String
  rule : String
  metric : String
  message : String
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct SketchGateReport {
  passed : Bool
  policy : SketchQualityPolicy
  drift : StreamDrift
  issues : Array[SketchGateIssue]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct SketchQualityPolicy {
  max_event_delta : Int
  max_unique_delta : Int
  min_top_overlap : Double
  min_minhash_similarity : Double
  max_bloom_false_positive_rate : Double
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct SketchRecommendation {
  severity : String
  code : String
  title : String
  detail : String
  action : String
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct SketchReport {
  item_count : Int
  unique_count : Int
  hll_estimate : Double
  topk : SpaceSavingTopK
  sampler : ReservoirSampler
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct SpaceSavingTopK {
  capacity : Int
  total : Int
  items : Array[TopKItem]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct StreamDrift {
  baseline : StreamSnapshot
  candidate : StreamSnapshot
  event_delta : Int
  unique_delta : Int
  top_overlap : Double
  minhash_similarity : Double
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct StreamSnapshot {
  name : String
  events : Int
  exact_unique : Int
  hll_unique : Double
  topk : Array[TopKItem]
  sample : Array[String]
  bloom : BloomStats
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct TokenProfile {
  total : Int
  unique : Int
  numeric : Int
  alphabetic : Int
  alphanumeric : Int
  mixed : Int
  min_length : Int
  max_length : Int
  average_length : Double
  length_histogram : IntHistogram
  prefix_topk : Array[TopKItem]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct TopKItem {
  key : String
  count : Int
  error : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct WeightedEvent {
  key : String
  weight : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct WeightedStreamSummary {
  event_rows : Int
  total_weight : Int
  unique_keys : Int
  count_min : CountMinSketch
  exact : ExactCounter
  topk : Array[TopKItem]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct WindowChange {
  index : Int
  previous_label : String
  current_label : String
  event_delta : Int
  unique_delta : Int
  top_overlap : Double
  minhash_similarity : Double
  dominant_key : String
  dominant_count : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct WindowSnapshot {
  index : Int
  label : String
  events : Int
  exact_unique : Int
  hll_unique : Double
  bloom_false_positive_rate : Double
  dominant_key : String
  dominant_count : Int
  topk : Array[TopKItem]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct WindowedStreamReport {
  windows : Array[WindowSnapshot]
  changes : Array[WindowChange]
  total_events : Int
  max_event_spike : Int
  min_similarity : Double
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

fn bloom_add(filter : BloomFilter, value : String) -> BloomFilter

fn bloom_add_many(filter : BloomFilter, values : Array[String]) -> BloomFilter

fn bloom_from_items(values : Array[String], size : Int, hashes : Int) -> BloomFilter

fn bloom_json(filter : BloomFilter) -> String

fn bloom_markdown(filter : BloomFilter, probes : Array[String]) -> String

fn bloom_might_contain(filter : BloomFilter, value : String) -> Bool

fn bloom_new(size : Int, hashes : Int) -> BloomFilter

fn bloom_set_bits(filter : BloomFilter) -> Int

fn bloom_stats(filter : BloomFilter) -> BloomStats

fn count_min_add(sketch : CountMinSketch, key : String) -> CountMinSketch

fn count_min_add_count(sketch : CountMinSketch, key : String, count : Int) -> CountMinSketch

fn count_min_error_markdown(report : CountMinErrorReport) -> String

fn count_min_error_report(items : Array[String], probes : Array[String], width : Int, depth : Int) -> CountMinErrorReport

fn count_min_estimate(sketch : CountMinSketch, key : String) -> Int

fn count_min_from_items(items : Array[String], width : Int, depth : Int) -> CountMinSketch

fn count_min_new(width : Int, depth : Int) -> CountMinSketch

fn count_min_summary_markdown(sketch : CountMinSketch, keys : Array[String]) -> String

fn evaluate_stream_gate(baseline_name : String, baseline_input : String, candidate_name : String, candidate_input : String, policy : SketchQualityPolicy) -> SketchGateReport

fn evaluate_stream_gate_default(baseline_input : String, candidate_input : String) -> SketchGateReport

fn exact_counter_add(counter : ExactCounter, key : String) -> ExactCounter

fn exact_counter_count(counter : ExactCounter, key : String) -> Int

fn exact_counter_from_items(items : Array[String]) -> ExactCounter

fn exact_counter_markdown(counter : ExactCounter, k : Int) -> String

fn exact_counter_new() -> ExactCounter

fn exact_counter_topk(counter : ExactCounter, k : Int) -> Array[TopKItem]

fn exact_counter_unique(counter : ExactCounter) -> Int

fn exact_jaccard(left : Array[String], right : Array[String]) -> Double

fn histogram_add(histogram : IntHistogram, value : Int) -> IntHistogram

fn histogram_approx_percentile(histogram : IntHistogram, percentile : Int) -> Int?

fn histogram_bucket_width(histogram : IntHistogram) -> Int

fn histogram_buckets(histogram : IntHistogram) -> Array[HistogramBucket]

fn histogram_from_text(input : String, min : Int, max : Int, buckets : Int) -> IntHistogram

fn histogram_from_values(values : Array[Int], min : Int, max : Int, buckets : Int) -> IntHistogram

fn histogram_index(histogram : IntHistogram, value : Int) -> Int

fn histogram_json(histogram : IntHistogram) -> String

fn histogram_markdown(histogram : IntHistogram) -> String

fn histogram_new(min : Int, max : Int, buckets : Int) -> IntHistogram

fn histogram_stats(histogram : IntHistogram) -> HistogramStats

fn hll_add(hll : HyperLogLogLite, value : String) -> HyperLogLogLite

fn hll_estimate(hll : HyperLogLogLite) -> Double

fn hll_from_items(items : Array[String], buckets : Int) -> HyperLogLogLite

fn hll_new(buckets : Int) -> HyperLogLogLite

fn jaccard_report(left_input : String, right_input : String) -> String

fn minhash_add(signature : MinHashSignature, value : String) -> MinHashSignature

fn minhash_from_items(items : Array[String], seeds : Int) -> MinHashSignature

fn minhash_new(seeds : Int) -> MinHashSignature

fn minhash_similarity(left : MinHashSignature, right : MinHashSignature) -> Double

fn numeric_summary(summary : QuantileSummary) -> NumericSummary

fn numeric_summary_json(summary : QuantileSummary) -> String

fn numeric_summary_markdown(summary : QuantileSummary) -> String

fn parse_event_windows(input : String) -> Array[EventWindow]

fn parse_events(input : String) -> Array[String]

fn parse_weighted_events(input : String) -> Array[WeightedEvent]

fn parse_weighted_token(token : String) -> WeightedEvent?

fn quantile_add(summary : QuantileSummary, value : Int) -> QuantileSummary

fn quantile_compare_markdown(baseline : QuantileSummary, candidate : QuantileSummary) -> String

fn quantile_from_text(input : String) -> QuantileSummary

fn quantile_from_values(values : Array[Int]) -> QuantileSummary

fn quantile_new() -> QuantileSummary

fn quantile_sorted(summary : QuantileSummary) -> QuantileSummary

fn quantile_value(summary : QuantileSummary, percentile : Int) -> Int?

fn recommendations_from_gate(report : SketchGateReport) -> Array[SketchRecommendation]

fn recommendations_from_weighted(summary : WeightedStreamSummary) -> Array[SketchRecommendation]

fn recommendations_from_windowed(report : WindowedStreamReport) -> Array[SketchRecommendation]

fn recommendations_json(items : Array[SketchRecommendation]) -> String

fn recommendations_markdown(items : Array[SketchRecommendation]) -> String

fn reservoir_add(sampler : ReservoirSampler, value : String) -> ReservoirSampler

fn reservoir_from_items(items : Array[String], capacity : Int) -> ReservoirSampler

fn reservoir_markdown(sampler : ReservoirSampler) -> String

fn reservoir_new(capacity : Int) -> ReservoirSampler

fn sketch_budget_from_text(input : String, accuracy_level : Int) -> SketchBudgetPlan

fn sketch_budget_json(plan : SketchBudgetPlan) -> String

fn sketch_budget_markdown(plan : SketchBudgetPlan) -> String

fn sketch_budget_plan(expected_events : Int, expected_unique : Int, accuracy_level : Int) -> SketchBudgetPlan

fn sketch_budget_recommendations(plan : SketchBudgetPlan) -> Array[SketchRecommendation]

fn sketch_gate_issue(severity : String, rule : String, metric : String, message : String) -> SketchGateIssue

fn sketch_gate_json(report : SketchGateReport) -> String

fn sketch_gate_markdown(report : SketchGateReport) -> String

fn sketch_hash(value : String, seed : Int) -> Int

fn sketch_quality_policy_default() -> SketchQualityPolicy

fn sketch_quality_policy_strict() -> SketchQualityPolicy

fn sketch_recommendation(severity : String, code : String, title : String, detail : String, action : String) -> SketchRecommendation

fn sketch_report(items : Array[String], topk_size : Int, sample_size : Int) -> SketchReport

fn sketch_report_json(input : String) -> String

fn sketch_report_markdown(input : String) -> String

fn stream_drift(baseline_name : String, baseline_input : String, candidate_name : String, candidate_input : String) -> StreamDrift

fn stream_drift_json(baseline_name : String, baseline_input : String, candidate_name : String, candidate_input : String) -> String

fn stream_drift_markdown(baseline_name : String, baseline_input : String, candidate_name : String, candidate_input : String) -> String

fn stream_snapshot(name : String, input : String) -> StreamSnapshot

fn stream_snapshot_json(snapshot : StreamSnapshot) -> String

fn stream_snapshot_markdown(snapshot : StreamSnapshot) -> String

fn token_profile(items : Array[String], prefix_length : Int) -> TokenProfile

fn token_profile_from_text(input : String, prefix_length : Int) -> TokenProfile

fn token_profile_json(profile : TokenProfile) -> String

fn token_profile_markdown(profile : TokenProfile) -> String

fn token_profile_recommendations(profile : TokenProfile) -> Array[SketchRecommendation]

fn topk_add(topk : SpaceSavingTopK, key : String) -> SpaceSavingTopK

fn topk_from_items(items : Array[String], capacity : Int) -> SpaceSavingTopK

fn topk_markdown(topk : SpaceSavingTopK) -> String

fn topk_new(capacity : Int) -> SpaceSavingTopK

fn weighted_compare_markdown(baseline : WeightedStreamSummary, candidate : WeightedStreamSummary) -> String

fn weighted_estimate(summary : WeightedStreamSummary, key : String) -> Int

fn weighted_event(key : String, weight : Int) -> WeightedEvent

fn weighted_summary(events : Array[WeightedEvent], width : Int, depth : Int, k : Int) -> WeightedStreamSummary

fn weighted_summary_from_text(input : String) -> WeightedStreamSummary

fn weighted_summary_json(summary : WeightedStreamSummary) -> String

fn weighted_summary_markdown(summary : WeightedStreamSummary) -> String

fn window_change(previous : WindowSnapshot, current : WindowSnapshot) -> WindowChange

fn window_snapshot(window : EventWindow) -> WindowSnapshot

fn windowed_report(windows : Array[EventWindow]) -> WindowedStreamReport

fn windowed_report_from_text(input : String) -> WindowedStreamReport

fn windowed_report_json(report : WindowedStreamReport) -> String

fn windowed_report_markdown(report : WindowedStreamReport) -> String

fn windowed_topk_timeline_markdown(report : WindowedStreamReport) -> String