pub(all) suberror RangeError {
  RangeError(RangeErrorStage, RangeErrorKind, Int, String)
}

pub(all) enum AcceptRanges {
  NoneAccepted
  Units(Array[String])
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct AuditFinding {
  kind : AuditFindingKind
  context : String
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum AuditFindingKind {
  TooManyRanges
  OverlappingRanges
  ManySmallRanges
  DescendingOrder
  DuplicateRanges
  ZeroLengthSuffix
  LargeNumericValue
  LargeHeader
  UnknownRangeUnit
  AdjacentRanges
  InefficientRangeSet
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct AuditReport {
  findings : Array[AuditFinding]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum ByteRangeSpec {
  Closed(Int64, Int64)
  OpenEnded(Int64)
  Suffix(Int64)
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct ConcreteRange {
  first : Int64
  last : Int64
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum ContentRangeValue {
  Satisfied(RangeUnit, Int64, Int64, Int64?)
  Unsatisfied(RangeUnit, Int64)
  OtherContentRange(String, String)
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum IfRangeValue {
  EntityTag(String)
  HttpDate(Int64)
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct Limits {
  max_input_bytes : Int
  max_ranges : Int
  max_digits_per_number : Int
  max_unit_bytes : Int
  max_raw_other_range_bytes : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct MultipartPartPlan {
  range : ConcreteRange
  content_range : ContentRangeValue
  content_length : Int64
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct MultipartPlan {
  boundary : String
  content_type : String
  parts : Array[MultipartPartPlan]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum RangeErrorKind {
  EmptyInput
  MissingEquals
  InvalidUnit
  EmptyRangeSet
  InvalidRange
  MissingNumber
  InvalidNumber
  IntegerOverflow
  LastBeforeFirst
  InvalidCompleteLength
  LimitExceeded
  UnexpectedCharacter
  InvalidRepresentationLength
  UnsupportedRangeUnit
  InvalidBoundary
  InvalidEntityTag
  InvalidHttpDate
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum RangeErrorStage {
  Input
  Unit
  Syntax
  Number
  RangeSpec
  ContentRange
  AcceptRanges
  Resolve
  Limit
  Plan
  IfRange
  HttpDate
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct RangeRequest {
  unit : RangeUnit
  specs : Array[ByteRangeSpec]
  raw_other_range_set : String?
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum RangeUnit {
  Bytes
  Other(String)
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct ResolvedRangeSet {
  satisfiable_ranges : Array[ConcreteRange]
  unsatisfiable_count : Int
  original_count : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum ResponsePlan {
  Ignore
  Unsatisfiable(Int64)
  Single(ConcreteRange)
  Multiple(Array[ConcreteRange])
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

fn audit_range_request(request : RangeRequest, raw_input? : String, representation_length? : Int64) -> AuditReport

fn canonicalize_range(input : String) -> Result[String, RangeError]

fn coalesce_ranges(input : Array[ConcreteRange]) -> Array[ConcreteRange]

fn concrete_range(first : Int64, last : Int64) -> ConcreteRange

fn http_date_from_unix(seconds : Int64) -> Result[String, RangeError]

fn if_range_matches(value : IfRangeValue, current_etag : String, current_last_modified_unix : Int64) -> Bool

fn library_version() -> String

fn merge_adjacent_ranges(input : Array[ConcreteRange]) -> Array[ConcreteRange]

fn merge_overlapping_ranges(input : Array[ConcreteRange]) -> Array[ConcreteRange]

fn multipart_content_type(boundary : String) -> String

fn parse_accept_ranges(input : String) -> Result[AcceptRanges, RangeError]

fn parse_accept_ranges_with_limits(input : String, limits : Limits) -> Result[AcceptRanges, RangeError]

fn parse_content_range(input : String) -> Result[ContentRangeValue, RangeError]

fn parse_content_range_with_limits(input : String, limits : Limits) -> Result[ContentRangeValue, RangeError]

fn parse_decimal_int64(input : String) -> Result[Int64, RangeError]

fn parse_http_date(input : String) -> Result[Int64, RangeError]

fn parse_if_range(input : String) -> Result[IfRangeValue, RangeError]

fn parse_range(input : String) -> Result[RangeRequest, RangeError]

fn parse_range_with_limits(input : String, limits : Limits) -> Result[RangeRequest, RangeError]

fn plan_byte_range_response(request : RangeRequest, representation_length : Int64, method_is_get : Bool, range_supported : Bool, apply_ranges : Bool) -> Result[ResponsePlan, RangeError]

fn plan_conditional_range_response(request : RangeRequest, representation_length : Int64, if_range : IfRangeValue?, current_etag : String, current_last_modified_unix : Int64, method_is_get : Bool, range_supported : Bool, apply_ranges : Bool) -> Result[ResponsePlan, RangeError]

fn plan_multipart_ranges(ranges : Array[ConcreteRange], representation_length : Int64, boundary : String) -> Result[MultipartPlan, RangeError]

fn range_error(stage : RangeErrorStage, kind : RangeErrorKind, offset : Int, context : String) -> RangeError

fn range_request(unit : RangeUnit, specs : Array[ByteRangeSpec], raw_other_range_set? : String) -> RangeRequest

fn resolve_byte_ranges(request : RangeRequest, representation_length : Int64) -> Result[ResolvedRangeSet, RangeError]

fn resolved_range_set(ranges : Array[ConcreteRange], unsatisfiable_count : Int, original_count : Int) -> ResolvedRangeSet

fn serialize_accept_ranges(value : AcceptRanges) -> String

fn serialize_content_range(value : ContentRangeValue) -> String

fn serialize_range(request : RangeRequest) -> String

fn sort_ranges(input : Array[ConcreteRange]) -> Array[ConcreteRange]

fn strong_etag_equal(left : String, right : String) -> Bool

fn unsatisfied_content_range(length : Int64) -> Result[ContentRangeValue, RangeError]