std/amqp

enum Value {
  Null
  Bool(v: Bool)
  UByte(v: UInt8)
  UShort(v: UInt16)
  UInt(v: UInt32)
  ULong(v: UInt64)
  Byte(v: Int8)
  Short(v: Int16)
  Int(v: Int32)
  Long(v: Int64)
  Float(v: Float32)
  Double(v: Float)
  Decimal32(bits: UInt32)
  Decimal64(bits: UInt64)
  Decimal128(bits: Bytes)
  Char(v: Rune)
  Timestamp(ms: Int)
  Uuid(bytes: Bytes)
  Binary(v: Bytes)
  Str(v: Str)
  Symbol(v: Str)
  List(items: List[Value])
  Map(pairs: List[(Value, Value)])
  Array(items: List[Value])
  Described(descriptor: Value, value: Value)
}

enum AmqpErr {
  Decode(msg: Str)
  Encode(msg: Str)
  Net(msg: Str)
  Protocol(msg: Str)
  Peer(error: WireError)
  Auth(code: Int, msg: Str)
}

enum Role {
  Sender
  Receiver
}

enum SenderSettleMode {
  Unsettled
  Settled
  Mixed
}

enum ReceiverSettleMode {
  First
  Second
}

struct WireError {
  condition: Str
  description: Str = ""
  info: List[(Str, Value)] = []
}

enum DeliveryState {
  Received(section_number: UInt32, section_offset: UInt64)
  Accepted
  Rejected(error: WireError?)
  Released
  Modified(delivery_failed: Bool, undeliverable_here: Bool, annotations: List[(Value, Value)])
}

struct Source {
  address: Str = ""
  durable: Int = 0
  expiry_policy: Str = ""
  timeout: Int = 0
  dynamic: Bool = false
  dynamic_node_properties: List[(Str, Value)] = []
  distribution_mode: Str = ""
  filter: List[(Str, Value)] = []
  default_outcome: Value = Value.Null
  outcomes: List[Str] = []
  capabilities: List[Str] = []
}

struct Target {
  address: Str = ""
  durable: Int = 0
  expiry_policy: Str = ""
  timeout: Int = 0
  dynamic: Bool = false
  dynamic_node_properties: List[(Str, Value)] = []
  capabilities: List[Str] = []
}

struct Open {
  container_id: Str
  hostname: Str = ""
  max_frame_size: Int = 4294967295
  channel_max: Int = 65535
  idle_timeout_ms: Int = 0
  outgoing_locales: List[Str] = []
  incoming_locales: List[Str] = []
  offered_capabilities: List[Str] = []
  desired_capabilities: List[Str] = []
  properties: List[(Str, Value)] = []
}

struct Begin {
  remote_channel: UInt16?
  next_outgoing_id: UInt32
  incoming_window: UInt32
  outgoing_window: UInt32
  handle_max: Int = 4294967295
  offered_capabilities: List[Str] = []
  desired_capabilities: List[Str] = []
  properties: List[(Str, Value)] = []
}

struct Attach {
  name: Str
  handle: UInt32
  role: Role
  sender_settle_mode: SenderSettleMode?
  receiver_settle_mode: ReceiverSettleMode?
  source: Source?
  target: Target?
  unsettled: List[(Bytes, DeliveryState?)] = []
  incomplete_unsettled: Bool = false
  initial_delivery_count: Int = 0
  max_message_size: Int = 0
  offered_capabilities: List[Str] = []
  desired_capabilities: List[Str] = []
  properties: List[(Str, Value)] = []
}

struct Flow {
  next_incoming_id: UInt32?
  incoming_window: UInt32
  next_outgoing_id: UInt32
  outgoing_window: UInt32
  handle: UInt32?
  delivery_count: UInt32?
  link_credit: UInt32?
  available: UInt32?
  drain: Bool = false
  echo: Bool = false
  properties: List[(Str, Value)] = []
}

struct Transfer {
  handle: UInt32
  delivery_id: UInt32?
  delivery_tag: Bytes = b""
  message_format: UInt32?
  settled: Bool = false
  more: Bool = false
  receiver_settle_mode: ReceiverSettleMode?
  state: DeliveryState?
  resume: Bool = false
  aborted: Bool = false
  batchable: Bool = false
  payload: Bytes = b""
}

struct Disposition {
  role: Role
  first: UInt32
  last: UInt32?
  settled: Bool = false
  state: DeliveryState?
  batchable: Bool = false
}

struct Detach {
  handle: UInt32
  closed: Bool = false
  error: WireError?
}

struct End {
  error: WireError?
}

struct Close {
  error: WireError?
}

struct SaslMechanisms {
  mechanisms: List[Str]
}

struct SaslInit {
  mechanism: Str
  initial_response: Bytes = b""
  hostname: Str = ""
}

struct SaslChallenge {
  challenge: Bytes
}

