type HttpHandler = async (MocketEvent) -> &Responder noraise

type Middleware = async (MocketEvent, async () -> &Responder noraise) -> &Responder noraise

type MiddlewareNext = async () -> &Responder noraise

type WebSocketHandler = (WebSocketEvent) -> Unit

pub(open) trait BodyReader {
  from_request(req : HttpRequest) -> Self raise
}

pub(open) trait Responder {
  options(Self, res : HttpResponse) -> Unit
  output(Self, buf : 
@moonbitlang/core/buffer.Buffer
Buffer) -> Unit
}

pub(open) trait ServeStaticProvider {
  get_meta(Self, id : String) -> StaticAssetMeta?
  get_contents(Self, id : String) -> &Responder
  get_type(Self, ext : String) -> String?
  get_encodings(Self) -> Map[String, String]
  get_index_names(Self) -> Array[String]
  get_fallthrough(Self) -> Bool
}

pub suberror ExecError

pub suberror FetchError {
  RequestFailed(String)
}

pub suberror IOError

pub suberror NetworkError

pub(all) struct CookieItem {
  name : String
  value : String
  max_age : Int?
  path : String?
  domain : String?
  secure : Bool?
  http_only : Bool?
  same_site : SameSiteOption?
}

pub(all) enum FetchCredentials {
  Omit
  SameOrigin
  Include
}

pub(all) enum FetchMode {
  Cors
  NoCors
  SameOrigin
  Navigate
}

type Html

pub(all) enum HttpMethod {
  GET
  POST
  PUT
  PATCH
  DELETE
  HEAD
  OPTIONS
  TRACE
  CONNECT
}

pub(all) struct HttpRequest {
  http_method : String
  url : String
  headers : Map[StringView, StringView]
  raw_body : Bytes
}

#external
pub type HttpRequestInternal

pub(all) struct HttpResponse {
  status_code : StatusCode
  headers : Map[StringView, StringView]
  cookies : Map[String, CookieItem]
  raw_body : Bytes
}

#external
pub type HttpResponseInternal

#external
pub type HttpServerInternal

#alias(T)
pub(all) struct Mocket {
  base_path : String
  mappings : Map[(String, String), async (MocketEvent) -> &Responder noraise]
  middlewares : Array[(String, async (MocketEvent, async () -> &Responder noraise) -> &Responder noraise)]
  static_routes : Map[String, Map[String, async (MocketEvent) -> &Responder noraise]]
  dynamic_routes : Map[String, Array[(String, async (MocketEvent) -> &Responder noraise)]]
  ws_static_routes : Map[String, (WebSocketEvent) -> Unit]
  ws_dynamic_routes : Array[(String, (WebSocketEvent) -> Unit)]
  ws_clients : Map[String, Unit]
  ws_channels : Map[String, Map[String, Unit]]
  ws_client_port : Map[String, Int]
}

pub(all) struct MocketEvent {
  req : HttpRequest
  res : HttpResponse
  params : Map[String, StringView]
}

pub(all) struct MultipartFormValue {
  filename : String?
  content_type : String?
  data : BytesView
}

pub(all) enum SameSiteOption {
  Lax
  Strict
  SameSiteNone
}

pub(all) struct StaticAssetMeta {
  asset_type : String?
  etag : String?
  mtime : Int64?
  path : String?
  size : Int64?
  encoding : String?
}

pub(all) enum StatusCode {
  Continue
  SwitchingProtocols
  Processing
  EarlyHints
  OK
  Created
  Accepted
  NonAuthoritativeInfo
  NoContent
  ResetContent
  PartialContent
  MultiStatus
  AlreadyReported
  IMUsed
  MultipleChoices
  MovedPermanently
  Found
  SeeOther
  NotModified
  UseProxy
  TemporaryRedirect
  PermanentRedirect
  BadRequest
  Unauthorized
  PaymentRequired
  Forbidden
  NotFound
  MethodNotAllowed
  NotAcceptable
  ProxyAuthRequired
  RequestTimeout
  Conflict
  Gone
  LengthRequired
  PreconditionFailed
  RequestEntityTooLarge
  RequestUriTooLong
  UnsupportedMediaType
  RequestedRangeNotSatisfiable
  ExpectationFailed
  Teapot
  MisdirectedRequest
  UnprocessableEntity
  Locked
  FailedDependency
  TooEarly
  UpgradeRequired
  PreconditionRequired
  TooManyRequests
  RequestHeaderFieldsTooLarge
  UnavailableForLegalReasons
  InternalServerError
  NotImplemented
  BadGateway
  ServiceUnavailable
  GatewayTimeout
  HttpVersionNotSupported
  VariantAlsoNegotiates
  InsufficientStorage
  LoopDetected
  NotExtended
  NetworkAuthenticationRequired
  Custom(Int)
}

pub enum WebSocketAggregatedMessage {
  Text(String)
  Binary(Bytes)
  Ping
}

pub enum WebSocketEvent {
  Open(WebSocketPeer)
  Message(WebSocketPeer, WebSocketAggregatedMessage)
  Close(WebSocketPeer)
}

pub(all) struct WebSocketPeer {
  connection_id : String
  subscribed_channels : Array[String]
}

fn __ws_emit(event_type : 
@oboard/mocket/native.CStr
CStr, connection_id : 
@oboard/mocket/native.CStr
CStr, payload : 
@oboard/mocket/native.CStr
CStr) -> Unit

fn async_run(f : async () -> Unit noraise) -> Unit

fn cookie_to_string(cookie : Array[CookieItem]) -> String

async fn execute_middlewares(middlewares : Array[(String, async (MocketEvent, async () -> &Responder noraise) -> &Responder noraise)], event : MocketEvent, final_handler : async (MocketEvent) -> &Responder noraise) -> &Responder noraise

async fn fetch(url : String, body? : String, http_method : HttpMethod, data? : &Responder, headers? : Map[String, String], credentials? : FetchCredentials, mode? : FetchMode) -> HttpResponse

fn form_encode(map : Map[String, String]) -> String

fn handle_not_found() -> (async (MocketEvent) -> &Responder noraise)

fn html(html : &Show) -> &Responder

fn new(base_path? : String) -> Mocket

fn parse_cookie(cookie : StringView) -> Map[String, CookieItem]

fn parse_form_data(bytes : BytesView) -> Map[String, String]

fn parse_multipart(bytes : BytesView, boundary : String) -> Map[String, MultipartFormValue]

fn register_ws_handler(mocket : Mocket, port : Int) -> Unit

fn serve_ffi(mocket : Mocket, port~ : Int) -> Unit

async fn[T, E : Error] suspend(f : ((T) -> Unit, (E) -> Unit) -> Unit) -> T raise E

fn text(text : &Show) -> &Responder

fn url_decode(bytes : BytesView) -> String

fn url_encode(s : String) -> String

fn ws_pong(id : String) -> Unit

fn ws_publish(channel : String, msg : String) -> Unit

fn ws_send(id : String, msg : String) -> Unit

fn ws_send_bytes(id : String, msg : Bytes) -> Unit

fn ws_subscribe(id : String, channel : String) -> Unit

fn ws_unsubscribe(id : String, channel : String) -> Unit