Persistence

declare class PersistenceBackingError extends any {
  constructor();
  message: any;
  static make(method: string, cause: unknown): PersistenceBackingError;
}

type PersistenceError = PersistenceParseError | PersistenceBackingError;

declare class PersistenceParseError extends any {
  constructor();
  message: any;
  static make(method: string, error: ParseError): PersistenceParseError;
}

declare const layerKeyValueStore: Layer.Layer<
  BackingPersistence,
  never,
  KeyValueStore.KeyValueStore
>;

declare const layerMemory: Layer.Layer<BackingPersistence>;

declare const layerResult: Layer<unknown, unknown, unknown>;

declare const layerResultKeyValueStore: Layer.Layer<
  ResultPersistence,
  never,
  KeyValueStore.KeyValueStore
>;

declare const layerResultMemory: Layer.Layer<ResultPersistence>;

interface BackingPersistence {
  readonly [BackingPersistenceTypeId]: typeof BackingPersistenceTypeId;
  readonly make: (storeId: string) => Effect<BackingPersistenceStore, never, Scope>;
}

interface BackingPersistenceStore {
  readonly clear: Effect<void, PersistenceError>;
  readonly get: (key: string) => Effect<Option<unknown>, PersistenceError>;
  readonly getMany: (key: Array<string>) => Effect<Array<Option<unknown>>, PersistenceError>;
  readonly remove: (key: string) => Effect<void, PersistenceError>;
  readonly set: (key: string, value: unknown, ttl: Option<Duration>) => Effect<void, PersistenceError>;
  readonly setMany: (entries: readonly Array<readonly [string, unknown, Option<Duration>]>) => Effect<void, PersistenceError>;
}

interface Persistable<A extends Schema.Schema.Any, E extends Schema.Schema.All>
  extends
    WithResult<A["Type"], A["Encoded"], E["Type"], E["Encoded"], A["Context"] | E["Context"]>,
    PrimaryKey {}

interface ResultPersistence {
  readonly [ResultPersistenceTypeId]: typeof ResultPersistenceTypeId;
  readonly make: (options: {
    readonly storeId: string;
    readonly timeToLive?: (key: KeyAny, exit: Exit<unknown, unknown>) => DurationInput;
  }) => Effect<ResultPersistenceStore, never, Scope>;
}

interface ResultPersistenceStore {
  readonly clear: Effect<void, PersistenceError>;
  readonly get: <R, IE, E, IA, A>(key: Key<R, IE, E, IA, A>) => Effect<Option<Exit<A, E>>, PersistenceError, R>;
  readonly getMany: <R, IE, E, IA, A>(key: readonly Array<Key<R, IE, E, IA, A>>) => Effect<Array<Option<Exit<A, E>>>, PersistenceError, R>;
  readonly remove: <R, IE, E, IA, A>(key: Key<R, IE, E, IA, A>) => Effect<void, PersistenceError>;
  readonly set: <R, IE, E, IA, A>(key: Key<R, IE, E, IA, A>, value: Exit<A, E>) => Effect<void, PersistenceError, R>;
  readonly setMany: <R, IE, E, IA, A>(entries: Iterable<readonly [Key<R, IE, E, IA, A>, Exit<A, E>]>) => Effect<void, PersistenceError, R>;
}

declare function unsafeTtlToExpires(clock: Clock, ttl: Option<Duration>): number | null;

declare const BackingPersistence: Tag<BackingPersistence, BackingPersistence>;

declare const ResultPersistence: Tag<ResultPersistence, ResultPersistence>;

declare const BackingPersistenceTypeId: unique symbol;

type BackingPersistenceTypeId = typeof BackingPersistenceTypeId;

declare const ErrorTypeId: unique symbol;

type ErrorTypeId = typeof ErrorTypeId;

declare const ResultPersistenceTypeId: unique symbol;

type ResultPersistenceTypeId = typeof ResultPersistenceTypeId;