struct SaslResponse {
  response: Bytes
}

struct SaslOutcome {
  code: UInt8
  additional_data: Bytes = b""
}

enum FrameBody {
  Open(v: Open)
  Begin(v: Begin)
  Attach(v: Attach)
  Flow(v: Flow)
  Transfer(v: Transfer)
  Disposition(v: Disposition)
  Detach(v: Detach)
  End(v: End)
  Close(v: Close)
  SaslMechanisms(v: SaslMechanisms)
  SaslInit(v: SaslInit)
  SaslChallenge(v: SaslChallenge)
  SaslResponse(v: SaslResponse)
  SaslOutcome(v: SaslOutcome)
  Empty
}

struct Frame {
  channel: UInt16
  body: FrameBody
}

enum Sasl {
  None
  Plain(user: Str, password: Str)
  Anonymous
}

struct ConnOptions {
  container_id: Str = ""
  hostname: Str = ""
  max_frame_size: Int = 65536
  channel_max: Int = 65535
  idle_timeout_ms: Int = 0
  properties: List[(Str, Value)] = []
  sasl: Sasl = Sasl.None
  tls_roots: tls.Roots? = None
  tls_verify: tls.Verify = tls.Verify.Full
  clock: Clock? = None
  timeout_ms: Int = 0
}

enum Transport {
  Plain(c: Conn)
  Tls(t: tls.TlsConn)
}

struct ConnState {
  link: Transport
  buf: Bytes = b""
  max_frame_size: Int = 65536
  peer_max_frame_size: Int = 65536
  peer_channel_max: Int = 65535
  peer_idle_timeout_ms: Int = 0
  peer_container_id: Str = ""
  peer_properties: List[(Str, Value)] = []
  channels: List[Int] = []
  pending: List[Frame] = []
  closed: Bool = false
  clock: Clock? = None
  timeout_ms: Int = 0
  idle_timeout_ms: Int = 0
  last_recv_ms: Int = 0
  last_send_ms: Int = 0
  broken: AmqpErr? = None
  mux: Bool = false
  closing: Bool = false
  close_done: Bool = false
  close_err: AmqpErr? = None
  waiters: List[Chan[Bool]] = []
  sess: List[SessState] = []
  links: List[LinkState] = []
}

struct Connection {
  st: Mutex[ConnState]
}

fn (c: Connection) peer_container_id() -> Str

fn (c: Connection) peer_max_frame_size() -> Int

fn (c: Connection) peer_channel_max() -> Int

fn (c: Connection) peer_idle_timeout_ms() -> Int

fn (c: Connection) peer_properties() -> List[(Str, Value)]

fn (c: Connection) keepalive(g: task.Group) -> () ! AmqpErr uses (net.dial, clock)

fn (c: Connection) send(f: Frame) -> () ! AmqpErr uses (net.dial, clock)

fn (c: Connection) recv() -> Frame ! AmqpErr uses (net.dial, clock)

fn (c: Connection) close(error: WireError? = None) -> () ! AmqpErr uses (net.dial, clock)

fn (c: Connection) abort()

fn (c: Connection) begin(opts: SessionOptions = SessionOptions{}) -> Session ! AmqpErr uses (net.dial, clock)

fn (c: Connection) end_session(s: Session, error: WireError? = None) -> () ! AmqpErr uses (net.dial, clock)

fn (c: Connection) new_sender(s: Session, target: Str, opts: SenderOptions = SenderOptions{}) -> Sender ! AmqpErr uses (net.dial, clock)

fn (c: Connection) new_receiver(s: Session, source: Str, opts: ReceiverOptions = ReceiverOptions{}) -> Receiver ! AmqpErr uses (net.dial, clock)

struct SessionOptions {
  incoming_window: Int = 2048
  outgoing_window: Int = 2048
  handle_max: Int = 4294967295
}

struct Session {
  channel: Int
  remote_channel: Int = 0
  next_outgoing_id: Int = 0
  remote_incoming_window: Int = 0
  remote_outgoing_window: Int = 0
  remote_next_outgoing_id: Int = 0
  incoming_window: Int
  outgoing_window: Int
  handle_max: Int
  remote_handle_max: Int = 0
}

struct Header {
  durable: Bool = false
  priority: Int = 4
  ttl_ms: Int = 0
  first_acquirer: Bool = false
  delivery_count: Int = 0
}

struct Properties {
  message_id: Value = Value.Null
  user_id: Bytes = b""
  to: Str? = None
  subject: Str? = None
  reply_to: Str? = None
  correlation_id: Value = Value.Null
  content_type: Str? = None
  content_encoding: Str? = None
  absolute_expiry_ms: Int? = None
  creation_ms: Int? = None
  group_id: Str? = None
  group_sequence: Int? = None
  reply_to_group_id: Str? = None
}

enum Body {
  Empty
  Data(sections: List[Bytes])
  Sequence(sections: List[List[Value]])
  Value(v: Value)
}

