Reply

declare function isReply(u: unknown): u is Reply<Any>;

declare class Chunk<R extends Rpc.Any> extends Readonly<{
  readonly id: Snowflake;
  readonly requestId: Snowflake;
  readonly sequence: number;
  readonly values: readonly [SuccessChunk<R>, SuccessChunk<R>];
}> & {
  readonly _tag: "Chunk";
} & Pipeable {
  constructor<R extends Any>(args: {
    readonly id: Snowflake;
    readonly requestId: Snowflake;
    readonly sequence: number;
    readonly values: readonly [SuccessChunk<R>, SuccessChunk<R>];
  });
  readonly [TypeId]: symbol;
  static readonly schemaFromSelf: Schema<Chunk<never>>;
  withRequestId(requestId: Snowflake): Chunk<R>;
  static emptyFrom(requestId: Snowflake): Chunk<Any>;
  static schema<R extends Any>(rpc: R): any;
}

interface ChunkEncoded<R extends Rpc.Any> {
  readonly _tag: "Chunk";
  readonly id: string;
  readonly requestId: string;
  readonly sequence: number;
  readonly values: readonly [SuccessChunkEncoded<R>, SuccessChunkEncoded<R>];
}

type Reply<R extends Rpc.Any> = WithExit<R> | Chunk<R>;

type ReplyEncoded<R extends Rpc.Any> = WithExitEncoded<R> | ChunkEncoded<R>;

declare class ReplyWithContext<R extends Rpc.Any> extends Readonly<{
  readonly context: Context<Context<R>>;
  readonly reply: Reply<R>;
  readonly rpc: R;
}> & {
  readonly _tag: "ReplyWithContext";
} & Pipeable {
  constructor<R extends Any>(args: {
    readonly context: Context<Context<R>>;
    readonly reply: Reply<R>;
    readonly rpc: R;
  });
  static fromDefect(options: {
    readonly defect: unknown;
    readonly id: Snowflake;
    readonly requestId: Snowflake;
  }): ReplyWithContext<any>;
  static interrupt(options: {
    readonly id: Snowflake;
    readonly requestId: Snowflake;
  }): ReplyWithContext<any>;
}

declare class WithExit<R extends Rpc.Any> extends Readonly<{
  readonly exit: Exit<R>;
  readonly id: Snowflake;
  readonly requestId: Snowflake;
}> & {
  readonly _tag: "WithExit";
} & Pipeable {
  constructor<R extends Any>(args: {
    readonly exit: Exit<R>;
    readonly id: Snowflake;
    readonly requestId: Snowflake;
  });
  readonly [TypeId]: symbol;
  withRequestId(requestId: Snowflake): WithExit<R>;
  static schema<R extends Any>(rpc: R): any;
}

interface WithExitEncoded<R extends Rpc.Any> {
  readonly _tag: "WithExit";
  readonly exit: ExitEncoded<R>;
  readonly id: string;
  readonly requestId: string;
}

declare const Encoded: Union<readonly Array<Constraint>>

declare const Reply: <R extends Any>(rpc: R) => any;

declare function serialize<R extends Any>(
  self: ReplyWithContext<R>,
): Effect<ReplyEncoded<R>, MalformedMessage>;

declare function serializeLastReceived<R extends Any>(
  self: OutgoingRequest<R>,
): Effect<Option<ReplyEncoded<R>>, MalformedMessage>;

declare const TypeId: unique symbol;

type TypeId = typeof TypeId;