declare const noop: {
  readonly saveRequest: <R extends Rpc.Any>(
    envelope: Message.OutgoingRequest<R>
  ) => Effect.Effect<SaveResult<R>, PersistenceError | MalformedMessage>
  readonly saveEnvelope: (
    envelope: Message.OutgoingEnvelope
  ) => Effect.Effect<void, PersistenceError | MalformedMessage>
  readonly saveReply: <R extends Rpc.Any>(
    reply: Reply.ReplyWithContext<R>
  ) => Effect.Effect<void, PersistenceError | MalformedMessage>
  readonly repliesFor: <R extends Rpc.Any>(
    requests: Iterable<Message.OutgoingRequest<R>>
  ) => Effect.Effect<Array<Reply.Reply<R>>, PersistenceError | MalformedMessage>
  readonly registerReplyHandler: <R extends Rpc.Any>(
    message: Message.OutgoingRequest<R> | Message.IncomingRequest<R>
  ) => Effect.Effect<void>
  readonly unprocessedMessages: (
    shardIds: Iterable<ShardId>
  ) => Effect.Effect<Array<Message.Incoming<any>>, PersistenceError>
  readonly unprocessedMessagesById: <R extends Rpc.Any>(
    messageIds: Iterable<Snowflake.Snowflake>
  ) => Effect.Effect<Array<Message.Incoming<R>>, PersistenceError>
  readonly resetShards: (shardIds: Iterable<ShardId>) => Effect.Effect<void, PersistenceError>
  readonly resetAddress: (address: EntityAddress) => Effect.Effect<void, PersistenceError>
}

type Encoded = {
  /**
   * Save the provided message and its associated metadata.
   */
  readonly saveEnvelope: (options: {
    readonly envelope: Envelope.Envelope.Encoded
    readonly primaryKey: string | null
    readonly deliverAt: number | null
  }) => Effect.Effect<SaveResult.Encoded, PersistenceError>

  /**
   * Save the provided `Reply` and its associated metadata.
   */
  readonly saveReply: (reply: Reply.ReplyEncoded<any>) => Effect.Effect<void, PersistenceError>

  /**
   * Retrieves the replies for the specified requests.
   *
   * - Un-acknowledged chunk replies
   * - WithExit replies
   */
  readonly repliesFor: (requestIds: Array<string>) => Effect.Effect<Array<Reply.ReplyEncoded<any>>, PersistenceError>

  /**
   * Retrieves the unprocessed messages for the given shards.
   *
   * A message is unprocessed when:
   *
   * - Requests that have no WithExit replies
   *   - Or they have no unacknowledged chunk replies
   * - The latest AckChunk envelope
   * - All Interrupt's for unprocessed requests
   */
  readonly unprocessedMessages: (
    shardIds: ReadonlyArray<number>,
    now: number
  ) => Effect.Effect<
    Array<{
      readonly envelope: Envelope.Envelope.Encoded
      readonly lastSentReply: Option.Option<Reply.ReplyEncoded<any>>
    }>,
    PersistenceError
  >

  /**
   * Retrieves the unprocessed messages by id.
   */
  readonly unprocessedMessagesById: (
    messageIds: ReadonlyArray<Snowflake.Snowflake>,
    now: number
  ) => Effect.Effect<
    Array<{
      readonly envelope: Envelope.Envelope.Encoded
      readonly lastSentReply: Option.Option<Reply.ReplyEncoded<any>>
    }>,
    PersistenceError
  >

  /**
   * Reset the mailbox state for the provided address.
   */
  readonly resetAddress: (address: EntityAddress) => Effect.Effect<void, PersistenceError>

  /**
   * Reset the mailbox state for the provided shards.
   */
  readonly resetShards: (shardIds: ReadonlyArray<number>) => Effect.Effect<void, PersistenceError>
}

type EncodedRepliesOptions<A> = {
  readonly existingRequests: Array<string>
  readonly newRequests: Array<string>
  readonly cursor: Option.Option<A>
}

type EncodedUnprocessedOptions<A> = {
  readonly existingShards: Array<number>
  readonly newShards: Array<number>
  readonly cursor: Option.Option<A>
}

declare class MemoryDriver

type MemoryEntry = {
  readonly envelope: Envelope.Request.Encoded
  lastReceivedChunk: Option.Option<Reply.ChunkEncoded<any>>
  replies: Array<Reply.ReplyEncoded<any>>
}

