import { ArchiveContentOptions, ArchiveContentResponse, ArchiveDiffFormat, ArchiveDiffOptions, ArchiveInterface, ArchiveMetadata, ArchiveOptions, ArchiveProvider, ArchiveResponse, ArchiveTodayMetadata, ArchivedContent, ArchivedContentDiff, ArchivedContentSummary, ArchivedPage, ArchivedPageMetadata, ArquivoMetadata, CommonCrawlMetadata, MementoMetadata, PermaccMetadata, ProviderReference, ResponseMetadata, UnsupportedProviderRecord, WaybackMetadata, WebCiteMetadata, WebarchivMetadata } from "./_chunks/types.mjs";
import { Driver, Storage } from "unstorage";
interface WaybackOptions extends ArchiveOptions {
  collapse?: string;
  filter?: string;
}
type ArquivoOptions = ArchiveOptions;
type WebarchivOptions = ArchiveOptions;
interface ArchiveItOptions extends ArchiveOptions {
  collection: number | string;
  collapse?: string;
  filter?: string;
}
interface ConiferOptions extends ArchiveOptions {
  user: string;
  collection: string;
}
type ArchiveTodayOptions = ArchiveOptions;
interface MementoOptions extends ArchiveOptions {
  /** Base URL of a Memento aggregator compatible with MemGator. */
  baseUrl?: string;
}
interface PermaccOptions extends ArchiveOptions {
  apiKey: string;
}
interface CommonCrawlOptions extends ArchiveOptions {
  collection?: string;
}
type WebCiteOptions = ArchiveOptions;
/**
 * Thrown by `archive.getPages()` when the only-or-all-queried providers do not
 * implement the requested operation. Lets callers distinguish a structural
 * "this provider has no such API" from a runtime fetch failure.
 */
declare class UnsupportedOperationError extends Error {
  readonly providers: UnsupportedProviderRecord[];
  constructor(reason: string, providers?: readonly Readonly<UnsupportedProviderRecord>[]);
}
type ProviderInput = ProviderReference | readonly ArchiveProvider[] | Promise<readonly ArchiveProvider[]>;
/**
 * Combine per-provider responses into a single merged ArchiveResponse.
 *
 * Merges pages, deduplicates matching URLs and timestamps across provider
 * responses, collapses repeated captures within each response, joins errors,
 * and propagates unsupported operations into `_meta`.
 * The combined response is marked `unsupported` only when *every* queried
 * provider was structurally unsupported.
 *
 * @param responses - Array of per-provider responses (possibly mixed success/failure).
 * @param limit - Optional cap on the number of pages in the merged result.
 *
 * @returns {ArchiveResponse} The operation result.
 */
declare function combineResults(responses: readonly ArchiveResponse[], limit?: number): ArchiveResponse;
/**
 * Combine per-provider content responses into a single response.
 *
 * A content query wants one body, not a merged set, so the first provider that
 * returns one wins and the others are reported beside it: which archive answered
 * decides how much the bytes can be trusted, and a caller that reads only the
 * body would never learn that its preferred archive was the one that failed.
 *
 * @param responses - Per-provider responses, in the order they were tried
 *
 * @returns {ArchiveContentResponse} The operation result.
 */
declare function combineContentResults(responses: readonly ArchiveContentResponse[]): ArchiveContentResponse;
/**
 * Unified archive client aggregating one or more `ArchiveProvider`s.
 *
 * Use `createArchive()` for the functional entry point; the class exists so
 * consumers preferring OOP can instantiate it directly and subclass it.
 */
