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;