type StreamInterceptor = (RpcContext, Bytes, (RpcContext, Bytes) -> Array[Bytes]) -> Array[Bytes]

type UnaryInterceptor = (RpcContext, Bytes, (RpcContext, Bytes) -> Bytes) -> Bytes

pub suberror FrameError {
  Incomplete
  FrameSizeError(String)
  ProtocolError(String)
} derive(Eq)

pub suberror HpackError {
  HuffmanError(String)
  HpackDecodeError(String)
} derive(Eq)

pub suberror StreamError {
  InvalidTransition(String)
} derive(Eq)

pub(all) struct BidiHandler {
  on_message : (Bytes) -> Array[Bytes]
  on_end : () -> Array[Bytes]
}

pub(all) struct CallReply {
  status : Bytes
  grpc_status : Int
  headers : Array[Header]
  messages : Array[Bytes]
  trailers : Array[Header]
}

pub(all) struct ClientCall {
  id : Int
  path : Bytes
  authority : Bytes
  metadata : Array[Header]
  timeout : Bytes?
  out : Bytes
  out_off : Int
  req_ended : Bool
  req_headers_sent : Bool
  req_fin_sent : Bool
  send_window : Int
  data : 
@moonbitlang/core/buffer.Buffer
Buffer
  data_off : Int
  messages : Array[Bytes]
  recv_window : Int
  status : Bytes
  grpc_status : Int?
  resp_headers : Array[Header]
  resp_trailers : Array[Header]
  headers_seen : Bool
  done : Bool
}

pub(all) struct DynamicTable {
  entries : Array[(Bytes, Bytes)]
  size : Int
  max_size : Int
}

pub(all) enum Frame {
  Data(stream_id~ : Int, data~ : Bytes, end_stream~ : Bool, padding~ : Int)
  Headers(stream_id~ : Int, fragment~ : Bytes, end_stream~ : Bool, end_headers~ : Bool, priority~ : Priority?, padding~ : Int)
  Priority(stream_id~ : Int, priority~ : Priority)
  RstStream(stream_id~ : Int, error_code~ : Int)
  Settings(params~ : Array[(Int, Int)], ack~ : Bool)
  PushPromise(stream_id~ : Int, promised_id~ : Int, fragment~ : Bytes, end_headers~ : Bool, padding~ : Int)
  Ping(payload~ : Bytes, ack~ : Bool)
  GoAway(last_stream_id~ : Int, error_code~ : Int, debug~ : Bytes)
  WindowUpdate(stream_id~ : Int, increment~ : Int)
  Continuation(stream_id~ : Int, fragment~ : Bytes, end_headers~ : Bool)
  Unknown(ftype~ : Int, flags~ : Int, stream_id~ : Int, payload~ : Bytes)
} derive(Eq)

pub(all) struct FrameHeader {
  length : Int
  ftype : Int
  flags : Int
  stream_id : Int
} derive(Eq)

pub struct H2Client {
  encoder : HpackEncoder
  decoder : HpackDecoder
  calls : Map[Int, ClientCall]
  next_id : Int
  conn_send_window : Int
  conn_recv_window : Int
  remote_initial_window : Int
  remote_max_frame : Int
}

pub struct H2Server {
  handlers : Map[String, Handler]
  encoder : HpackEncoder
  decoder : HpackDecoder
  streams : Map[Int, SrvStream]
  unary_interceptors : Array[(RpcContext, Bytes, (RpcContext, Bytes) -> Bytes) -> Bytes]
  stream_interceptors : Array[(RpcContext, Bytes, (RpcContext, Bytes) -> Array[Bytes]) -> Array[Bytes]]
  conn_recv_window : Int
  conn_send_window : Int
  remote_initial_window : Int
  remote_max_frame : Int
  goaway_received : Bool
}

pub(all) enum Handler {
  Unary((RpcContext, Bytes) -> Bytes)
  ServerStreaming((RpcContext, Bytes) -> Array[Bytes])
  ClientStreaming((RpcContext, Array[Bytes]) -> Bytes)
  Bidi((RpcContext) -> BidiHandler)
}

pub(all) struct Header {
  name : Bytes
  value : Bytes
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct HealthService {
  statuses : Map[String, ServingStatus]
}

pub(all) struct HpackDecoder {
  table : DynamicTable
  limit : Int
}

pub(all) struct HpackEncoder {
  table : DynamicTable
  huffman : Bool
}

pub(all) struct Method {
  service : String
  name : String
}

pub(all) struct Priority {
  exclusive : Bool
  stream_dependency : Int
  weight : Int
} derive(Eq)

pub(all) struct RpcContext {
  path : String
  metadata : Array[Header]
  deadline_millis : Int?
  resp_headers : Array[Header]
  resp_trailers : Array[Header]
}

pub(all) enum ServingStatus {
  StatusUnknown
  Serving
  NotServing
  ServiceUnknown
} derive(Eq)

pub(all) struct SrvStream {
  id : Int
  state : StreamState
  header_block : 
@moonbitlang/core/buffer.Buffer
Buffer
  data : 
@moonbitlang/core/buffer.Buffer
Buffer
  req_off : Int
  req_msgs : Array[Bytes]
  bidi_processed : Int
  headers_complete : Bool
  end_stream_recv : Bool
  path : String
  ctx : RpcContext
  recv_window : Int
  send_window : Int
  out : Bytes
  out_off : Int
  started : Bool
  started_response : Bool
  response_ended : Bool
  finalized : Bool
  trailers_only : Bool
  status_code : Int
  headers_sent : Bool
  trailers_sent : Bool
  bidi : BidiHandler?
}

pub(all) enum Status {
  Ok
  Cancelled
  Unknown
  InvalidArgument
  DeadlineExceeded
  NotFound
  AlreadyExists
  PermissionDenied
  ResourceExhausted
  FailedPrecondition
  Aborted
  OutOfRange
  Unimplemented
  Internal
  Unavailable
  DataLoss
  Unauthenticated
} derive(Eq)

pub(all) struct Stream {
  id : Int
  state : StreamState
}

pub(all) enum StreamEvent {
  Headers(end_stream~ : Bool)
  Data(end_stream~ : Bool)
  Reserve
  RstStream
} derive(Eq)

pub(all) enum StreamState {
  Idle
  ReservedLocal
  ReservedRemote
  Open
  HalfClosedLocal
  HalfClosedRemote
  Closed
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

let connection_preface : Bytes

fn decode_frame(data : Bytes, offset? : Int) -> (Frame, Int) raise FrameError

fn decode_frame_header(data : Bytes, offset? : Int) -> FrameHeader raise FrameError

fn decode_health_request(msg : Bytes) -> Bytes

fn decode_health_response(msg : Bytes) -> ServingStatus

fn decode_message(data : Bytes) -> (Bool, Bytes)?

let default_max_frame_size : Int

let default_window_size : Int

fn encode_grpc_timeout(millis : Int) -> Bytes

fn encode_health_request(service : Bytes) -> Bytes

fn encode_health_response(status : ServingStatus) -> Bytes

fn encode_message(payload : Bytes, compressed? : Bool) -> Bytes

let error_cancel : Int

let error_compression_error : Int

let error_connect_error : Int

let error_enhance_your_calm : Int

let error_flow_control_error : Int

let error_frame_size_error : Int

let error_http_1_1_required : Int

let error_inadequate_security : Int

let error_internal_error : Int

let error_no_error : Int

let error_protocol_error : Int

let error_refused_stream : Int

let error_settings_timeout : Int