declare class Archive implements ArchiveInterface {
  /**
   * Default options applied to every query unless overridden per-request.
   * Readonly from the outside – mutate by creating a new `Archive` instead.
   */
  readonly options?: ArchiveOptions;
  private readonly providersInput;
  private providerResolution;
  constructor(providers: ProviderInput, options?: Readonly<ArchiveOptions>);
  /**
   * Force-resolve providers immediately. Normally resolution is deferred
   * until the first query so `createArchive(providers.all())` stays cheap
   * even when never called. Public for consumers that want eager init.
   *
   * @returns {Promise<ArchiveProvider[]>} A promise resolving to the operation result.
   */
  resolveProviders(): Promise<ArchiveProvider[]>;
  private resolveProviderList;
  /**
   * Fetch from a single provider, honoring cache and error-normalization.
   *
   * @param provider - Provider.
   * @param domain - Domain.
   * @param requestOptions - Request Options.
   * @returns {Promise<ArchiveResponse>} A promise resolving to the operation result.
   */
  private fetchFromProvider;
  /**
   * Fetch archived snapshots for a domain.
   * Returns a full response object with pages, metadata, and cache status.
   *
   * A `from`/`to` window is validated once here, normalized to digits, and
   * completed per provider, because init-level bounds count too and a provider
   * without a window-aware index cannot apply them itself. A windowed fetch
   * runs with the provider limits lifted; every cap returns after the filter,
   * the caller's after the newest-first merge, since a cap taken earlier turns
   * a tight limit into a false "nothing captured in this window". An inverted
   * window throws before the fan-out, where the parallel runner would swallow
   * the error.
   *
   * @param domain - The domain to search for in archive services (e.g., "example.com")
   * @param listOptions - Request-specific options that override the default options
   * @returns {Promise<ArchiveResponse>} Promise resolving to ArchiveResponse with pages, metadata and status
   *
   * @example
   * ```js
   * // Basic usage
   * const response = await archive.snapshots('example.com')
   *
   * // With request-specific options
   * const response = await archive.snapshots('example.com', {
   *   limit: 5,
   *   cache: false // Skip cache for this request
   * })
   *
   * // Only the captures from the first half of 2019
   * const response = await archive.snapshots('example.com', {
   *   from: '2019',
   *   to: '2019-06'
   * })
   * ```
   */
  snapshots(domain: string, listOptions?: Readonly<ArchiveOptions>): Promise<ArchiveResponse>;
  /**
   * Fetch archived pages for a domain, returning only the pages array.
   * Throws an error if the request fails (unlike snapshots which returns a success flag).
   *
   * @param domain - The domain to search for in archive services
   * @param listOptions - Request-specific options that override the defaults
   * @returns {Promise<ArchivedPage[]>} Promise resolving to array of ArchivedPage objects
   * @throws {Error} Error if the request fails
   *
   * @example
   * ```js
   * try {
   *   // Get pages directly
   *   const pages = await archive.getPages('example.com', { limit: 10 })
   *
   *   // Work with pages array
   *   pages.forEach(page => console.log(page.snapshot))
   * } catch (error) {
   *   console.error('Failed to fetch pages:', error.message)
   * }
   * ```
   */
  getPages(domain: string, listOptions?: Readonly<ArchiveOptions>): Promise<ArchivedPage[]>;
  /**
   * Read one archived capture's body from a single provider, honoring the cache.
   *
   * @param provider - Provider.
   * @param url - Url.
   * @param requestOptions - Request Options.
   * @returns {Promise<ArchiveContentResponse>} A promise resolving to the operation result.
   */
  private readContentFromProvider;
  /**
   * Read the body of one archived capture.
   *
   * Providers are tried in order and the first body wins, because there is one
   * page to read rather than a set to merge. Passing a playback URL works as
   * well as passing the original: the capture it names is unwrapped out of it.
   *
   * @param url - Original URL, or a playback URL printed by `snapshots()`
   * @param contentOptions - Request options; `timestamp` selects the capture
   * @returns {Promise<ArchiveContentResponse>} Promise resolving to the capture, or to the reasons nobody had it
   *
   * @example
   * ```js
   * // Newest capture
   * const response = await archive.content('example.com')
   *
   * // The page as it stood in March 2019
   * const response = await archive.content('https://example.com/page', {
   *   timestamp: '2019-03-01'
   * })
   * ```
   */
  content(url: string, contentOptions?: Readonly<ArchiveContentOptions>): Promise<ArchiveContentResponse>;
  /**
   * Read one archived capture, returning the capture itself.
   * Throws when no provider could produce it (unlike `content`, which reports).
   *
   * @param url - Original URL, or a playback URL printed by `snapshots()`
   * @param contentOptions - Request options; `timestamp` selects the capture
   * @returns {Promise<ArchivedContent>} Promise resolving to the archived capture
   * @throws {Error} `UnsupportedOperationError` when every queried provider lacks the
   * operation, and a generic `Error` when the read failed for any other reason
   */
  getContent(url: string, contentOptions?: Readonly<ArchiveContentOptions>): Promise<ArchivedContent>;
  /**
   * Add a new provider to this archive instance.
   * Allows for dynamically extending the archive with additional providers.
   *
   * @param provider - The provider or Promise resolving to a provider to add
   * @returns {Promise<ArchiveInterface>} The archive instance for method chaining
   *
   * @example
   * ```js
   * // Create archive with one provider
   * const archive = createArchive(providers.wayback())
   *
   * // Add another provider later
   * await archive.use(providers.archiveToday())
   *
   * // Await each addition
   * await archive.use(providers.webcite())
   * await archive.use(providers.commoncrawl())
   * ```
   */
  use(provider: ProviderReference): Promise<ArchiveInterface>;
  /**
   * Add multiple providers to this archive instance at once.
   * More efficient than calling use() multiple times.
   *
   * @param newProviders - Array of providers or Promises resolving to providers
   * @returns {Promise<ArchiveInterface>} The archive instance for method chaining
   *
   * @example
   * ```js
   * // Create archive with one provider
   * const archive = createArchive(providers.wayback())
   *
   * // Add multiple providers at once
   * await archive.useAll([
   *   providers.archiveToday(),
   *   providers.webcite(),
   *   providers.commoncrawl()
   * ])
   * ```
   */
  useAll(newProviders: readonly ProviderReference[]): Promise<ArchiveInterface>;
}
/**
 * Create a unified archive client that wraps one or multiple providers.
 * Supports lazy loading and asynchronous provider initialization.
 *
 * Backwards-compatible functional factory; prefer `new Archive(providers, options)`.
 *
 * @param providers - Single provider, array of providers, or Promise(s) resolving to provider(s)
 * @param options - Default options applied to all queries (limit, cache, ttl, concurrency, etc.)
 * @returns {ArchiveInterface} Archive client with methods for fetching and managing archive data
 *
 * @example
 * ```js
 * // Single provider
 * const waybackArchive = createArchive(providers.wayback())
 *
 * // Multiple providers
 * const multiArchive = createArchive([
 *   providers.wayback(),
 *   providers.archiveToday()
 * ])
 *
 * // With options
 * const archive = createArchive(providers.all(), {
 *   limit: 10,
 *   cache: true,
 *   ttl: 3600000, // 1 hour cache TTL
 *   concurrency: 3
 * })
 * ```
 */
