RpcMessage

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

interface AckEncoded {
  readonly _tag: "Ack";
  readonly requestId: string;
}

declare const constEof: Eof

declare const constPing: Ping

interface Eof {
  readonly _tag: "Eof";
}

type FromClient<A extends Rpc.Any> = Request<A> | Ack | Interrupt | Eof

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

interface Interrupt {
  readonly _tag: "Interrupt";
  readonly interruptors: readonly Array<FiberId>;
  readonly requestId: RequestId;
}

interface InterruptEncoded {
  readonly _tag: "Interrupt";
  readonly requestId: string;
}

interface Ping {
  readonly _tag: "Ping";
}

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

interface RequestEncoded {
  readonly _tag: "Request";
  readonly headers: readonly Array<[string, string]>;
  readonly id: string;
  readonly payload: unknown;
  readonly sampled?: boolean;
  readonly spanId?: string;
  readonly tag: string;
  readonly traceId?: string;
}

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

type RequestId = Branded<bigint, RequestIdTypeId>

declare const RequestIdTypeId: unique symbol

type RequestIdTypeId = typeof RequestIdTypeId

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

interface ClientProtocolError {
  readonly _tag: "ClientProtocolError";
  readonly error: RpcClientError;
}

declare const constPong: Pong

type FromServer<A extends Rpc.Any> = ResponseChunk<A> | ResponseExit<A> | ResponseDefect | ClientEnd

type FromServerEncoded = ResponseChunkEncoded | ResponseExitEncoded | ResponseDefectEncoded | Pong | ClientProtocolError

interface Pong {
  readonly _tag: "Pong";
}

interface ResponseChunk<A extends Rpc.Any> {
  readonly _tag: "Chunk";
  readonly clientId: number;
  readonly requestId: RequestId;
  readonly values: readonly [SuccessChunk<A>, SuccessChunk<A>];
}

interface ResponseChunkEncoded {
  readonly _tag: "Chunk";
  readonly requestId: string;
  readonly values: readonly [unknown, unknown];
}

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

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

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

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

interface ResponseExitEncoded {
  readonly _tag: "Exit";
  readonly exit: ExitEncoded<unknown, unknown, unknown>;
  readonly requestId: string;
}

type ResponseId = Branded<number, ResponseIdTypeId>

declare const ResponseIdTypeId: unique symbol

type ResponseIdTypeId = typeof ResponseIdTypeId