MessageStorage

declare function make(
  storage: Omit<
    MessageStorage["Type"],
    "registerReplyHandler" | "unregisterReplyHandler" | "unregisterShardReplyHandlers"
  >,
): Effect<any>;

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

declare const noop: MessageStorage["Type"];

declare class MessageStorage extends any {
  constructor();
}

type Encoded = {
  readonly clearAddress: (address: EntityAddress) => Effect.Effect<void, PersistenceError>;
  readonly clearReplies: (requestId: Snowflake.Snowflake) => Effect.Effect<void, PersistenceError>;
  readonly repliesFor: (
    requestIds: Arr.NonEmptyArray<string>,
  ) => Effect.Effect<Array<Reply.ReplyEncoded<any>>, PersistenceError>;
  readonly repliesForUnfiltered: (
    requestIds: Arr.NonEmptyArray<string>,
  ) => Effect.Effect<Array<Reply.ReplyEncoded<any>>, PersistenceError>;
  readonly requestIdForPrimaryKey: (
    primaryKey: string,
  ) => Effect.Effect<Option.Option<Snowflake.Snowflake>, PersistenceError>;
  readonly resetAddress: (address: EntityAddress) => Effect.Effect<void, PersistenceError>;
  readonly resetShards: (
    shardIds: Arr.NonEmptyArray<string>,
  ) => Effect.Effect<void, PersistenceError>;
  readonly saveEnvelope: (options: {
    readonly deliverAt: number | null;
    readonly envelope: Envelope.Envelope.Encoded;
    readonly primaryKey: string | null;
  }) => Effect.Effect<SaveResult.Encoded, PersistenceError>;
  readonly saveReply: (reply: Reply.ReplyEncoded<any>) => Effect.Effect<void, PersistenceError>;
  readonly unprocessedMessages: (
    shardIds: Arr.NonEmptyArray<string>,
    now: number,
  ) => Effect.Effect<
    Array<{
      readonly envelope: Envelope.Envelope.Encoded;
      readonly lastSentReply: Option.Option<Reply.ReplyEncoded<any>>;
    }>,
    PersistenceError
  >;
  readonly unprocessedMessagesById: (
    messageIds: Arr.NonEmptyArray<Snowflake.Snowflake>,
    now: number,
  ) => Effect.Effect<
    Array<{
      readonly envelope: Envelope.Envelope.Encoded;
      readonly lastSentReply: Option.Option<Reply.ReplyEncoded<any>>;
    }>,
    PersistenceError
  >;
};

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

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

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

declare const layerNoop: Layer.Layer<MessageStorage>;

declare class MemoryDriver extends any {
  constructor();
}

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

declare const SaveResult: {
  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<
          Success,
          {
            readonly _tag: Tag;
          }
        >
      | Extract<
          Duplicate<unknown>,
          {
            readonly _tag: Tag;
          }
        >;
  };
  readonly $match: {
    <
      A,
      B,
      C,
      D,
      Cases extends {
        Duplicate: (args: Duplicate<A extends Any ? A : never>) => any;
        Success: (args: Success) => any;
      },
    >(
      cases: Cases,
    ): (
      self: SaveResult<A extends Any ? A : never>,
    ) => Unify<ReturnType<Cases["Success" | "Duplicate"]>>;
    <
      A,
      B,
      C,
      D,
      Cases extends {
        Duplicate: (args: Duplicate<A extends Any ? A : never>) => any;
        Success: (args: Success) => any;
      },
    >(
      self: SaveResult<A extends Any ? A : never>,
      cases: Cases,
    ): Unify<ReturnType<Cases["Success" | "Duplicate"]>>;
  };
  Duplicate: <A>(args: {
    readonly lastReceivedReply: Option<Reply<A extends Any ? A : never>>;
    readonly originalId: Snowflake;
  }) => Duplicate<A extends Any ? A : never>;
  Success: <A>(args: void) => Success;
};

type SaveResult<R extends Rpc.Any> = SaveResult.Success | SaveResult.Duplicate<R>;

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