declare function createArchive(providers: ProviderInput, options?: Readonly<ArchiveOptions>): ArchiveInterface;
type ArchivedContentView = Readonly<Omit<ArchivedContent, "_meta">> & {
  readonly _meta: Readonly<ArchivedContent["_meta"]>;
};
/**
 * Produces a bounded unified line diff from two captures of the same original URL.
 *
 * The comparison rejects mixed providers and nonchronological captures because a
 * plausible patch with broken provenance is worse evidence than no patch. The
 * default text mode removes markup, scripts and styles; raw mode retains decoded
 * source for route, comment and bundle archaeology.
 *
 * @param before - Earlier archived capture.
 * @param after - Later archived capture.
 * @param options - Rendering, context and complexity bounds.
 * @returns {ArchivedContentDiff} Patch, change counts and identities of both captures.
 * @throws {Error} When provenance, chronology, options or complexity bounds fail.
 */
declare function diffArchivedContent(before: ArchivedContentView, after: ArchivedContentView, options?: Readonly<ArchiveDiffOptions>): ArchivedContentDiff;
/**
 * Abstract base class for archive providers.
 * Holds the instance's initial options; concrete providers override
 * `snapshots()` and call `this.resolveOptions(reqOptions)` to get the
 * effective options for a request.
 *
 * `content()` is optional: a provider that cannot serve archived bodies leaves
 * it out, or overrides it with an unsupported response naming the gap.
 *
 * @template TOptions - Provider-specific options extending the shared archive options.
 */
declare abstract class BaseProvider<TOptions extends ArchiveOptions = ArchiveOptions> implements ArchiveProvider {
  abstract readonly name: string;
  abstract readonly slug?: string;
  cacheKey(_options?: Readonly<ArchiveOptions>): string | undefined;
  readonly options: Partial<TOptions>;
  constructor(options?: Partial<TOptions>);
  protected resolveOptions(reqOptions?: Partial<TOptions>): Promise<TOptions>;
  /**
   * Same cascade as {@link resolveOptions}, keeping the content-only options typed.
   *
   * @param reqOptions - Req Options.
   * @returns {Promise<TOptions & ArchiveContentOptions>} A promise resolving to the operation result.
   */
  protected resolveContentOptions(reqOptions?: Readonly<Partial<TOptions & ArchiveContentOptions>>): Promise<TOptions & ArchiveContentOptions>;
  abstract snapshots(domain: string, options?: Readonly<ArchiveOptions>): Promise<ArchiveResponse>;
  content?(url: string, options?: Readonly<ArchiveContentOptions>): Promise<ArchiveContentResponse>;
}
/**
 * Wayback Machine archive provider.
 */
