pub suberror McapError {
  Invalid(String)
} derive(
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct AggregateOptions {
  value_path : String
  group_paths : Array[String]
  by_topic : Bool
  window : UInt64
  origin : UInt64
  max_groups : Int
  group_bytes : Int
  invalid : JsonInvalidPolicy
}

type AggregateRow

type AggregateRun

type AggregateSpill

type AggregateState

pub(all) struct Attachment {
  log_time : UInt64
  create_time : UInt64
  name : String
  media_type : String
  data : Bytes
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct AttachmentIndex {
  offset : UInt64
  length : UInt64
  log_time : UInt64
  create_time : UInt64
  data_size : UInt64
  name : String
  media_type : String
}

pub(all) struct BinaryField {
  path : String
  offset : Int
  byte_length : Int
  elements : Int
  element_type : String
  stride : Int
  little_endian : Bool
  aligned : Bool
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct BlockRecoveryEvidence {
  start : UInt64
  end : UInt64
  recovered : Bool
  messages : Int
  actual_start : UInt64?
  actual_end : UInt64?
  advertised_start : UInt64
  advertised_end : UInt64
  reason : String?
}

pub(all) struct BlockRecoveryReport {
  recovered : Array[RecoveredBlock]
  skipped : Array[SkippedBlock]
  messages : Int
  output_bytes : UInt64
  source_complete : Bool
}

type CachedChunk

pub struct CdrDecoder {
  name : String
  definitions : Map[String, Array[CdrField]]
  options : CdrOptions
  field_count : Int
  ros1 : Bool
}

type CdrField

pub(all) struct CdrOptions {
  schema_bytes : Int
  message_bytes : Int
  string_bytes : Int
  items : Int
  fields : Int
  depth : Int
  int64_as_string : Bool
}

type CdrProjection

type CdrWire

pub(all) struct Channel {
  id : Int
  schema_id : Int
  topic : String
  message_encoding : String
  metadata : Array[(String, String)]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct Chunk {
  start_time : UInt64
  end_time : UInt64
  records : Array[Record]
}

pub(all) struct ChunkIndex {
  start_time : UInt64
  end_time : UInt64
  chunk_start : UInt64
  chunk_length : UInt64
  message_index_offsets : Array[(Int, UInt64)]
  message_index_length : UInt64
  compression : String
  compressed_size : UInt64
  uncompressed_size : UInt64
}

type ChunkJobState

type ChunkPart

pub(all) struct ChunkReadRequest {
  span : ReadSpan
  chunk_bytes : Int
  expanded_bytes : Int
  compression : String
}

type ChunkSegment

pub(all) struct ClockAnchor {
  source : UInt64
  target : UInt64
}

pub struct ClockMap {
  anchors : Array[ClockAnchor]
  extrapolate : Bool
}

pub(all) struct CommandOptions {
  command : String
  inputs : Array[String]
  output : String
  query : Query
  compression : Compression
  format : String
  max_file_bytes : Int
  cache_bytes : Int
  chunk_messages : Int
  full : Bool
  transform : TransformOptions
  external : ExternalOptions
  temp_dir : String
  indexes : Array[String]
  fast_index : Bool
  index_bytes : Int
  content : JsonFilter?
  job_dir : String
  resume_job : Bool
  aggregate : AggregateOptions
  diff : DiffOptions
}

pub(all) enum Compression {
  Uncompressed
  Lz4
  Zstd
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct ContextClip {
  log : Log
  report : Json
}

pub(all) struct ContextRule {
  topic : String
  depth : Int
  max_age : UInt64
  required : Bool
}

type Cursor

type CursorRun

type DataInspection

pub struct Dataset {
  sources : Array[QuerySource]
  declarations : Log
  remaps : Array[Map[Int, Int]]
  limits : Limits
}

pub struct DatasetCursor {
  dataset : Dataset
  original : Query
  budget : Int
  streams : Array[MessageStream]
  heap : Array[DatasetMessage]
  query : Query
  state : FileCursorState
  initialized : Bool
  loaded : Int
  advance : Int?
  remaining : Int
  offset_left : Int
  emitted : Int
  skipped : Int
  peak : Int
}

pub(all) struct DatasetMessage {
  source_index : Int
  message : Message
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct DatasetProgress {
  state : FileCursorState
  sources : Int
  materialized_sources : Int
  loaded_sources : Int
  emitted_messages : Int
  skipped_messages : Int
  pending_bytes : Int
  peak_pending_bytes : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct DecodeSelection {
  paths : Array[String]
  inline_array_items : Int
  scan_items : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct Diagnostic {
  code : DiagnosticCode
  offset : UInt64?
  opcode : Byte?
  message : String
  expected : UInt64?
  actual : UInt64?
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum DiagnosticCode {
  BadEnvelope
  BadRecord
  BadDeclaration
  BadCompression
  BadChecksum
  BadIndex
  BadSummary
  TruncatedInput
  LimitExceeded
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

type DiffBag

pub(all) struct DiffOptions {
  json_payloads : Bool
  bucket_bytes : Int
  auxiliary_bytes : Int
  max_details : Int
  detail_bytes : Int
  fallback_bytes : Int
  limits : Limits
}

type DiffResult

type DiskIndexEntry

pub struct DiskSidecarAudit {
  reader : DiskSidecarReader
  page : Int
  previous : DiskIndexEntry?
  failed : Bool
}

pub struct DiskSidecarCursor {
  reader : DiskSidecarReader
  original : Query
  allowed : Map[Int, Bool]
  query : Query
  position : Int
  offset : Int
  remaining : Int
  state : FileCursorState
}

pub(all) enum DiskSidecarPoll {
  DiskDone
  DiskMessage(Message)
  DiskIndexRead(ReadSpan)
  DiskSourceRead(ReadSpan)
}

pub struct DiskSidecarPollCursor {
  reader : DiskSidecarReader
  original : Query
  allowed : Map[Int, Bool]
  query : Query
  low : Int
  high : Int
  searching : Bool
  position : Int
  offset : Int
  remaining : Int
  state : FileCursorState
  current : (Int, Array[DiskIndexEntry])?
  waiting_page : Int?
  waiting_entry : SidecarEntry?
  ready : Message?
}

pub struct DiskSidecarReader {
  index : ReadSource
  base : SidecarReader
  count : Int
  width : Int
  start : UInt64
  cache_limit : Int
  pages : Array[(Int, Array[DiskIndexEntry])]
  page_reads : Int
  cache_hits : Int
  peak_pages : Int
}

pub struct EventDetector {
  rule : EventRule
  enter : JsonFilter
  leave : JsonFilter?
  previous : UInt64?
  candidate : UInt64?
  confirmed : UInt64?
  ended : UInt64?
  finished : Bool
}