struct Message {
  header: Header? = None
  delivery_annotations: List[(Value, Value)]? = None
  annotations: List[(Value, Value)]? = None
  properties: Properties? = None
  app_properties: List[(Str, Value)]? = None
  body: Body = Body.Empty
  footer: List[(Value, Value)]? = None
}

struct SessState {
  channel: Int
  next_outgoing_id: Int = 0
  next_incoming_id: Int = 0
  incoming_window: Int
  initial_incoming_window: Int
  remote_incoming_window: Int = 0
  ended: Bool = false
  next_handle: Int = 0
  sending: Bool = false
}

struct Delivery {
  message: Message
  id: Int
  tag: Bytes
  settled: Bool
  link: Int
}

struct LinkState {
  id: Int
  name: Str
  channel: Int
  handle: Int
  role: Role
  remote_handle: Int = -1
  attached: Bool = false
  refused: Bool = false
  detached: Bool = false
  error: WireError? = None
  peer_max_message_size: Int = 0
  delivery_count: Int = 0
  credit: Int = 0
  credit_target: Int = 1
  remote_attach: Attach? = None
  draining: Bool = false
  second: Bool = false
  waiting: List[Int] = []
  acks: List[(Int, DeliveryState?)] = []
  tag_counter: Int = 0
  results: List[(Int, DeliveryState?)] = []
  partial: Bytes = b""
  partial_active: Bool = false
  partial_id: Int = 0
  partial_tag: Bytes = b""
  partial_settled: Bool = false
  unsettled: List[Int] = []
  inbox: List[Delivery] = []
}

struct SenderOptions {
  name: Str = ""
  settle_mode: SenderSettleMode? = None
  source: Str = ""
  max_message_size: Int = 0
  properties: List[(Str, Value)] = []
  capabilities: List[Str] = []
  target_capabilities: List[Str] = []
  desired_capabilities: List[Str] = []
}

struct ReceiverOptions {
  name: Str = ""
  credit: Int = 1
  settle_mode: ReceiverSettleMode? = None
  sender_settle_mode: SenderSettleMode? = None
  target: Str = ""
  filters: List[(Str, Value)] = []
  max_message_size: Int = 0
  properties: List[(Str, Value)] = []
  capabilities: List[Str] = []
  source_capabilities: List[Str] = []
  desired_capabilities: List[Str] = []
}

struct Sender {
  conn: Connection
  id: Int
  name: Str
  target: Str
}

fn (x: Sender) send(m: Message, settled: Bool = false, message_format: Int = 0) -> DeliveryState? ! AmqpErr uses (net.dial, clock)

fn (x: Sender) close(error: WireError? = None) -> () ! AmqpErr uses (net.dial, clock)

fn (x: Sender) remote_attach() -> Attach?

struct Receiver {
  conn: Connection
  id: Int
  name: Str
  source: Str
}

fn (r: Receiver) receive(timeout_ms: Int = 0) -> Delivery ! AmqpErr uses (net.dial, clock)

fn (r: Receiver) remote_attach() -> Attach?

fn (r: Receiver) issue_credit(n: Int) -> () ! AmqpErr uses (net.dial, clock)

fn (r: Receiver) drain(timeout_ms: Int = 0) -> List[Delivery] ! AmqpErr uses (net.dial, clock)

fn (r: Receiver) accept(d: Delivery) -> () ! AmqpErr uses (net.dial, clock)

fn (r: Receiver) reject(d: Delivery, error: WireError? = None) -> () ! AmqpErr uses (net.dial, clock)

fn (r: Receiver) release(d: Delivery) -> () ! AmqpErr uses (net.dial, clock)

fn (r: Receiver) modify(d: Delivery, delivery_failed: Bool = true, undeliverable_here: Bool = false, annotations: List[(Str, Value)] = []) -> () ! AmqpErr uses (net.dial, clock)

fn (r: Receiver) close(error: WireError? = None) -> () ! AmqpErr uses (net.dial, clock)

fn encode(v: Value) -> Bytes ! AmqpErr

fn decode(b: Bytes) -> (Value, Int) ! AmqpErr

fn encode_frame(f: Frame) -> Bytes ! AmqpErr

fn decode_frame(b: Bytes, max_size: Int = 4294967295) -> (Frame, Int) ! AmqpErr

fn dial(net: Net, addr: Str, opts: ConnOptions = ConnOptions{}) -> Connection ! AmqpErr uses (net.dial, clock)

fn encode_message(m: Message) -> Bytes ! AmqpErr

fn decode_message(b: Bytes) -> Message ! AmqpErr

fn cbs_put_token(c: Connection, s: Session, audience: Str, token: Str, token_type: Str = "servicebus.windows.net:sastoken", expiry_ms: Int = 0, expiration: Value? = None) -> () ! AmqpErr uses (net.dial, clock)