declare class WaybackProvider extends BaseProvider<WaybackOptions> {
  readonly name = "Internet Archive Wayback Machine";
  readonly slug = "wayback";
  /**
   * Cache key extension for options that change the CDX result set.
   *
   * @param options - Options.
   * @returns {string} The resulting string.
   */
  cacheKey(options?: Readonly<ArchiveOptions>): string;
  /**
   * Fetch archived snapshots from the Internet Archive Wayback Machine.
   *
   * The window bounds are normalized here too, not only in `Archive.snapshots`:
   * the provider is a public export, and CDX does not read a raw ISO date as an
   * instant.
   *
   * @param domain - Domain.
   * @param reqOptions - Req Options.
   * @returns {Promise<ArchiveResponse>} A promise resolving to the operation result.
   */
  snapshots(domain: string, reqOptions?: Readonly<WaybackOptions>): Promise<ArchiveResponse>;
  /**
   * Read the body of one archived capture from the Wayback Machine.
   *
   * Two steps, because the archive answers them at different endpoints: CDX says
   * which capture exists at the requested instant, and the playback endpoint
   * replays that capture's original bytes.
   *
   * @param url - Url.
   * @param reqOptions - Req Options.
   * @returns {Promise<ArchiveContentResponse>} A promise resolving to the operation result.
   */
  content(url: string, reqOptions?: Readonly<Partial<WaybackOptions> & ArchiveContentOptions>): Promise<ArchiveContentResponse>;
  /**
   * Lists the captures worth considering for one URL.
   *
   * `limit=-5` asks CDX for the newest few rather than the oldest, which is what
   * an unqualified request means; the second query runs only when the archive
   * holds nothing at or before the requested instant, and finds the closest
   * capture after it.
   *
   * @param target - Target.
   * @param wanted - Wanted.
   * @param options - Options.
   * @returns {Promise<CdxCapture[]>} A promise resolving to the operation result.
   */
  private findCaptures;
  private queryCaptures;
}
/** Arquivo.pt web archive provider. */
declare class ArquivoProvider extends BaseProvider<ArquivoOptions> {
  readonly name = "Arquivo.pt";
  readonly slug = "arquivo";
  cacheKey(options?: Readonly<ArchiveOptions>): string;
  snapshots(domain: string, reqOptions?: Readonly<ArquivoOptions>): Promise<ArchiveResponse>;
  content(url: string, reqOptions?: Readonly<ArquivoOptions & ArchiveContentOptions>): Promise<ArchiveContentResponse>;
  private findCaptures;
}
declare class WebarchivProvider extends BaseProvider<WebarchivOptions> {
  readonly name = "Webarchiv Österreich";
  readonly slug = "webarchiv";
  cacheKey(options?: Readonly<ArchiveOptions>): string;
  snapshots(url: string, reqOptions?: Readonly<WebarchivOptions>): Promise<ArchiveResponse>;
  content(url: string, reqOptions?: Readonly<WebarchivOptions & ArchiveContentOptions>): Promise<ArchiveContentResponse>;
  private findCaptures;
}
/**
 * Archive-It collection archive provider.
 */
declare class ArchiveItProvider extends BaseProvider<ArchiveItOptions> {
  readonly name = "Archive-It";
  readonly slug = "archive-it";
  constructor(options: Readonly<ArchiveItOptions>);
  /**
   * Cache key extension for the collection and filters that change the CDX result set.
   *
   * @param options - Options.
   * @returns {string} The resulting string.
   */
  cacheKey(options?: Readonly<ArchiveOptions>): string;
  /**
   * Fetch archived snapshots from one Archive-It collection.
   *
   * The window bounds are normalized here too, not only in `Archive.snapshots`:
   * the provider is a public export, and the CDX index does not read a raw ISO
   * date as an instant.
   *
   * @param domain - Domain.
   * @param reqOptions - Req Options.
   * @returns {Promise<ArchiveResponse>} A promise resolving to the operation result.
   */
  snapshots(domain: string, reqOptions?: Readonly<Partial<ArchiveItOptions>>): Promise<ArchiveResponse>;
  /**
   * Read the body of one archived capture from the configured collection.
   *
   * Archive-It replays captures through the same Wayback machinery as the
   * Internet Archive, so the `id_` modifier returns the original response here
   * too. Only the host and the collection segment differ.
   *
   * @param url - Url.
   * @param reqOptions - Req Options.
   * @returns {Promise<ArchiveContentResponse>} A promise resolving to the operation result.
   */
  content(url: string, reqOptions?: Readonly<Partial<ArchiveItOptions> & ArchiveContentOptions>): Promise<ArchiveContentResponse>;
  private findCaptures;
}
/**
 * Read-only access to pages in an existing public Conifer collection.
 */
