import { ReactNode, Ref, SVGProps } from "react"; declare const STATUS: { readonly IDLE: "idle"; readonly LOADING: "loading"; readonly LOADED: "loaded"; readonly FAILED: "failed"; readonly READY: "ready"; readonly UNSUPPORTED: "unsupported"; }; /** * 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, 'onLoad' | 'onError' | 'ref'> & { /** * A URL to prepend to url() references inside the SVG when using `uniquifyIDs`. * Only required if your page uses an HTML `` tag. */ baseURL?: string; /** * Reuse the converted React element for SVGs that produce identical markup, instead of * parsing and converting the content on every mount. * * Entries are keyed by the content and by every prop that shapes the output, so `title`, * `description`, `preProcessor` and `uniquifyIDs` keep working as they do without it. * With `uniquifyIDs`, only instances that have a `uniqueHash` when they mount are cached. * @default false */ cacheElements?: boolean; /** * 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 `` 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; /** * 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 `` 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; } 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>; } 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-DYD5tcmv.d.mts.map