import { ReactNode, Ref, SVGProps } from "react";

//#region src/config.d.ts
declare const STATUS: {
  readonly IDLE: "idle";
  readonly LOADING: "loading";
  readonly LOADED: "loaded";
  readonly FAILED: "failed";
  readonly READY: "ready";
  readonly UNSUPPORTED: "unsupported";
};
//#endregion
//#region src/types.d.ts
/**
 * Called when loading the SVG fails.
 */
type ErrorCallback = (error: Error | FetchError) => void;
/**
 * Called when the SVG loads successfully.
 */
type LoadCallback = (src: string, isCached: boolean) => void;
/**
 * Pre-processes the SVG string before parsing.
 * Must return a string.
 */
type PreProcessorCallback = (code: string) => string;
type Props = Simplify<Omit<SVGProps<SVGElement>, 'onLoad' | 'onError' | 'ref'> & {
  /**
   * A URL to prepend to url() references inside the SVG when using `uniquifyIDs`.
   * Only required if your page uses an HTML `<base>` tag.
   */
  baseURL?: string;
  /**
   * Cache remote SVGs in memory.
   *
   * When used with the CacheProvider, requests are also persisted in the browser cache.
   * @default true
   */
  cacheRequests?: boolean;
  /**
   * Fallback content rendered on fetch error or unsupported browser.
   */
  children?: ReactNode;
  /**
   * A description for the SVG.
   * Overrides an existing `<desc>` tag.
   */
  description?: string;
  /**
   * Custom options for the fetch request.
   */
  fetchOptions?: RequestInit;
  /**
   * A ref to the rendered SVG element.
   * Not available on initial render — use `onLoad` instead.
   */
  innerRef?: Ref<SVGElement | null>;
  /**
   * A component shown while the SVG is loading.
   */
  loader?: ReactNode;
  /**
   * Called when loading the SVG fails.
   * Receives an `Error` or `FetchError`.
   */
  onError?: ErrorCallback;
  /**
   * Called when the SVG loads successfully.
   * Receives the `src` and an `isCached` flag.
   */
  onLoad?: LoadCallback;
  /**
   * A function to pre-process the SVG string before parsing.
   * Must return a string.
   */
  preProcessor?: PreProcessorCallback;
  /**
   * The SVG to load.
   * Accepts a URL or path, a data URI (base64 or URL-encoded), or a raw SVG string.
   */
  src: string;
  /**
   * A title for the SVG. Overrides an existing `<title>` tag.
   * Pass `null` to remove it.
   */
  title?: string | null;
  /**
   * A string to use with `uniquifyIDs`.
   * @default random 8-character alphanumeric string
   */
  uniqueHash?: string;
  /**
   * Create unique IDs for each icon.
   * @default false
   */
  uniquifyIDs?: boolean;
}>;
type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
type Status = (typeof STATUS)[keyof typeof STATUS];
interface FetchError extends Error {
  code: string;
  errno: string;
  message: string;
  type: string;
}
interface State {
  content: string;
  element: ReactNode;
  isCached: boolean;
  status: Status;
}
interface StorageItem {
  content: string;
  error?: Error;
  status: Status;
}
//#endregion
//#region src/modules/cache.d.ts
interface CacheStoreOptions {
  name?: string;
  persistent?: boolean;
}
declare class CacheStore {
  private cacheApi;
  private readonly cacheStore;
  private readonly subscribers;
  isReady: boolean;
  constructor(options?: CacheStoreOptions);
  onReady(callback: () => void): () => void;
  private waitForReady;
  get(url: string, fetchOptions?: RequestInit): Promise<string>;
  getContent(url: string): string;
  set(url: string, data: StorageItem): void;
  isCached(url: string): boolean;
  private fetchAndCache;
  private fetchFromPersistentCache;
  private handleLoading;
  keys(): Array<string>;
  data(): Array<Record<string, StorageItem>>;
  delete(url: string): Promise<void>;
  clear(): Promise<void>;
}
//#endregion
export { PreProcessorCallback as a, State as c, LoadCallback as i, Status as l, ErrorCallback as n, Props as o, FetchError as r, Simplify as s, CacheStore as t, StorageItem as u };
//# sourceMappingURL=cache-DdM7QpJp.d.mts.map