declare class ConiferProvider extends BaseProvider<ConiferOptions> {
  readonly name = "Conifer";
  readonly slug = "conifer";
  constructor(options: Readonly<ConiferOptions>);
  cacheKey(options?: Readonly<ArchiveOptions>): string;
  snapshots(domain: string, reqOptions?: Readonly<Partial<ConiferOptions>>): Promise<ArchiveResponse>;
}
/**
 * Archive.today archive provider. Uses the Memento timemap endpoint.
 */
declare class ArchiveTodayProvider extends BaseProvider<ArchiveTodayOptions> {
  readonly name = "Archive.today";
  readonly slug = "archive-today";
  /**
   * Fetch archived snapshots from Archive.today.
   *
   * @param domain - Domain.
   * @param reqOptions - Req Options.
   * @returns {Promise<ArchiveResponse>} A promise resolving to the operation result.
   */
  snapshots(domain: string, reqOptions?: Readonly<ArchiveTodayOptions>): Promise<ArchiveResponse>;
  /**
   * Read the body of one archived capture from Archive.today.
   *
   * There is no raw-playback endpoint here: a snapshot URL serves the page as
   * Archive.today rendered it, so the body is that wrapper HTML rather than the
   * bytes the original site sent. The capture is chosen locally from the
   * timemap, the same way the other providers choose from their index.
   *
   * A capture answers with a `Memento-Datetime` header and the rate-limit and
   * CAPTCHA pages do not, so a body without one is refused as an error instead
   * of being cached for days as the page's content.
   *
   * Any `#fragment` is dropped from the URL up front: a fragment never travels
   * to the server, so the timemap answers for the bare URL, and a fragment kept
   * on this side would make every returned capture fail the match and read as
   * never archived. The same fragment-free form feeds the same-url narrowing,
   * which still wants the caller's scheme, so it is not the timemap target.
   *
   * @param url - Url.
   * @param reqOptions - Req Options.
   * @returns {Promise<ArchiveContentResponse>} A promise resolving to the operation result.
   */
  content(url: string, reqOptions?: Readonly<Partial<ArchiveTodayOptions> & ArchiveContentOptions>): Promise<ArchiveContentResponse>;
  /**
   * Fetch and parse the Memento timemap for one domain or URL.
   *
   * A memento's `datetime` is not always something `Date` can read, but the
   * snapshot URL names the same instant, so its stamp is the fallback. Stamping
   * "now" instead would push the row above every real capture once a merged
   * response sorts newest-first; a row with no readable time at all is dropped.
   *
   * The timemap labels its newest row `last memento` and a lone capture
   * `first last memento`, so the match takes any first/last qualifiers;
   * requiring a bare `memento` would drop the newest capture from every
   * listing. Fully qualified URLs stay exactly as the timemap recorded them:
   * scheme, duplicate path separators, and a trailing slash can all distinguish
   * one archived resource from another.
   *
   * @param target - Target.
   * @param options - Options.
   * @returns {Promise<ArchivedPage[]>} A promise resolving to the operation result.
   */
  private fetchMementos;
}
/** Memento JSON TimeMaps through ODU MemGator, replacing the discontinued Time Travel aggregator. */
declare class MementoProvider extends BaseProvider<MementoOptions> {
  readonly name = "Memento (MemGator)";
  readonly slug = "memento";
  /**
   * Separates aggregators and caps while redacting invalid URLs before cache lookup.
   *
   * @param options - Options.
   * @returns {string} The resulting string.
   */
  cacheKey(options?: Readonly<MementoOptions>): string;
  /**
   * Fetches the aggregated JSON TimeMap for one exact original URL.
   *
   * @param domain - Domain.
   * @param reqOptions - Req Options.
   * @returns {Promise<ArchiveResponse>} A promise resolving to the operation result.
   */
  snapshots(domain: string, reqOptions?: Readonly<MementoOptions>): Promise<ArchiveResponse>;
  /**
   * Reads the selected Memento URI directly, with negotiation through MemGator only as fallback.
   *
   * @param url - Url.
   * @param reqOptions - Req Options.
   * @returns {Promise<ArchiveContentResponse>} A promise resolving to the operation result.
   */
  content(url: string, reqOptions?: Readonly<Partial<MementoOptions> & ArchiveContentOptions>): Promise<ArchiveContentResponse>;
  private readCapture;
  private fetchTimeMap;
  private parseTimeMap;
  /**
   * Requests raw replay used by PyWB without the archive toolbar or rewritten links.
   *
   * @param value - Value.
   * @returns {URL} The operation result.
   */
  private rawSnapshotURL;
  private originalURL;
  private baseURL;
}
/**
 * Perma.cc requires an API key and returns only archives accessible to that
 * account. Lookups match one exact submitted URL; bare domains are normalized
 * to their HTTPS root URL. When neither init-time nor request-time `apiKey` is
 * provided, `snapshots()` returns an error response.
 */
