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 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 H2Server {
  handlers : Map[String, Handler]
  encoder : HpackEncoder
  decoder : HpackDecoder
  streams : Map[Int, SrvStream]
  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(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) 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_message(data : Bytes) -> (Bool, Bytes)?

let default_max_frame_size : Int

let default_window_size : Int

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

let error_stream_closed : Int

let flag_ack : Int

let flag_end_headers : Int

let flag_end_stream : Int

let flag_padded : Int

let flag_priority : Int

let frame_continuation : Int

let frame_data : Int

let frame_goaway : Int

let frame_headers : Int

let frame_ping : Int

let frame_priority : Int

let frame_push_promise : Int

let frame_rst_stream : Int

let frame_settings : Int

let frame_window_update : Int

fn has_connection_preface(data : Bytes) -> Bool

fn hpack_decode_int(data : Bytes, offset : Int, prefix_bits : Int) -> (Int, Int)

fn hpack_decode_string(data : Bytes, offset : Int) -> (Bytes, Int)

fn hpack_encode_int(value : Int, prefix_bits : Int) -> Bytes

fn hpack_encode_size_update(new_max : Int) -> Bytes

fn hpack_encode_string(octets : Bytes) -> Bytes

fn hpack_encode_string_auto(octets : Bytes) -> Bytes

fn hpack_encode_string_huffman(octets : Bytes) -> Bytes

fn hpack_read_string(data : Bytes, offset : Int) -> (Bytes, Int) raise HpackError

fn hpack_static_entry(index : Int) -> (String, String)?

fn hpack_static_table() -> Array[(String, String)]

fn hpack_string_is_huffman(data : Bytes, offset : Int) -> Bool

fn huffman_decode(input : Bytes) -> Bytes raise HpackError

fn huffman_encode(input : Bytes) -> Bytes

fn huffman_encoded_length(input : Bytes) -> Int

fn parse_grpc_timeout(v : Bytes) -> Int?

let settings_enable_push : Int

let settings_header_table_size : Int

let settings_initial_window_size : Int

let settings_max_concurrent_streams : Int

let settings_max_frame_size : Int

let settings_max_header_list_size : Int

fn stream_id_valid_for_initiator(id : Int, by_client~ : Bool) -> Bool

fn stream_is_client_initiated(id : Int) -> Bool

fn stream_is_server_initiated(id : Int) -> Bool