export interface Ack {
  readonly _tag: "Ack"
  readonly requestId: RequestId
}

export interface Eof {
  readonly _tag: "Eof"
}

type FromClient<A> = Request<A> | Ack | Interrupt | Eof

type FromClientEncoded = RequestEncoded | Ack | InterruptEncoded | Ping | Eof

export interface Interrupt {
  readonly _tag: "Interrupt"
  readonly requestId: RequestId
  readonly interruptors: ReadonlyArray<FiberId.FiberId>
}

export interface InterruptEncoded {
  readonly _tag: "Interrupt"
  readonly requestId: RequestId
}

export interface Ping {
  readonly _tag: "Ping"
}

export interface Request<A extends Rpc.Any> {
  readonly _tag: "Request"
  readonly id: RequestId
  readonly tag: Rpc.Tag<A>
  readonly payload: Rpc.Payload<A>
  readonly traceId: string
  readonly spanId: string
  readonly sampled: boolean
  readonly headers: Headers
}

export interface RequestEncoded {
  readonly _tag: "Request"
  readonly id: bigint | string
  readonly tag: string
  readonly payload: unknown
  readonly traceId: string
  readonly spanId: string
  readonly sampled: boolean
  readonly headers: ReadonlyArray<[string, string]>
}

declare const RequestId: (id: bigint | string) => RequestId

type RequestId = Branded<bigint, RequestIdTypeId>

declare const RequestIdTypeId: unique symbol

type RequestIdTypeId = typeof RequestIdTypeId

declare const constEof: Eof

declare const constPing: Ping

export interface ClientEnd {
  readonly _tag: "ClientEnd"
  readonly clientId: number
}

type FromServer<A> = ResponseChunk<A> | ResponseExit<A> | ResponseDefect | ClientEnd

type FromServerEncoded = ResponseChunkEncoded | ResponseExitEncoded | ResponseDefectEncoded | Pong

export interface Pong {
  readonly _tag: "Pong"
}

export interface ResponseChunk<A extends Rpc.Any> {
  readonly _tag: "Chunk"
  readonly clientId: number
  readonly requestId: RequestId
  readonly values: NonEmptyReadonlyArray<Rpc.SuccessChunk<A>>
}

export interface ResponseChunkEncoded {
  readonly _tag: "Chunk"
  readonly requestId: bigint | string
  readonly values: NonEmptyReadonlyArray<unknown>
}

export interface ResponseDefect {
  readonly _tag: "Defect"
  readonly clientId: number
  readonly defect: unknown
}

declare const ResponseDefectEncoded: (input: unknown) => ResponseDefectEncoded

export interface ResponseDefectEncoded {
  readonly _tag: "Defect"
  readonly defect: unknown
}

export interface ResponseExit<A extends Rpc.Any> {
  readonly _tag: "Exit"
  readonly clientId: number
  readonly requestId: RequestId
  readonly exit: Rpc.Exit<A>
}

export interface ResponseExitEncoded {
  readonly _tag: "Exit"
  readonly requestId: bigint | string
  readonly exit: Schema.ExitEncoded<unknown, unknown, unknown>
}

type ResponseId = Branded<number, ResponseIdTypeId>

declare const ResponseIdTypeId: unique symbol

type ResponseIdTypeId = typeof ResponseIdTypeId

declare const constPong: Pong