declare const noop: any

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: any

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: any

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>