declare class PersistenceBackingError

declare const make: (method: string, cause: unknown) => PersistenceBackingError

type PersistenceError = PersistenceParseError | PersistenceBackingError

declare class PersistenceParseError

declare const make: (method: string, error: ParseResult.ParseError["issue"]) => PersistenceParseError

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

declare const layerMemory: Layer.Layer<BackingPersistence>

declare const layerResult: any

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

declare const layerResultMemory: Layer.Layer<ResultPersistence>

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

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

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

export interface Key<R, IE, E, IA, A> extends Schema.WithResult<A, IA, E, IE, R>, PrimaryKey.PrimaryKey {}

type KeyAny = Key<any, any, any, any, any> | Key<any, never, never, any, any>

type TimeToLiveArgs<A> = A extends infer K
  ? K extends Key<infer _R, infer _IE, infer _E, infer _IA, infer _A>
    ? [request: K, exit: Exit.Exit<_A, _E>]
    : never
  : never

export interface ResultPersistenceStore {
  readonly get: <R, IE, E, IA, A>(
    key: ResultPersistence.Key<R, IE, E, IA, A>
  ) => Effect.Effect<Option.Option<Exit.Exit<A, E>>, PersistenceError, R>
  readonly getMany: <R, IE, E, IA, A>(
    key: ReadonlyArray<ResultPersistence.Key<R, IE, E, IA, A>>
  ) => Effect.Effect<Array<Option.Option<Exit.Exit<A, E>>>, PersistenceError, R>
  readonly set: <R, IE, E, IA, A>(
    key: ResultPersistence.Key<R, IE, E, IA, A>,
    value: Exit.Exit<A, E>
  ) => Effect.Effect<void, PersistenceError, R>
  readonly remove: <R, IE, E, IA, A>(
    key: ResultPersistence.Key<R, IE, E, IA, A>
  ) => Effect.Effect<void, PersistenceError>
  readonly clear: Effect.Effect<void, PersistenceError>
}

declare const BackingPersistence: Context.Tag<BackingPersistence, BackingPersistence>

declare const ResultPersistence: Context.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

declare const unsafeTtlToExpires: (clock: Clock.Clock, ttl: Option.Option<Duration.Duration>) => number | null