export declare class PersistenceBackingError

static make(method: string, cause: unknown)

export type PersistenceError = PersistenceParseError | PersistenceBackingError

export declare class PersistenceParseError

static make(method: string, error: ParseResult.ParseError["issue"])

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

export declare const layerMemory: Layer.Layer<BackingPersistence>

export declare const layerResult: any

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

export 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 {}

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

export 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>
}

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

export declare const ResultPersistence: Context.Tag<ResultPersistence, ResultPersistence>

export declare const BackingPersistenceTypeId: typeof BackingPersistenceTypeId

export type BackingPersistenceTypeId = typeof BackingPersistenceTypeId

export declare const ErrorTypeId: typeof ErrorTypeId

export type ErrorTypeId = typeof ErrorTypeId

export declare const ResultPersistenceTypeId: typeof ResultPersistenceTypeId

export type ResultPersistenceTypeId = typeof ResultPersistenceTypeId

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