export = Cache;
declare class Cache {
  hooks: {
    /** @type {AsyncSeriesBailHook<[string, Etag | null, GotHandler[]], any>} */
    get: AsyncSeriesBailHook<[string, Etag | null, GotHandler[]], any>;
    /** @type {AsyncParallelHook<[string, Etag | null, any]>} */
    store: AsyncParallelHook<[string, Etag | null, any]>;
    /** @type {AsyncParallelHook<[Iterable<string>]>} */
    storeBuildDependencies: AsyncParallelHook<[Iterable<string>]>;
    /** @type {SyncHook<[]>} */
    beginIdle: SyncHook<[]>;
    /** @type {AsyncParallelHook<[]>} */
    endIdle: AsyncParallelHook<[]>;
    /** @type {AsyncParallelHook<[]>} */
    shutdown: AsyncParallelHook<[]>;
  };
  /**
   * @template T
   * @param {string} identifier the cache identifier
   * @param {Etag | null} etag the etag
   * @param {CallbackCache<T>} callback signals when the value is retrieved
   * @returns {void}
   */
  get<T>(
    identifier: string,
    etag: Etag | null,
    callback: CallbackCache<T>,
  ): void;
  /**
   * @template T
   * @param {string} identifier the cache identifier
   * @param {Etag | null} etag the etag
   * @param {T} data the value to store
   * @param {CallbackCache<void>} callback signals when the value is stored
   * @returns {void}
   */
  store<T_1>(
    identifier: string,
    etag: Etag | null,
    data: T_1,
    callback: CallbackCache<void>,
  ): void;
  /**
   * After this method has succeeded the cache can only be restored when build dependencies are
   * @param {Iterable<string>} dependencies list of all build dependencies
   * @param {CallbackCache<void>} callback signals when the dependencies are stored
   * @returns {void}
   */
  storeBuildDependencies(
    dependencies: Iterable<string>,
    callback: CallbackCache<void>,
  ): void;
  /**
   * @returns {void}
   */
  beginIdle(): void;
  /**
   * @param {CallbackCache<void>} callback signals when the call finishes
   * @returns {void}
   */
  endIdle(callback: CallbackCache<void>): void;
  /**
   * @param {CallbackCache<void>} callback signals when the call finishes
   * @returns {void}
   */
  shutdown(callback: CallbackCache<void>): void;
}
declare namespace Cache {
  export {
    STAGE_MEMORY,
    STAGE_DEFAULT,
    STAGE_DISK,
    STAGE_NETWORK,
    WebpackError,
    Etag,
    CallbackCache,
    GotHandler,
  };
}
import { AsyncSeriesBailHook } from 'tapable';
type Etag = {
  toString: () => string;
};
type GotHandler = (
  result: any,
  callback: (arg0: Error | undefined) => void,
) => void;
import { AsyncParallelHook } from 'tapable';
import { SyncHook } from 'tapable';
type CallbackCache<T> = (
  err?: (WebpackError | null) | undefined,
  result?: T | undefined,
) => void;
declare var STAGE_MEMORY: number;
declare var STAGE_DEFAULT: number;
declare var STAGE_DISK: number;
declare var STAGE_NETWORK: number;
type WebpackError = import('./WebpackError');