import { RateLimitOptions, ReactPromise } from "./promises.js";

//#region src/utils/caches.d.ts
/**
 * Can be used to cache the result of a function call, for example for the `use` hook in React.
 */
declare function cacheFunction<F extends Function>(f: F): F;
type CacheStrategy = "write-only" | "read-write" | "never";
declare class AsyncCache<D extends any[], T> {
  private readonly _fetcher;
  private readonly _options;
  private readonly _map;
  constructor(_fetcher: (dependencies: D) => Promise<T>, _options?: {
    onSubscribe?: (key: D, refresh: () => void) => (() => void);
    rateLimiter?: Omit<RateLimitOptions, "batchCalls">;
  });
  private _createKeyed;
  getValueCache(dependencies: D): AsyncValueCache<T>;
  refreshWhere(predicate: (dependencies: D) => boolean): Promise<void>;
  invalidateWhere(predicate: (dependencies: D) => boolean): Promise<void>;
  readonly isCacheAvailable: (key: D) => boolean;
  readonly getIfCached: (key: D) => ({
    status: "error";
    error: unknown;
  } & {
    status: "error";
  }) | ({
    status: "pending";
  } & {
    progress: void;
  } & {
    status: "pending";
  }) | ({
    status: "ok";
    data: T;
  } & {
    status: "ok";
  });
  readonly getOrWait: (key: D, cacheStrategy: CacheStrategy) => ReactPromise<T>;
  readonly forceSetCachedValue: (key: D, value: T) => void;
  readonly forceSetCachedValueAsync: (key: D, value: Promise<T>) => ReactPromise<void>;
  readonly refresh: (key: D) => Promise<void>;
  readonly invalidate: (key: D) => Promise<void>;
  readonly onStateChange: (key: D, callback: (value: T, oldValue: T | undefined) => void) => {
    unsubscribe: () => void;
  };
  readonly isDirty: (key: D) => boolean;
}
declare class AsyncValueCache<T> {
  private readonly _options;
  private _store;
  private _pendingPromise;
  private _fetcher;
  private readonly _rateLimitOptions;
  private _subscriptionsCount;
  private _unsubscribers;
  private _mostRecentRefreshPromiseIndex;
  constructor(fetcher: () => Promise<T>, _options?: {
    onSubscribe?: (refresh: () => void) => (() => void);
    rateLimiter?: Omit<RateLimitOptions, "batchCalls">;
  });
  isCacheAvailable(): boolean;
  getIfCached(): ({
    status: "error";
    error: unknown;
  } & {
    status: "error";
  }) | ({
    status: "pending";
  } & {
    progress: void;
  } & {
    status: "pending";
  }) | ({
    status: "ok";
    data: T;
  } & {
    status: "ok";
  });
  getOrWait(cacheStrategy: CacheStrategy): ReactPromise<T>;
  private _set;
  private _setAsync;
  private _refetch;
  forceSetCachedValue(value: T): void;
  forceSetCachedValueAsync(value: Promise<T>): ReactPromise<void>;
  /**
   * If anyone is listening to the cache, refreshes the value, and sets it without invalidating the cache.
   */
  refresh(): Promise<void>;
  /**
   * Invalidates the cache, marking it dirty (ie. it will be refreshed on the next read). If anyone is listening to the cache, it will refresh immediately.
   */
  invalidate(): Promise<void>;
  isDirty(): boolean;
  _invalidateCacheSoon(): void;
  onStateChange(callback: (value: T, oldValue: T | undefined) => void): {
    unsubscribe: () => void;
  };
}
//#endregion
export { AsyncCache, cacheFunction };
//# sourceMappingURL=caches.d.ts.map