export declare const contains: {
  <Key, Error, Value>(self: Cache<Key, Error, Value>, key: Key): Effect.Effect<never, never, boolean>
  <Key>(key: Key): <Error, Value>(self: Cache<Key, Error, Value>) => Effect.Effect<never, never, boolean>
}

export declare const entryStats: {
  <Key, Error, Value>(self: Cache<Key, Error, Value>, key: Key): Effect.Effect<
    never,
    never,
    Option.Option<EntryStats.EntryStats>
  >
  <Key>(key: Key): <Error, Value>(
    self: Cache<Key, Error, Value>
  ) => Effect.Effect<never, never, Option.Option<EntryStats.EntryStats>>
}

export declare const get: {
  <Key, Error, Value>(self: Cache<Key, Error, Value>, key: Key): Effect.Effect<never, Error, Value>
  <Key>(key: Key): <Error, Value>(self: Cache<Key, Error, Value>) => Effect.Effect<never, Error, Value>
}

export declare const invalidate: {
  <Key, Error, Value>(self: Cache<Key, Error, Value>, key: Key): Effect.Effect<never, never, void>
  <Key>(key: Key): <Error, Value>(self: Cache<Key, Error, Value>) => Effect.Effect<never, never, void>
}

export declare const invalidateAll: <Key, Error, Value>(
  self: Cache<Key, Error, Value>
) => Effect.Effect<never, never, void>

export declare const refresh: {
  <Key, Error, Value>(self: Cache<Key, Error, Value>, key: Key): Effect.Effect<never, Error, void>
  <Key>(key: Key): <Error, Value>(self: Cache<Key, Error, Value>) => Effect.Effect<never, Error, void>
}

export declare const set: {
  <Key, Error, Value>(self: Cache<Key, Error, Value>, key: Key, value: Value): Effect.Effect<never, never, void>
  <Key>(key: Key): <Error, Value>(self: Cache<Key, Error, Value>, value: Value) => Effect.Effect<never, never, void>
}

export declare const make: <Key, Environment, Error, Value>(
  capacity: number,
  timeToLive: Duration.Duration,
  lookup: any
) => Effect.Effect<Environment, never, Cache<Key, Error, Value>>

export declare const makeWith: <Key, Environment, Error, Value>(
  capacity: number,
  lookup: any,
  timeToLive: (exit: Exit.Exit<Error, Value>) => Duration.Duration
) => Effect.Effect<Environment, never, Cache<Key, Error, Value>>

export declare const makeWithKey: <Input, Key, Environment, Error, Value>(
  capacity: number,
  lookup: any,
  timeToLive: (exit: Exit.Exit<Error, Value>) => Duration.Duration,
  keyBy: (input: Input) => Key
) => Effect.Effect<Environment, never, Cache<Input, Error, Value>>

export declare const cacheStats: <Key, Error, Value>(
  self: Cache<Key, Error, Value>
) => Effect.Effect<never, never, CacheStats.CacheStats>

export declare const size: <Key, Error, Value>(self: Cache<Key, Error, Value>) => Effect.Effect<never, never, number>

export declare const values: <Key, Error, Value>(
  self: Cache<Key, Error, Value>
) => Effect.Effect<never, never, Chunk.Chunk<Value>>

export interface Cache<Key, Error, Value> extends Cache.Variance<Key, Error, Value> {
  /**
   * Returns statistics for this cache.
   */
  cacheStats(): Effect.Effect<never, never, CacheStats.CacheStats>

  /**
   * Returns whether a value associated with the specified key exists in the
   * cache.
   */
  contains(key: Key): Effect.Effect<never, never, boolean>

  /**
   * Returns statistics for the specified entry.
   */
  entryStats(key: Key): Effect.Effect<never, never, Option.Option<EntryStats.EntryStats>>

  /**
   * Retrieves the value associated with the specified key if it exists.
   * Otherwise computes the value with the lookup function, puts it in the
   * cache, and returns it.
   */
  get(key: Key): Effect.Effect<never, Error, Value>

  /**
   * Invalidates the value associated with the specified key.
   */
  invalidate(key: Key): Effect.Effect<never, never, void>

  /**
   * Invalidates all values in the cache.
   */
  invalidateAll(): Effect.Effect<never, never, void>

  /**
   * Computes the value associated with the specified key, with the lookup
   * function, and puts it in the cache. The difference between this and
   * `get` method is that `refresh` triggers (re)computation of the value
   * without invalidating it in the cache, so any request to the associated
   * key can still be served while the value is being re-computed/retrieved
   * by the lookup function. Additionally, `refresh` always triggers the
   * lookup function, disregarding the last `Error`.
   */
  refresh(key: Key): Effect.Effect<never, Error, void>

  /**
   * Associates the specified value with the specified key in the cache.
   */
  set(key: Key, value: Value): Effect.Effect<never, never, void>

  /**
   * Returns the approximate number of values in the cache.
   */
  size(): Effect.Effect<never, never, number>

  /**
   * Returns an approximation of the values in the cache.
   */
  values(): Effect.Effect<never, never, Chunk.Chunk<Value>>
}

export declare const CacheTypeId: typeof CacheTypeId

export type CacheTypeId = typeof CacheTypeId