declare const SaveResult: {
  readonly Success: <A>(args: void) => SaveResult.Success
  readonly Duplicate: <A>(args: {
    readonly originalId: Snowflake.Snowflake
    readonly lastReceivedReply: Option.Option<Reply.Reply<A extends Rpc.Any ? A : never>>
  }) => SaveResult.Duplicate<A extends Rpc.Any ? A : never>
  readonly $is: <Tag extends "Success" | "Duplicate">(
    tag: Tag
  ) => {
    <T extends SaveResult<any>>(u: T): u is T & { readonly _tag: Tag }
    (
      u: unknown
    ): u is
      | Extract<SaveResult.Success, { readonly _tag: Tag }>
      | Extract<SaveResult.Duplicate<never>, { readonly _tag: Tag }>
  }
  readonly $match: {
    <
      A,
      B,
      C,
      D,
      Cases extends {
        readonly Success: (args: SaveResult.Success) => any
        readonly Duplicate: (args: SaveResult.Duplicate<A extends Rpc.Any ? A : never>) => any
      }
    >(
      cases: Cases
    ): (self: SaveResult<A extends Rpc.Any ? A : never>) => Unify<ReturnType<Cases["Success" | "Duplicate"]>>
    <
      A,
      B,
      C,
      D,
      Cases extends {
        readonly Success: (args: SaveResult.Success) => any
        readonly Duplicate: (args: SaveResult.Duplicate<A extends Rpc.Any ? A : never>) => any
      }
    >(
      self: SaveResult<A extends Rpc.Any ? A : never>,
      cases: Cases
    ): Unify<ReturnType<Cases["Success" | "Duplicate"]>>
  }
}

type SaveResult<R> = SaveResult.Success | SaveResult.Duplicate<R>

export interface Success {
  readonly _tag: "Success"
}

export interface Duplicate<R extends Rpc.Any> {
  readonly _tag: "Duplicate"
  readonly originalId: Snowflake.Snowflake
  readonly lastReceivedReply: Option.Option<Reply.Reply<R>>
}

export interface DuplicateEncoded {
  readonly _tag: "Duplicate"
  readonly originalId: Snowflake.Snowflake
  readonly lastReceivedReply: Option.Option<Reply.ReplyEncoded<any>>
}

export interface Constructor extends Data.TaggedEnum.WithGenerics<1> {
  readonly taggedEnum: SaveResult<this["A"] extends Rpc.Any ? this["A"] : never>
}

type Encoded = SaveResult.Success | SaveResult.DuplicateEncoded

declare const SaveResultEncoded: {
  readonly Success: Data.Case.Constructor<SaveResult.Success, "_tag">
  readonly Duplicate: Data.Case.Constructor<SaveResult.DuplicateEncoded, "_tag">
  readonly $is: <Tag extends "Success" | "Duplicate">(
    tag: Tag
  ) => (
    u: unknown
  ) => u is
    | Extract<SaveResult.Success, { readonly _tag: Tag }>
    | Extract<SaveResult.DuplicateEncoded, { readonly _tag: Tag }>
  readonly $match: {
    <
      Cases extends {
        readonly Success: (args: SaveResult.Success) => any
        readonly Duplicate: (args: SaveResult.DuplicateEncoded) => any
      }
    >(
      cases: Cases
    ): (value: SaveResult.Encoded) => Unify<ReturnType<Cases["Success" | "Duplicate"]>>
    <
      Cases extends {
        readonly Success: (args: SaveResult.Success) => any
        readonly Duplicate: (args: SaveResult.DuplicateEncoded) => any
      }
    >(
      value: SaveResult.Encoded,
      cases: Cases
    ): Unify<ReturnType<Cases["Success" | "Duplicate"]>>
  }
}

declare const make: (
  storage: Omit<MessageStorage["Type"], "registerReplyHandler">
) => Effect.Effect<MessageStorage["Type"]>

declare const makeEncoded: (encoded: Encoded) => Effect.Effect<MessageStorage["Type"], never, Snowflake.Generator>

declare class MessageStorage

declare const layerMemory: Layer.Layer<MessageStorage | MemoryDriver, never, ShardingConfig>

declare const layerNoop: Layer.Layer<MessageStorage, never, never>