declare class PermaccProvider extends BaseProvider<PermaccOptions> {
  readonly name = "Perma.cc";
  readonly slug = "permacc";
  /**
   * Partition responses by account and effective limit without storing the raw API key.
   *
   * @param options - Options.
   * @returns {string | undefined} The operation result.
   */
  cacheKey(options?: Readonly<ArchiveOptions>): string | undefined;
  /**
   * Fetch archives matching one exact URL from the authenticated Perma.cc account.
   *
   * @param domain - Domain.
   * @param reqOptions - Req Options.
   * @returns {Promise<ArchiveResponse>} A promise resolving to the operation result.
   */
  snapshots(domain: string, reqOptions?: Readonly<Partial<PermaccOptions>>): Promise<ArchiveResponse>;
  content(_url: string, _options?: Readonly<ArchiveContentOptions>): Promise<ArchiveContentResponse>;
}
/**
 * Common Crawl archive provider.
 */
declare class CommonCrawlProvider extends BaseProvider<CommonCrawlOptions> {
  readonly name = "Common Crawl";
  readonly slug = "commoncrawl";
  /**
   * Cache key extension that separates storage entries by collection.
   *
   * @param options - Options.
   * @returns {string | undefined} The operation result.
   */
  cacheKey(options?: Readonly<ArchiveOptions>): string | undefined;
  /**
   * Fetch archived snapshots from Common Crawl.
   *
   * @param domain - Domain.
   * @param reqOptions - Req Options.
   * @returns {Promise<ArchiveResponse>} A promise resolving to the operation result.
   */
  snapshots(domain: string, reqOptions?: Readonly<Partial<CommonCrawlOptions>>): Promise<ArchiveResponse>;
  /**
   * Read the body of one archived capture from Common Crawl.
   *
   * Common Crawl has no playback host: the index gives the WARC file plus the
   * byte range of the record inside it, so the body is a range request against
   * that file, gzip-decoded, with the WARC and HTTP header blocks stripped off.
   *
   * @param url - Url.
   * @param reqOptions - Req Options.
   * @returns {Promise<ArchiveContentResponse>} A promise resolving to the operation result.
   */
  content(url: string, reqOptions?: Readonly<Partial<CommonCrawlOptions> & ArchiveContentOptions>): Promise<ArchiveContentResponse>;
  /**
   * Resolves which crawl to query: the configured collection, or the newest one
   * `collinfo.json` advertises.
   *
   * The endpoint names differ from the collection ids by an `-index` suffix, and
   * the two are reported separately because the collection id is what a caller
   * sees in the response while the endpoint name is what the query needs.
   *
   * @param options - Options.
   * @returns {Promise<{ collectionName: string; indexName: string }>} A promise resolving to the operation result.
   */
  private resolveIndex;
  private fetchLatestIndex;
  /**
   * Lists the indexed captures of one exact URL, with their WARC coordinates.
   * The row cap leaves enough captures to sort frequently crawled URLs before selection.
   *
   * @param indexName - Index Name.
   * @param target - Target.
   * @param wanted - Wanted.
   * @param options - Options.
   * @returns {Promise<CrawlCapture[]>} A promise resolving to the operation result.
   */
  private findCaptures;
  /**
     * Fetches one WARC record by byte range and unwraps the HTTP response inside it.
     *
     * @param capture - Capture.
     * @param options - Options.
     * @param maxBytes - Max Bytes.
     * @returns {Promise<{
      text: string;
      bytes: number;
      truncated: boolean;
      status?: number;
      mime?: string;
    }>} A promise resolving to the operation result.
     */
  private readRecord;
}
/**
 * WebCite archive provider.
 *
 * WebCite does not expose a list-by-domain endpoint, so `snapshots(domain)`
 * always returns an unsupported response. Existing snapshots are still
 * retrievable via direct webcitation.org/<id> URLs once a `getById` API is
 * added at the aggregator level.
 */
