@lesomnus/grpc-dgram 0.0.1 → 0.1.0

package/dist/conn-Dc57BC-h.d.mts

@@ -0,0 +1,775 @@
+import { a as MethodDesc, h as Metadata, n as CallOptions, o as NamedCodec, s as PayloadCodec } from "./desc-BMF2FBqk.mjs";
+//#region src/timing.d.ts
+interface Timing {
+  callMs?: number;
+  livenessMs?: number;
+  retransmitMs?: number;
+  tombstoneMs?: number;
+  holdMs?: number;
+}
+interface ResolvedTiming {
+  callMs: number;
+  livenessMs: number;
+  retransmitMs: number;
+  tombstoneMs: number;
+  holdMs: number;
+  probeMs: number;
+  tickMs: number;
+}
+//#endregion
+//#region src/limits.d.ts
+declare enum DropPolicy {
+  Newest = 0,
+  Oldest = 1
+}
+interface RxBufferConfig {
+  size?: number;
+  policy?: DropPolicy;
+}
+interface ResolvedRxConfig {
+  size: number;
+  policy: DropPolicy;
+}
+interface Limits {
+  maxTombstones?: number;
+  maxTombstoneBytes?: number;
+  maxDeadPeers?: number;
+  maxPendingResets?: number;
+  maxLiveCalls?: number;
+  maxRepliesPerRTI?: number;
+  maxPeerWindow?: number;
+}
+//#endregion
+//#region src/stats.d.ts
+type ProtocolEventKind = 'skipped' | 'dropped' | 'off-shape' | 'reset-sent' | 'reset-received' | 'retransmit' | 'probe-sent' | 'keepalive-sent' | 'liveness-expired' | 'tombstone-replay' | 'data-loss' | 'flow-stall' | 'flow-resume' | 'peer-flow-stall' | 'peer-flow-resume';
+interface ProtocolEvent {
+  readonly kind: ProtocolEventKind;
+  readonly peer?: unknown;
+  readonly sid: number;
+  readonly method: string;
+  readonly count: number;
+}
+type ProtocolStats = (ev: ProtocolEvent) => void;
+interface CounterSnapshot {
+  skipped: number;
+  dropped: number;
+  offShape: number;
+  resetSent: number;
+  resetReceived: number;
+  retransmit: number;
+  probeSent: number;
+  keepaliveSent: number;
+  livenessExpired: number;
+  tombstoneReplay: number;
+  dataLoss: number;
+  flowStall: number;
+  flowResume: number;
+  peerFlowStall: number;
+  peerFlowResume: number;
+}
+declare class Counters {
+  private readonly n;
+  readonly observe: ProtocolStats;
+  snapshot(): CounterSnapshot;
+}
+//#endregion
+//#region src/status.d.ts
+declare enum Code {
+  OK = 0,
+  CANCELLED = 1,
+  UNKNOWN = 2,
+  INVALID_ARGUMENT = 3,
+  DEADLINE_EXCEEDED = 4,
+  NOT_FOUND = 5,
+  ALREADY_EXISTS = 6,
+  PERMISSION_DENIED = 7,
+  RESOURCE_EXHAUSTED = 8,
+  FAILED_PRECONDITION = 9,
+  ABORTED = 10,
+  OUT_OF_RANGE = 11,
+  UNIMPLEMENTED = 12,
+  INTERNAL = 13,
+  UNAVAILABLE = 14,
+  DATA_LOSS = 15,
+  UNAUTHENTICATED = 16
+}
+declare class StatusError extends Error {
+  readonly code: Code;
+  readonly desc: string;
+  constructor(code: Code, desc: string);
+}
+declare function statusError(code: Code, desc: string): StatusError;
+declare class MessageTooLargeError extends Error {
+  constructor(message?: string);
+}
+declare function isMessageTooLarge(err: unknown): boolean;
+declare function toStatusError(err: unknown): StatusError;
+declare function abortCause(signal: AbortSignal): StatusError;
+//#endregion
+//#region src/wire.d.ts
+declare const FlagOpen = 1;
+declare const FlagClose = 2;
+declare const FlagReset = 4;
+declare const FlagPing = 8;
+declare const FlagWindow = 16;
+declare const FlagCompressed = 32;
+declare const SHAPE_MASK: number;
+interface Any {
+  typeUrl: string;
+  value: Uint8Array;
+}
+interface Frame {
+  epoch: number;
+  sid: number;
+  seq: number;
+  flags: number;
+  method: string;
+  codec: string;
+  timeoutMs?: number;
+  payload?: Uint8Array;
+  code?: number;
+  desc: string;
+  header?: Metadata;
+  trailer?: Metadata;
+  peerEpoch: number;
+  window: number;
+  compressor: string;
+  details?: Any[];
+  connWindow: number;
+}
+declare function frame(init?: Partial<Frame>): Frame;
+declare const isOpen: (f: Frame) => boolean;
+declare const isClose: (f: Frame) => boolean;
+declare const isReset: (f: Frame) => boolean;
+declare const isPing: (f: Frame) => boolean;
+declare const isWindow: (f: Frame) => boolean;
+declare const isCompressed: (f: Frame) => boolean;
+declare const shapeOf: (f: Frame) => number;
+declare const hasUnknownFlags: (f: Frame) => boolean;
+declare function legalShape(shape: number): boolean;
+declare const isTerminal: (f: Frame) => boolean;
+declare const isHalfClose: (f: Frame) => boolean;
+declare const isData: (f: Frame) => boolean;
+declare const isHeaderFrame: (f: Frame) => boolean;
+declare function frameStatus(f: Frame): StatusError;
+declare function setFrameError(f: Frame, err: unknown): void;
+declare function resetFor(f: Frame): Frame;
+declare function encodeFrame(f: Frame): Uint8Array;
+declare function decodeFrame(data: Uint8Array): Frame;
+declare function encodeEnvelope(frames: readonly Frame[]): Uint8Array;
+declare function decodeEnvelope(data: Uint8Array): Frame[];
+//#endregion
+//#region src/seam.d.ts
+interface FrameContext {
+  peer?: unknown;
+  reliable?: boolean;
+  signal?: AbortSignal;
+}
+interface FrameHandler {
+  handle(frame: Frame, ctx?: FrameContext): void | Promise<void>;
+}
+interface EnvelopeSender {
+  sendFrames(frames: readonly Frame[], ctx?: FrameContext): Promise<void>;
+}
+interface TransportInfo {
+  reliable(): boolean;
+}
+interface ConnAttacher {
+  attachConn(conn: Conn): void;
+}
+declare function hasTransportInfo(tx: FrameHandler): tx is FrameHandler & TransportInfo;
+declare function hasConnAttacher(tx: FrameHandler): tx is FrameHandler & ConnAttacher;
+declare function unpack(frames: readonly Frame[], h: FrameHandler, ctx?: FrameContext): Promise<void>;
+//#endregion
+//#region src/util.d.ts
+declare class Latch {
+  tripped: boolean;
+  private readonly promise;
+  private resolve;
+  constructor();
+  trip(): void;
+  wait(): Promise<void>;
+}
+declare class FrameQueue {
+  readonly cap: number;
+  dropped: number;
+  private buf;
+  private readWaiters;
+  private spaceWaiters;
+  private putTail;
+  constructor(cap: number);
+  get size(): number;
+  tryTake(): Frame | undefined;
+  tryPut(f: Frame): boolean;
+  putDrop(f: Frame, policy: DropPolicy): number;
+  putBlocking(f: Frame, done: Latch, signal?: AbortSignal): Promise<boolean>;
+  readable(): Promise<void>;
+  private space;
+}
+declare const W_INIT = 32;
+declare const W_CONN = 1024;
+declare const DEFAULT_STALL_MS = 30000;
+type FlowAcquire = 'ok' | 'ended' | 'aborted' | 'stalled';
+interface SenderState {
+  on: boolean;
+  observed: boolean;
+  granted: number;
+  sent: number;
+}
+declare class FlowSender {
+  private on;
+  private observed;
+  private granted;
+  private sent;
+  private readonly waiters;
+  assume(window: number): void;
+  observe(window: number): void;
+  reassume(window: number): void;
+  grant(n: number): void;
+  undo(): boolean;
+  refund(n: number): number;
+  drain(): number;
+  release(): void;
+  tryAcquire(): boolean;
+  empty(): boolean;
+  state(): SenderState;
+  restore(st: SenderState): void;
+  acquire(done: Latch, stallMs: number, signal?: AbortSignal): Promise<FlowAcquire>;
+  parked(): Promise<void>;
+}
+declare class PeerFlowRx {
+  private window;
+  private outstanding;
+  private readonly pending;
+  private readonly evicted;
+  private evictCap;
+  enable(window: number, evictCap: number): void;
+  get active(): boolean;
+  admit(): boolean;
+  retire(epoch: number, n: number, credit: boolean): number;
+  unadmitted(epoch: number, n: number): number;
+  unadmittedEvicted(epoch: number, n: number): number;
+  private hold;
+  private due;
+  renew(): void;
+  stash(epoch: number, state: SenderState): void;
+  unstash(epoch: number): SenderState | undefined;
+  creditEvicted(epoch: number, n: number): void;
+}
+declare const DEFAULT_MAX_RECV_MSG_SIZE: number;
+declare const DEFAULT_MAX_SEND_MSG_SIZE = 2147483647;
+interface Compressor {
+  compress(data: Uint8Array): Uint8Array | Promise<Uint8Array>;
+  decompress(data: Uint8Array, maxBytes: number): Uint8Array | Promise<Uint8Array>;
+}
+declare function getCompressor(name: string): Compressor | undefined;
+//#endregion
+//#region src/server.d.ts
+interface ServerOptions {
+  reliable?: boolean;
+  timing?: FlowTiming;
+  maxHandlerTimeoutMs?: number;
+  rxBuffer?: RxBufferConfig;
+  methodRxBuffer?: Record<string, RxBufferConfig>;
+  limits?: Limits;
+  codecs?: Record<string, NamedCodec>;
+  compressors?: Record<string, Compressor>;
+  maxRecvMsgSize?: number;
+  maxSendMsgSize?: number;
+  unaryInterceptors?: UnaryServerInterceptor[];
+  streamInterceptors?: StreamServerInterceptor[];
+  protocolStats?: ProtocolStats | ProtocolStats[];
+}
+interface ServerContext {
+  readonly signal: AbortSignal;
+  readonly metadata: Metadata | undefined;
+  readonly peer: unknown;
+  readonly method: string;
+  readonly desc: MethodDesc;
+  readonly deadline: number | undefined;
+  setHeader(md: Metadata): void;
+  sendHeader(md?: Metadata): Promise<void>;
+  setTrailer(md: Metadata): void;
+}
+interface ServerReader<Req> {
+  recv(): Promise<Req | undefined>;
+  [Symbol.asyncIterator](): AsyncIterator<Req>;
+}
+interface ServerWriter<Res> {
+  send(msg: Res): Promise<void>;
+}
+type UnaryHandler<Req, Res> = (req: Req, ctx: ServerContext) => Res | Promise<Res>;
+type ServerStreamingHandler<Req, Res> = (req: Req, stream: ServerWriter<Res>, ctx: ServerContext) => void | Promise<void>;
+type ClientStreamingHandler<Req, Res> = (stream: ServerReader<Req>, ctx: ServerContext) => Res | Promise<Res>;
+type BidiHandler<Req, Res> = (stream: ServerReader<Req> & ServerWriter<Res>, ctx: ServerContext) => void | Promise<void>;
+type AnyHandler = UnaryHandler<unknown, unknown> | ServerStreamingHandler<unknown, unknown> | ClientStreamingHandler<unknown, unknown> | BidiHandler<unknown, unknown>;
+interface Registration {
+  desc: MethodDesc<unknown, unknown>;
+  handler: AnyHandler;
+}
+interface SrvTomb {
+  sid: number;
+  term: Frame | undefined;
+  size: number;
+  expireAt: number;
+  lastReplay: number;
+}
+interface HwmCheckpoint {
+  at: number;
+  hwm: number;
+}
+interface PendingReset {
+  due: number;
+  echo: number;
+  peerEcho: number;
+  epoch: number;
+  sid: number;
+}
+declare class PeerState {
+  readonly peer: unknown;
+  readonly epoch: number;
+  readonly reliable: boolean;
+  readonly createdAt: number;
+  readonly maxTombs: number;
+  readonly maxTombBytes: number;
+  hwm: number;
+  cps: HwmCheckpoint[];
+  dead: boolean;
+  readonly tombs: Map<number, SrvTomb>;
+  tombOrder: number[];
+  tombBytes: number;
+  tombFloor: number;
+  readonly calls: Map<number, ServerStream<unknown, unknown>>;
+  liveCalls: number;
+  readonly connTx: FlowSender;
+  lastRx: number;
+  lastTx: number;
+  lastPing: number;
+  constructor(peer: unknown, epoch: number, reliable: boolean, createdAt: number, maxTombs: number, maxTombBytes: number);
+  hwmAged(now: number, ttlMs: number): number;
+  addTomb(sid: number, term: Frame | undefined, expireAt: number): void;
+  removeTomb(sid: number): void;
+  replayDue(tb: SrvTomb, now: number, rtiMs: number): boolean;
+  replayTomb(tb: SrvTomb, now: number, rtiMs: number): Frame | undefined;
+}
+declare class PeerSlot {
+  readonly peer: unknown;
+  readonly epochs: Map<number, PeerState>;
+  liveCalls: number;
+  replyBudget: {
+    windowStart: number;
+    n: number;
+  } | undefined;
+  readonly resetAt: Map<string, number>;
+  readonly pendingResets: Map<string, PendingReset>;
+  flow: PeerFlowRx | undefined;
+  constructor(peer: unknown);
+}
+declare class Server {
+  readonly epoch: number;
+  private readonly tx;
+  private readonly mode;
+  private readonly maxHandlerTimeoutMs;
+  private readonly rxCfg;
+  private readonly methodRx;
+  private readonly limits;
+  private readonly codecs;
+  private readonly compressors;
+  private readonly maxRecv;
+  private readonly maxSend;
+  private readonly stallMs;
+  /** @internal */ readonly pstats: readonly ProtocolStats[];
+  private readonly services;
+  private serving;
+  private readonly slots;
+  private pendingResetTotal;
+  private resetAtTotal;
+  private replyBudgetTotal;
+  private drain;
+  private closed;
+  private liveTasks;
+  private idleWaiters;
+  private sawUnreliable;
+  private readonly sw;
+  private readonly unaryInt;
+  private readonly streamInt;
+  constructor(tx: FrameHandler, opts?: ServerOptions);
+  private protoEvent;
+  register<Req, Res>(desc: MethodDesc<Req, Res> & {
+    clientStreams: false;
+    serverStreams: false;
+  }, handler: UnaryHandler<Req, Res>): void;
+  register<Req, Res>(desc: MethodDesc<Req, Res> & {
+    clientStreams: false;
+    serverStreams: true;
+  }, handler: ServerStreamingHandler<Req, Res>): void;
+  register<Req, Res>(desc: MethodDesc<Req, Res> & {
+    clientStreams: true;
+    serverStreams: false;
+  }, handler: ClientStreamingHandler<Req, Res>): void;
+  register<Req, Res>(desc: MethodDesc<Req, Res> & {
+    clientStreams: true;
+    serverStreams: true;
+  }, handler: BidiHandler<Req, Res>): void;
+  private rxReliable;
+  handle(f: Frame, ctx?: FrameContext): Promise<void>;
+  private open;
+  private rejectOpen;
+  private runUnary;
+  private runStream;
+  private finish;
+  private resetByPeerSid;
+  private sendReset;
+  private allowReply;
+  gracefulStop(): Promise<void>;
+  stop(): Promise<void>;
+  disconnectPeer(peer: unknown, err?: unknown): void;
+  private waitIdle;
+  private taskDone;
+  /** @internal */
+  get timing(): ResolvedTiming;
+  /** @internal */
+  send(f: Frame, ctx: FrameContext): Promise<void>;
+  /** @internal */
+  sendOrThrow(f: Frame, ctx: FrameContext): Promise<void>;
+  /** @internal */
+  txFor(peer: unknown): FrameContext;
+  /** @internal */
+  allowReplyFor(peer: unknown, now: number): boolean;
+  private ensureSlot;
+  private ensurePeer;
+  private observeAdvertisement;
+  /** @internal */
+  advertise(f: Frame, reliable: boolean): void;
+  private ensurePeerFlow;
+  /** @internal */
+  grantPeer(ps: PeerState, n: number): void;
+  private grantEpoch;
+  private grantOn;
+  /** @internal */
+  kickSweep(): void;
+  private hasWork;
+  private sweep;
+}
+declare class ServerStream<Req, Res> implements ServerReader<Req>, ServerWriter<Res> {
+  private readonly server;
+  readonly peer: unknown;
+  readonly clientEpoch: number;
+  readonly sid: number;
+  /** @internal */ readonly reg: Registration;
+  /** @internal */ readonly reliable: boolean;
+  private readonly comp;
+  private readonly maxRecv;
+  private readonly maxSend;
+  private readonly stallMs;
+  readonly context: ServerContext;
+  /** @internal */ ps: PeerState | undefined;
+  /** @internal */ pf: PeerFlowRx | undefined;
+  /** @internal */ slot: PeerSlot | undefined;
+  /** @internal */ deadlineAt: number | undefined;
+  /** @internal */ deadlineTimer: ReturnType<typeof setTimeout> | undefined;
+  /** @internal */ metadata: Metadata | undefined;
+  /** @internal */ suppressTerm: boolean;
+  /** @internal */ readonly flowTx: FlowSender;
+  private readonly flowRx;
+  private readonly txSeq;
+  /** @internal */ txHeader: Metadata | undefined;
+  private hdrSent;
+  private hdrFlushed;
+  private hdrFrame;
+  /** @internal */ trailerMd: Metadata | undefined;
+  private resp;
+  private respSet;
+  private lastRx;
+  private lastTx;
+  private lastProbe;
+  private hReplayAt;
+  private readonly rxWin;
+  private pinned;
+  private rxReleased;
+  /** @internal */ readonly rxq: FrameQueue;
+  private readonly rxCfg;
+  /** @internal */ rxDropped: number;
+  /** @internal */ readonly rxEOF: Latch;
+  private readonly ctrl;
+  private readonly endLatch;
+  /** @internal */
+  constructor(server: Server, peer: unknown, clientEpoch: number, sid: number, /** @internal */ reg: Registration, codec: {
+    request: PayloadCodec<unknown>;
+    response: PayloadCodec<unknown>;
+  }, rxCfg: ResolvedRxConfig, /** @internal */ reliable: boolean, comp: Compressor | undefined, maxRecv: number, maxSend: number, stallMs: number);
+  /** @internal */ readonly reqCodec: PayloadCodec<unknown>;
+  /** @internal */ readonly resCodec: PayloadCodec<unknown>;
+  get signal(): AbortSignal;
+  /** @internal */
+  cancel(cause: StatusError): void;
+  /** @internal */
+  protoEvent(kind: ProtocolEventKind, count?: number): void;
+  /** @internal */
+  handleRx(f: Frame, ctx: FrameContext): Promise<void>;
+  private noteValidatedRx;
+  recv(): Promise<Req | undefined>;
+  private recvBuffered;
+  private pin;
+  private unpin;
+  /** @internal */
+  releasePinned(): void;
+  private creditUnbuffered;
+  private retirePeer;
+  [Symbol.asyncIterator](): AsyncIterator<Req>;
+  /** @internal */
+  transmit(f: Frame): Promise<void>;
+  private nextFrame;
+  private attachHeader;
+  /** @internal */
+  sendH(): void;
+  private grantWindow;
+  private replayH;
+  /** @internal */
+  probeDue(now: number, probeMs: number, epoch: number): Frame | undefined;
+  /** @internal */
+  setHeader(md: Metadata): void;
+  /** @internal */
+  sendHeader(md?: Metadata): Promise<void>;
+  send(msg: Res): Promise<void>;
+  private transmitOrThrow;
+  private undoRefused;
+  private undoCredit;
+  private encodePayload;
+  /** @internal */
+  decodeMessage(f: Frame): Promise<unknown>;
+  /** @internal */
+  setResponse(resp: unknown): void;
+  /** @internal */
+  terminalFrame(err: StatusError | undefined): Promise<Frame>;
+  /** @internal */
+  transmitTerminal(f: Frame): Promise<void>;
+  private tryTransmit;
+}
+//#endregion
+//#region src/interceptor.d.ts
+interface ClientCall<Req = unknown, Res = unknown> {
+  readonly desc: MethodDesc<Req, Res>;
+  opts: CallConfig<Req, Res>;
+}
+type UnaryInvoker = (req: unknown, call: ClientCall) => Promise<NonNullable<unknown>>;
+type UnaryClientInterceptor = (req: unknown, call: ClientCall, next: UnaryInvoker) => Promise<NonNullable<unknown>>;
+type Streamer = (call: ClientCall) => ClientStream<unknown, unknown>;
+type StreamClientInterceptor = (call: ClientCall, next: Streamer) => ClientStream<unknown, unknown>;
+type UnaryServerHandler = (req: unknown, ctx: ServerContext) => Promise<NonNullable<unknown>>;
+type UnaryServerInterceptor = (req: unknown, ctx: ServerContext, next: UnaryServerHandler) => Promise<NonNullable<unknown>>;
+type StreamServerHandler = (stream: ServerReader<unknown> & ServerWriter<unknown>, ctx: ServerContext) => Promise<unknown>;
+type StreamServerInterceptor = (stream: ServerReader<unknown> & ServerWriter<unknown>, ctx: ServerContext, next: StreamServerHandler) => Promise<unknown>;
+//#endregion
+//#region src/conn.d.ts
+declare class EndOfStreamError extends Error {
+  constructor();
+}
+interface FlowTiming extends Timing {
+  stallMs?: number;
+}
+interface CallConfig<Req = unknown, Res = unknown> extends CallOptions<Req, Res> {
+  compressor?: string;
+  maxRecvMsgSize?: number;
+  maxSendMsgSize?: number;
+}
+interface ConnOptions {
+  reliable?: boolean;
+  timing?: FlowTiming;
+  rxBuffer?: RxBufferConfig;
+  limits?: Limits;
+  compressor?: string;
+  maxRecvMsgSize?: number;
+  maxSendMsgSize?: number;
+  compressors?: Record<string, Compressor>;
+  defaultCallOptions?: CallConfig;
+  unaryInterceptors?: UnaryClientInterceptor[];
+  streamInterceptors?: StreamClientInterceptor[];
+  protocolStats?: ProtocolStats | ProtocolStats[];
+}
+interface CallInfo {
+  compressorName: string;
+  compressor: Compressor | undefined;
+  maxRecv: number;
+  maxSend: number;
+  stallMs: number;
+}
+type DetailedStatusError = StatusError & {
+  details?: readonly Any[];
+};
+declare function statusDetails(err: unknown): readonly Any[] | undefined;
+declare class Conn {
+  readonly epoch: number;
+  private readonly tx;
+  private readonly mode;
+  private readonly rxCfg;
+  private readonly limits;
+  private readonly defaults;
+  private readonly compressor;
+  private readonly compressors;
+  private readonly maxRecv;
+  private readonly maxSend;
+  private readonly stallMs;
+  /** @internal */ readonly pstats: readonly ProtocolStats[];
+  private readonly ss;
+  private readonly tombs;
+  private readonly resetAt;
+  private sidNext;
+  private exhausted;
+  private closed;
+  /** @internal */ readonly connTx: FlowSender;
+  /** @internal */ readonly connRx: PeerFlowRx;
+  private srvEpoch;
+  private srvEpochSet;
+  private lastRx;
+  private lastTx;
+  private lastPing;
+  private readonly sw;
+  private readonly unaryInt;
+  private readonly streamInt;
+  constructor(tx: FrameHandler, opts?: ConnOptions);
+  get reliable(): boolean;
+  private protoEvent;
+  handle(f: Frame, ctx?: FrameContext): Promise<void>;
+  close(err?: unknown): void;
+  invoke<Req, Res>(desc: MethodDesc<Req, Res>, req: Req, opts?: CallConfig<Req, Res>): Promise<Res>;
+  private doInvoke;
+  newStream<Req, Res>(desc: MethodDesc<Req, Res>, opts?: CallConfig<Req, Res>): ClientStream<Req, Res>;
+  private doNewStream;
+  private resolveCall;
+  private createStream;
+  /** @internal */
+  get timing(): ResolvedTiming;
+  /** @internal */
+  get isReliable(): boolean;
+  /** @internal */
+  get streamRxCfg(): ResolvedRxConfig;
+  /** @internal */
+  transmit(f: Frame): Promise<void>;
+  /** @internal */
+  noteRx(): void;
+  /** @internal */
+  lockServerEpoch(epoch: number): void;
+  /** @internal */
+  observeAdvertisement(f: Frame): void;
+  /** @internal */
+  get locked(): boolean;
+  private serverEpochIs;
+  private serverCurrent;
+  /** @internal */
+  creditUnbuffered(f: Frame): void;
+  /** @internal */
+  retirePeer(n: number, epoch: number): void;
+  /** @internal */
+  get peerWindow(): number;
+  private grantPeer;
+  /** @internal */
+  retire(s: ClientStream<unknown, unknown>): void;
+  private clearTombAbort;
+  private sendReset;
+  private failAll;
+  /** @internal */
+  kickSweep(): void;
+  private hasWork;
+  private sweep;
+}
+declare class ClientStream<Req, Res> {
+  readonly sid: number;
+  private readonly conn;
+  private readonly desc;
+  private readonly reqCodec;
+  private readonly resCodec;
+  private readonly codecName;
+  private readonly openHdr;
+  private readonly ci;
+  private readonly flowTx;
+  private readonly flowRx;
+  private readonly rxSize;
+  private readonly callerSignal;
+  private signalDispose;
+  private deadlineTimer;
+  private deadlineFired;
+  private readonly timeoutCause;
+  /** @internal */
+  deadlineAt: number | undefined;
+  private readonly txSeq;
+  private txOpened;
+  private txClosed;
+  /** @internal */
+  abortFrame: Frame | undefined;
+  private retxOpen;
+  private retxClose;
+  private retxAt;
+  private retxIval;
+  private lastRx;
+  private lastTx;
+  private lastProbe;
+  private readonly rxWin;
+  private srvEpoch;
+  private srvEpochSet;
+  private pinned;
+  private rxReleased;
+  private readonly rxq;
+  private readonly rxPolicy;
+  private rxDropped;
+  private rxHeader;
+  private trailerMd;
+  private readonly hdrLatch;
+  private readonly done;
+  private term;
+  private termErr;
+  private termPayloadDelivered;
+  /** @internal */
+  constructor(conn: Conn, desc: MethodDesc<Req, Res>, sid: number, opts: CallConfig<Req, Res>, ci: CallInfo, timeoutCause: StatusError | undefined);
+  /** @internal */
+  arm(opts: CallOptions<Req, Res>): void;
+  private pin;
+  private unpin;
+  private undoCredit;
+  /** @internal */
+  protoEvent(kind: ProtocolEventKind, count?: number): void;
+  /** @internal */
+  handleRx(f: Frame, ctx: FrameContext): Promise<void>;
+  private grantWindow;
+  private recvInto;
+  private latchHeader;
+  private noteValidatedRx;
+  private openFrame;
+  private nextFrame;
+  /** @internal */
+  sendOpen(): Promise<void>;
+  /** @internal */
+  sendRaw(m: Req): Promise<void>;
+  private undoRefused;
+  send(m: Req): Promise<void>;
+  closeSend(): void;
+  recv(): Promise<Res | undefined>;
+  private recvBuffered;
+  private terminalRecv;
+  [Symbol.asyncIterator](): AsyncIterator<Res>;
+  header(): Promise<Metadata | undefined>;
+  trailer(): Metadata | undefined;
+  latchedHeader(): Metadata | undefined;
+  cancel(): void;
+  private abortFromCtx;
+  private sendAbort;
+  private finishTerm;
+  /** @internal */
+  finishLocal(err: StatusError): void;
+  /** @internal */
+  abandon(): void;
+  /** @internal */
+  finishReset(): void;
+  private release;
+  /** @internal */
+  transmit(f: Frame): Promise<void>;
+  private scheduleRetx;
+  /** @internal */
+  dropRetx(): void;
+  /** @internal */
+  sweepRetx(now: number, capMs: number): Frame[];
+  /** @internal */
+  probeDue(now: number, probeMs: number): Frame | undefined;
+}
+//#endregion
+export { encodeEnvelope as $, DEFAULT_STALL_MS as A, DropPolicy as At, hasTransportInfo as B, ServerReader as C, statusError as Ct, Compressor as D, ProtocolEvent as Dt, UnaryHandler as E, Counters as Et, EnvelopeSender as F, FlagOpen as G, Any as H, FrameContext as I, FlagWindow as J, FlagPing as K, FrameHandler as L, W_INIT as M, RxBufferConfig as Mt, getCompressor as N, Timing as Nt, DEFAULT_MAX_RECV_MSG_SIZE as O, ProtocolEventKind as Ot, ConnAttacher as P, decodeFrame as Q, TransportInfo as R, ServerOptions as S, isMessageTooLarge as St, ServerWriter as T, CounterSnapshot as Tt, FlagClose as U, unpack as V, FlagCompressed as W, SHAPE_MASK as X, Frame as Y, decodeEnvelope as Z, UnaryServerInterceptor as _, shapeOf as _t, DetailedStatusError as a, isCompressed as at, Server as b, StatusError as bt, statusDetails as c, isHeaderFrame as ct, StreamServerHandler as d, isReset as dt, encodeFrame as et, StreamServerInterceptor as f, isTerminal as ft, UnaryServerHandler as g, setFrameError as gt, UnaryInvoker as h, resetFor as ht, ConnOptions as i, isClose as it, W_CONN as j, Limits as jt, DEFAULT_MAX_SEND_MSG_SIZE as k, ProtocolStats as kt, ClientCall as l, isOpen as lt, UnaryClientInterceptor as m, legalShape as mt, ClientStream as n, frameStatus as nt, EndOfStreamError as o, isData as ot, Streamer as p, isWindow as pt, FlagReset as q, Conn as r, hasUnknownFlags as rt, FlowTiming as s, isHalfClose as st, CallConfig as t, frame as tt, StreamClientInterceptor as u, isPing as ut, BidiHandler as v, Code as vt, ServerStreamingHandler as w, toStatusError as wt, ServerContext as x, abortCause as xt, ClientStreamingHandler as y, MessageTooLargeError as yt, hasConnAttacher as z };