declare const isReply: (u: unknown) => u is Reply<Rpc.Any>

declare class Chunk<R>

declare const emptyFrom: (requestId: Snowflake) => Chunk<Rpc.Any>

declare const schema: <R extends Rpc.Any>(rpc: R) => Schema.Schema<Chunk<R>, ChunkEncoded<R>, Rpc.Context<R>>

declare const withRequestId: (requestId: Snowflake) => Chunk<R>

readonly [TypeId]: symbol

export interface ChunkEncoded<R extends Rpc.Any> {
  readonly _tag: "Chunk"
  readonly requestId: string
  readonly id: string
  readonly sequence: number
  readonly values: NonEmptyReadonlyArray<Rpc.SuccessChunkEncoded<R>>
}

type Reply<R> = WithExit<R> | Chunk<R>

type ReplyEncoded<R> = WithExitEncoded<R> | ChunkEncoded<R>

declare class ReplyWithContext<R>

declare const fromDefect: (options: {
  readonly id: Snowflake
  readonly requestId: Snowflake
  readonly defect: unknown
}) => ReplyWithContext<any>

declare const interrupt: (options: { readonly id: Snowflake; readonly requestId: Snowflake }) => ReplyWithContext<any>

declare class WithExit<R>

declare const schema: <R extends Rpc.Any>(rpc: R) => Schema.Schema<WithExit<R>, WithExitEncoded<R>, Rpc.Context<R>>

declare const withRequestId: (requestId: Snowflake) => WithExit<R>

readonly [TypeId]: symbol

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

declare const Encoded: Schema.Union<
  [
    Schema.Struct<{
      _tag: Schema.Literal<["WithExit"]>
      requestId: typeof Schema.String
      id: typeof Schema.String
      exit: typeof Schema.Unknown
    }>,
    Schema.Struct<{
      _tag: Schema.Literal<["Chunk"]>
      requestId: typeof Schema.String
      id: typeof Schema.String
      sequence: typeof Schema.Number
      values: Schema.Array$<typeof Schema.Unknown>
    }>
  ]
>

declare const Reply: <R extends Rpc.Any>(rpc: R) => Schema.Schema<Reply<R>, ReplyEncoded<R>, Rpc.Context<R>>

declare const serialize: <R extends Rpc.Any>(
  self: ReplyWithContext<R>
) => Effect.Effect<ReplyEncoded<R>, MalformedMessage>

declare const serializeLastReceived: <R extends Rpc.Any>(
  self: OutgoingRequest<R>
) => Effect.Effect<Option.Option<ReplyEncoded<R>>, MalformedMessage>

declare const TypeId: unique symbol

type TypeId = typeof TypeId