declare class WebCiteProvider extends BaseProvider<WebCiteOptions> {
  readonly name = "WebCite";
  readonly slug = "webcite";
  snapshots(_domain: string, _options?: Readonly<WebCiteOptions>): Promise<ArchiveResponse>;
  content(_url: string, _options?: Readonly<ArchiveContentOptions>): Promise<ArchiveContentResponse>;
}
/**
 * Provider factory with lazy-loading for optimized tree-shaking.
 * Only loads the providers that are actually used.
 */
declare const providers: {
  /**
   * Creates a Wayback Machine provider.
   * @param options - Configuration options for the Wayback Machine provider
   * @returns {Promise<ArchiveProvider>} The Wayback Machine provider
   * @example
   * ```js
   * const waybackProvider = providers.wayback({ limit: 100 })
   * ```
   */
  wayback(options?: Readonly<WaybackOptions>): Promise<ArchiveProvider>;
  /**
   * Creates an Arquivo.pt provider.
   * @param options - Configuration options for the Arquivo.pt provider
   * @returns {Promise<ArchiveProvider>} The Arquivo.pt provider
   */
  arquivo(options?: Readonly<ArquivoOptions>): Promise<ArchiveProvider>;
  /**
   * Creates a Webarchiv Österreich provider.
   * @param options - Configuration options for Webarchiv Österreich
   * @returns {Promise<ArchiveProvider>} The Webarchiv Österreich provider
   */
  webarchiv(options?: Readonly<WebarchivOptions>): Promise<ArchiveProvider>;
  /**
   * Creates an Archive-It provider for one collection.
   * @param options - Configuration including the required Archive-It collection ID
   * @returns {Promise<ArchiveProvider>} The Archive-It provider
   * @example
   * ```js
   * const archiveItProvider = providers.archiveIt({ collection: 4399 })
   * ```
   */
  archiveIt(options: Readonly<ArchiveItOptions>): Promise<ArchiveProvider>;
  /**
   * Creates a Conifer provider for one existing public collection.
   * @param options - Configuration including the required user and collection slugs
   * @returns {Promise<ArchiveProvider>} The Conifer provider
   * @example
   * ```js
   * const coniferProvider = providers.conifer({ user: 'imamuseum', collection: 'imamuseumorg' })
   * ```
   */
  conifer(options: Readonly<ConiferOptions>): Promise<ArchiveProvider>;
  /**
   * Creates an Archive.today provider.
   * @param options - Configuration options for the Archive.today provider
   * @returns {Promise<ArchiveProvider>} The Archive.today provider
   * @example
   * ```js
   * const archiveTodayProvider = providers.archiveToday({ timeout: 15000 })
   * ```
   */
  archiveToday(options?: Readonly<ArchiveTodayOptions>): Promise<ArchiveProvider>;
  /**
   * Creates a lazily loaded Memento provider that uses MemGator.
   *
   * @param options - Options.
   * @returns {Promise<ArchiveProvider>} A promise resolving to the operation result.
   */
  memento(options?: Readonly<MementoOptions>): Promise<ArchiveProvider>;
  /**
   * Creates a Perma.cc provider.
   * @param options - Configuration options for the Perma.cc provider (requires apiKey)
   * @returns {Promise<ArchiveProvider>} The Perma.cc provider
   * @example
   * ```js
   * const permaccProvider = providers.permacc({ apiKey: 'your-api-key' })
   * ```
   */
  permacc(options?: Readonly<Partial<PermaccOptions>>): Promise<ArchiveProvider>;
  /**
   * Creates a Common Crawl provider.
   * @param options - Configuration options for the Common Crawl provider
   * @returns {Promise<ArchiveProvider>} The Common Crawl provider
   * @example
   * ```js
   * const commoncrawlProvider = providers.commoncrawl({ collection: 'CC-MAIN-2023-50' })
   * ```
   */
  commoncrawl(options?: Readonly<CommonCrawlOptions>): Promise<ArchiveProvider>;
  /**
   * Creates a WebCite provider.
   * @param options - Configuration options for the WebCite provider
   * @returns {Promise<ArchiveProvider>} The WebCite provider
   * @example
   * ```js
   * const webciteProvider = providers.webcite({ timeout: 10000 })
   * ```
   */
  webcite(options?: Readonly<WebCiteOptions>): Promise<ArchiveProvider>;
  /**
   * Helper to initialize all commonly used providers at once.
   * Note: Archive-It is excluded because it requires a collection ID; Perma.cc requires an API key.
   * Memento is excluded because it already aggregates many of the same archives.
   * @param options - Common configuration options for all providers
   * @returns {Promise<ArchiveProvider[]>} An array of all common providers
   * @example
   * ```js
   * const allProviders = providers.all({ timeout: 15000 })
   * const archive = createArchive(allProviders)
   * ```
   */
  all(options?: Readonly<ArchiveOptions>): Promise<ArchiveProvider[]>;
};
declare const storage: Storage;
type StorageConfigOptions = Readonly<{
  driver?: Driver;
  ttl?: number;
  cache?: boolean;
  prefix?: string;
}>;
/**
 * Clear stored responses for a specific provider
 *
 * @param provider - Provider.
 */
