Message

type Incoming<R extends Rpc.Any> = IncomingRequest<R> | IncomingEnvelope;

declare class IncomingEnvelope extends Readonly<{
  readonly _tag: "IncomingEnvelope";
  readonly envelope: AckChunk | Interrupt;
}> & {
  readonly _tag: "IncomingEnvelope";
} & Pipeable {
  constructor(args: {
    readonly envelope: AckChunk | Interrupt;
  });
}

type IncomingLocal<R extends Rpc.Any> = IncomingRequestLocal<R> | IncomingEnvelope;

declare function incomingLocalFromOutgoing<R extends Any>(self: Outgoing<R>): IncomingLocal<R>;

declare class IncomingRequest<R extends Rpc.Any> extends Readonly<{
  readonly envelope: PartialEncoded;
  readonly lastSentReply: Option<ReplyEncoded<R>>;
  readonly respond: (reply: ReplyWithContext<R>) => Effect<void, MalformedMessage | PersistenceError>;
}> & {
  readonly _tag: "IncomingRequest";
} & Pipeable {
  constructor<R extends Any>(args: {
    readonly envelope: PartialEncoded;
    readonly lastSentReply: Option<ReplyEncoded<R>>;
    readonly respond: (reply: ReplyWithContext<R>) => Effect<void, MalformedMessage | PersistenceError>;
  });
}

declare class IncomingRequestLocal<R extends Rpc.Any> extends Readonly<{
  readonly envelope: Request<R>;
  readonly lastSentReply: Option<Reply<R>>;
  readonly respond: (reply: Reply<R>) => Effect<void, MalformedMessage | PersistenceError>;
}> & {
  readonly _tag: "IncomingRequestLocal";
} & Pipeable {
  constructor<R extends Any>(args: {
    readonly envelope: Request<R>;
    readonly lastSentReply: Option<Reply<R>>;
    readonly respond: (reply: Reply<R>) => Effect<void, MalformedMessage | PersistenceError>;
  });
}

type Outgoing<R extends Rpc.Any> = OutgoingRequest<R> | OutgoingEnvelope;

declare class OutgoingEnvelope extends Readonly<{
  readonly envelope: AckChunk | Interrupt;
  readonly rpc: AnyWithProps;
}> & {
  readonly _tag: "OutgoingEnvelope";
} & Pipeable {
  constructor(args: {
    readonly envelope: AckChunk | Interrupt;
    readonly rpc: AnyWithProps;
  });
  static interrupt(options: {
    readonly address: EntityAddress;
    readonly id: Snowflake;
    readonly requestId: Snowflake;
  }): OutgoingEnvelope;
}

declare class OutgoingRequest<R extends Rpc.Any> extends Readonly<{
  readonly context: Context<Context<R>>;
  readonly envelope: Request<R>;
  readonly lastReceivedReply: Option<Reply<R>>;
  readonly respond: (reply: Reply<R>) => Effect<void>;
  readonly rpc: R;
}> & {
  readonly _tag: "OutgoingRequest";
} & Pipeable {
  constructor<R extends Any>(args: {
    readonly context: Context<Context<R>>;
    readonly envelope: Request<R>;
    readonly lastReceivedReply: Option<Reply<R>>;
    readonly respond: (reply: Reply<R>) => Effect<void>;
    readonly rpc: R;
  });
  encodedCache?: PartialEncoded;
}

declare function deserializeLocal<Rpc extends Any>(
  self: Outgoing<Rpc>,
  encoded: PartialEncoded,
): Effect<IncomingLocal<Rpc>, MalformedMessage>;

declare function serialize<Rpc extends Any>(
  message: Outgoing<Rpc>,
): Effect<PartialEncoded, MalformedMessage>;

declare function serializeEnvelope<Rpc extends Any>(
  message: Outgoing<Rpc>,
): Effect<Encoded, MalformedMessage>;

declare function serializeRequest<Rpc extends Any>(
  self: OutgoingRequest<Rpc>,
): Effect<PartialEncoded, MalformedMessage>;