export declare class PersistenceBackingError

static make(method: string, error: unknown)

export type PersistenceError = PersistenceParseError | PersistenceBackingError

export declare class PersistenceParseError

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

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: (storeId: string) => Effect.Effect<ResultPersistenceStore, never, Scope.Scope>
}

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

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

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