declare const makeRequest: <Rpc extends Rpc.Any>(options: {
  readonly requestId: Snowflake
  readonly address: EntityAddress
  readonly tag: Rpc.Tag<Rpc>
  readonly payload: Rpc.Payload<Rpc>
  readonly headers: Headers.Headers
  readonly traceId?: string | undefined
  readonly spanId?: string | undefined
  readonly sampled?: boolean | undefined
}) => Request<Rpc>

declare class AckChunk

declare const withRequestId: (requestId: Snowflake) => AckChunk

readonly [TypeId]: unique symbol

type Envelope<R> = Request<R> | AckChunk | Interrupt

declare class Interrupt

declare const withRequestId: (requestId: Snowflake) => Interrupt

readonly [TypeId]: unique symbol

export interface Request<in out Rpc extends Rpc.Any> {
  readonly [TypeId]: TypeId
  readonly _tag: "Request"
  readonly requestId: Snowflake
  readonly address: EntityAddress
  readonly tag: Rpc.Tag<Rpc>
  readonly payload: Rpc.Payload<Rpc>
  readonly headers: Headers.Headers
  readonly traceId?: string | undefined
  readonly spanId?: string | undefined
  readonly sampled?: boolean | undefined
}

declare const primaryKey: <R extends Rpc.Any>(envelope: Envelope<R>) => string | null

declare const primaryKeyByAddress: (options: {
  readonly address: EntityAddress
  readonly tag: string
  readonly id: string
}) => string

declare const isEnvelope: (u: unknown) => u is Envelope<any>

declare const EnvelopeFromSelf: Schema.Schema<Envelope.Any, Envelope.Any, never>

declare const PartialEncoded: Schema.Union<
  [
    Schema.Struct<{
      _tag: Schema.Literal<["Request"]>
      requestId: Schema.Schema<Snowflake, string>
      address: typeof EntityAddress
      tag: typeof Schema.String
      payload: typeof Schema.Unknown
      headers: Schema.Schema<Headers.Headers, ReadonlyRecord<string, string>>
      traceId: Schema.optional<typeof Schema.String>
      spanId: Schema.optional<typeof Schema.String>
      sampled: Schema.optional<typeof Schema.Boolean>
    }>,
    typeof AckChunk,
    typeof Interrupt
  ]
>

declare const PartialEncodedArray: Schema.Schema<Array<Envelope.PartialEncoded>, Array<Envelope.Encoded>, never>

declare const PartialEncodedFromSelf: Schema.Union<
  [
    Schema.Struct<{
      _tag: Schema.Literal<["Request"]>
      requestId: Schema.Schema<Snowflake>
      address: Schema.Schema<EntityAddress>
      tag: typeof Schema.String
      payload: typeof Schema.Unknown
      headers: Schema.Schema<Headers.Headers>
      traceId: Schema.optional<typeof Schema.String>
      spanId: Schema.optional<typeof Schema.String>
      sampled: Schema.optional<typeof Schema.Boolean>
    }>,
    Schema.Schema<AckChunk, AckChunk, never>,
    Schema.Schema<Interrupt, Interrupt, never>
  ]
>

declare const PartialEncodedRequest: Schema.Struct<{
  _tag: Schema.Literal<["Request"]>
  requestId: Schema.Schema<Snowflake, string>
  address: typeof EntityAddress
  tag: typeof Schema.String
  payload: typeof Schema.Unknown
  headers: Schema.Schema<Headers.Headers, ReadonlyRecord<string, string>>
  traceId: Schema.optional<typeof Schema.String>
  spanId: Schema.optional<typeof Schema.String>
  sampled: Schema.optional<typeof Schema.Boolean>
}>

declare const PartialEncodedRequestFromSelf: Schema.Struct<{
  _tag: Schema.Literal<["Request"]>
  requestId: Schema.Schema<Snowflake>
  address: Schema.Schema<EntityAddress>
  tag: typeof Schema.String
  payload: typeof Schema.Unknown
  headers: Schema.Schema<Headers.Headers>
  traceId: Schema.optional<typeof Schema.String>
  spanId: Schema.optional<typeof Schema.String>
  sampled: Schema.optional<typeof Schema.Boolean>
}>

declare const RequestFromSelf: Schema.Schema<Request.Any, Request.Any, never>

declare const TypeId: unique symbol

type TypeId = typeof TypeId

type Any = Envelope<any>

type Encoded = Request.Encoded | typeof AckChunk.Encoded | typeof Interrupt.Encoded

type PartialEncoded = Request.PartialEncoded | AckChunk | Interrupt

export interface Encoded {
  readonly _tag: "Request"
  readonly requestId: string
  readonly address: typeof EntityAddress.Encoded
  readonly tag: string
  readonly payload: unknown
  readonly headers: ReadonlyRecord<string, string>
  readonly traceId?: string | undefined
  readonly spanId?: string | undefined
  readonly sampled?: boolean | undefined
}

export interface PartialEncoded {
  readonly _tag: "Request"
  readonly requestId: Snowflake
  readonly address: EntityAddress
  readonly tag: string
  readonly payload: unknown
  readonly headers: Headers.Headers
  readonly traceId?: string | undefined
  readonly spanId?: string | undefined
  readonly sampled?: boolean | undefined
}

type Any = Request<any>