interface Duplex {
  readable: ReadableStream
  writable: WritableStream
}

interface StreamEvents {
  /**
   * Data was received from the remote end of the stream
   */
  'message': MessageEvent<Uint8Array | Uint8ArrayList>

  /**
   * The stream closed gracefully - all data written to the stream has been consumed by
   * the underlying sink.
   *
   * No further events will be emitted and the stream cannot be used to send/receive
   * any more data.
   */
  'close': Event

  /**
   * A local or remote error occurred.
   *
   * No further events will be emitted and the stream cannot be used to send/receive
   * any more data.
   */
  'error': ErrorEvent

  /**
   * The local send buffer is empty and the stream can accept new data from the caller
   */
  'drain': Event
}

interface ErrorEvent extends Event {
  /**
   * The error that occurred
   */
  reason: Error

  /**
   * If true the error was local, otherwise it occurred on the remote end of the stream
   */
  local: boolean
}

interface Stream extends TypedEventTarget<StreamEvents> {
  /**
   * When the stream is closed for writing via `close` or `closeWrite`, any buffered data
   * must be consumed by the underling sink within this many ms, otherwise the stream
   * will be reset and an 'error' event emitted.
   *
   * @default 1_000
   */
  closeTimeout: number

  /**
   * If no data is sent or received in this number of ms the stream will be reset and an
   * 'error' event emitted.
   *
   * @default 120_000
   */
  inactivityTimeout: number

  /**
   * The maximum number of bytes to store when paused. If receipt of more bytes from the
   * remote end of the stream causes the buffer size to exceed this value the stream will
   * be reset and an 'error' event emitted.
   */
  maxPauseBufferLength: number

  /**
   * Write data to the stream. If the method returns false it means the internal buffer
   * is now full and the caller should wait for the 'drain' event before sending more
   * data.
   * 
   * This method may throw if:
   *   - The internal send buffer is full
   *   - The stream has previously been closed for writing locally or remotely
   */
  send (data: Uint8Array | Uint8ArrayList): boolean

  /**
   * Returns a promise that resolves once the passed data has been written to the
   * underlying sink.
   * 
   * This method can result in lower throughput since subsequent writes will be delayed
   * until after promise resolution. If throughput is a priority, call `send` without
   * passing any options.
   * 
   * This method may reject if:
   *   - The internal send buffer is full
   *   - The stream has previously been closed for writing locally or remotely
   */
  send (data: Uint8Array | Uint8ArrayList, options: AbortOptions): Promise<void>

  /**
   * Immediately close the stream for reading and writing, discard any unsent/unread
   * data, and emit an error event on the stream.
   */
  abort (err: Error): void

  /**
   * Gracefully close the stream for reading and writing.
   *
   * A 'close' event will be emitted on the stream once all outstanding data has been
   * sent to the remote.
   */
  close (): void

  /**
   * Sends a message to the remote informing them we will not read any more data from
   * the stream.
   *
   * If the writable end of the stream is already closed, a 'close' event will be emitted
   * on the stream.
   */
  closeRead (): void

  /**
   * Gracefully close the stream for writing - any outstanding data will be sent to the
   * remote and any further calls to `.send` will throw.
   *
   * If the readable end of the stream is already closed, a 'close' event will be emitted
   * on the stream once any buffered data has been sent.
   */
  closeWrite (): void

  /**
   * Stop emitting further 'message' events. Any received data will be stored in an
   * internal buffer. If this buffer reaches a preset limit the stream will be reset
   * and an 'error' event emitted.
   * 
   * If the underlying source supports it, the remote peer will be instructed to pause
   * transmission of further data.
   */
  pause (): void

  /**
   * Resume emitting 'message' events.
   * 
   * If the underlying source supports it, the remote peer will be informed that it is
   * ok to start sending data again.
   */
  unpause (): void
}