declare function clearProviderStorage(provider: Readonly<string | {
  name: string;
  slug?: string;
}>): Promise<void>;
/**
 * Configure storage options and driver
 * @deprecated Use config file or options passed to createArchive instead
 *
 * @param options - Options.
 */
declare function configureStorage(options?: StorageConfigOptions): Promise<void>;
/**
 * Configuration options for Archives
 */
interface ArchivesConfig {
  storage: {
    driver?: Driver;
    cache?: boolean;
    ttl?: number;
    prefix?: string;
  };
  performance: {
    concurrency?: number;
    batchSize?: number;
    timeout?: number;
    retries?: number;
  };
  $env?: Record<string, ArchivesConfig>;
  $development?: ArchivesConfig;
  $production?: ArchivesConfig;
  $test?: ArchivesConfig;
}
type ConfigLayer = Readonly<{
  storage?: Readonly<ArchivesConfig["storage"]>;
  performance?: Readonly<ArchivesConfig["performance"]>;
  $env?: Readonly<Record<string, ConfigLayer>>;
  $development?: ConfigLayer;
  $production?: ConfigLayer;
  $test?: ConfigLayer;
}>;
type ResolveConfigOptions = Readonly<{
  cwd?: string;
  defaults?: ConfigLayer;
  overrides?: ConfigLayer;
  envName?: string | false;
  configFile?: string;
  rcFile?: string;
}>;
/**
 * Load Archives configuration from all available sources
 *
 * @param options - Options.
 * @returns {Promise<ArchivesConfig>} A promise resolving to the operation result.
 */
declare function resolveConfig(options?: ResolveConfigOptions): Promise<ArchivesConfig>;
/**
 * Reset the cached configuration
 */
declare function resetConfig(): void;
/**
 * Get the current configuration or resolve it if not already loaded
 *
 * @param options - Options.
 * @returns {Promise<ArchivesConfig>} A promise resolving to the operation result.
 */
declare function getConfig(options?: ResolveConfigOptions): Promise<ArchivesConfig>;
export { Archive, type ArchiveContentOptions, type ArchiveContentResponse, type ArchiveDiffFormat, type ArchiveDiffOptions, type ArchiveInterface, type ArchiveItOptions, ArchiveItProvider, type ArchiveMetadata, type ArchiveOptions, type ArchiveProvider, type ArchiveResponse, type ArchiveTodayMetadata, type ArchiveTodayOptions, ArchiveTodayProvider, type ArchivedContent, type ArchivedContentDiff, type ArchivedContentSummary, type ArchivedPage, type ArchivedPageMetadata, type ArquivoMetadata, type ArquivoOptions, ArquivoProvider, BaseProvider, type CommonCrawlMetadata, type CommonCrawlOptions, CommonCrawlProvider, type ConiferOptions, ConiferProvider, type MementoMetadata, type MementoOptions, MementoProvider, type PermaccMetadata, type PermaccOptions, PermaccProvider, type ProviderReference, type ResponseMetadata, UnsupportedOperationError, type UnsupportedProviderRecord, type WaybackMetadata, type WaybackOptions, WaybackProvider, type WebCiteMetadata, type WebCiteOptions, WebCiteProvider, type WebarchivMetadata, type WebarchivOptions, WebarchivProvider, clearProviderStorage, combineContentResults, combineResults, configureStorage, createArchive, diffArchivedContent, getConfig, providers, resetConfig, resolveConfig, storage };