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">;
}