import { i as MimeType, n as HeadersWithSuggestions, r as KnownRequestHeader, t as HeadersRecord } from "./http-well-known-CWSKjGqw.mjs";
import { $ as mapResult, A as CacheManager, B as HTTPOptions, C as InfiniteData, D as CircuitBreakerOptions, E as CircuitBreaker, F as AbortError, G as TimeoutError, H as NetworkError, I as CacheMetadata, J as http, K as ValidationError, L as CircuitOpenError, M as MemoryAdapter, N as StorageAdapter, O as CircuitState, P as WebStorageAdapter, Q as err, R as HTTPError, S as parseTraceparent, T as InfiniteQueryOptions, U as ParamScalar, V as HTTPResponse, W as ParamsValue, X as Ok, Y as Err, Z as Result, _ as OTelConfig, at as MetricsCollector, b as createOTelInterceptor, c as JsonPrimitive, d as Logger, et as ok, f as RequestInterceptor, g as TaskQueue, h as QueueEvents, i as HTTPClientConfig, it as Metrics, j as CacheOptions, k as CacheEntry, l as JsonValue, m as PersistentQueueOptions, n as HTTPBuilder, nt as unwrap, o as JsonArray, ot as RequestMetrics, p as ResponseInterceptor, q as ValidationSchema, r as HTTPClient, rt as unwrapOr, s as JsonObject, t as BodyData, tt as toResult, u as LogMeta, v as OTelSpanHooks, w as InfiniteQuery, x as formatTraceparent, y as SpanContext, z as HTTPMethod } from "./http-client-CtmE_7Hq.mjs";
import { a as RetryResult, i as RetryOptions, n as QueueOptions, r as QueueTask, t as EventEmitter } from "./emitter-C4RFGk0k.mjs";
import { i as GraphQLResponse, r as GraphQLError, t as GraphQLClient } from "./graphql-client-CfX6Si5y.mjs";
import { n as SSEConfig, r as SSEEvents, t as SSEClient } from "./sse-client-BWVzOXwo.mjs";
import { n as WebSocketConfig, r as WebSocketEvents, t as WebSocketClient } from "./websocket-client-auDoEEzU.mjs";
import { n as MockResponseData, t as MockAdapter } from "./mock-adapter-BLbCf01X.mjs";

//#region src/utils/auth.d.ts
interface AuthConfig {
  /**
   * Function to retrieve the current access token.
   */
  getAccessToken: () => string | null | Promise<string | null>;
  /**
   * Function to refresh the tokens.
   * Should throw if refresh fails.
   * Should return the new access token.
   */
  refreshTokens: (client: HTTPClient) => Promise<string>;
  /**
   * Callback when refresh fails (e.g. logout user).
   */
  onRefreshFailed?: (error: unknown) => void;
  /**
   * Header name used to attach the access token. Common header names are
   * suggested by IntelliSense.
   * @default 'Authorization'
   */
  headerName?: KnownRequestHeader;
  /**
   * Token prefix (default: 'Bearer ')
   */
  tokenPrefix?: string;
}
/**
 * Creates an authentication interceptor that handles:
 * 1. Attaching the access token to requests.
 * 2. Intercepting 401 errors.
 * 3. Refreshing the token.
 * 4. Retrying the original request.
 */
declare function createAuthInterceptor(client: HTTPClient, config: AuthConfig): void;
//#endregion
//#region src/utils/batch.d.ts
interface BatchOptions {
  maxBatchSize?: number;
  batchDelayMs?: number;
}
/**
 * Groups multiple individual calls into a single batch execution.
 * Useful for reducing N+1 API calls or database queries.
 *
 * @template T The type of individual items to be processed
 * @template R The type of the result for each item
 */
declare class BatchProcessor<T, R> {
  private queue;
  private timeout;
  private readonly maxBatchSize;
  private readonly batchDelayMs;
  private readonly processor;
  /**
   * Creates a new BatchProcessor instance.
   *
   * @param processor Function that handles a batch of items and returns an array of results
   * @param options Configuration for batch size and delay
   */
  constructor(processor: (items: T[]) => Promise<R[]>, options?: BatchOptions);
  /**
   * Adds an item to the batch queue.
   *
   * @param item The item to process
   * @returns Promise resolving to the result for this specific item
   */
  add(item: T): Promise<R>;
  private flush;
}
//#endregion
//#region src/utils/polling.d.ts
/**
 * Options for {@link PollingController} and the {@link poll} helper.
 *
 * @template T The resolved type of each poll result.
 *
 * @example
 * ```ts
 * // Poll until a job completes, with adaptive intervals
 * const { promise, cancel } = poll(
 *   () => client.get<Job>('/jobs/123'),
 *   {
 *     interval: 2000,
 *     until: (res) => res.data.status === 'completed',
 *     adaptiveInterval: (res) =>
 *       res.data.progress < 50 ? 5000 : 1000, // faster near completion
 *     timeout: 60_000,
 *   }
 * );
 *
 * const job = await promise;
 * ```
 */
interface PollingOptions<T = unknown> {
  /**
   * Base interval between poll attempts, in milliseconds.
   * When `backoff` is enabled this is the *initial* interval.
   * When `adaptiveInterval` is provided this value is used as the fallback
   * for the first attempt only.
   */
  interval: number;
  /**
   * Wall-clock deadline for the entire polling session, in milliseconds.
   * An error is thrown if the deadline is exceeded before the stop condition fires.
   */
  timeout?: number;
  /**
   * Maximum number of total attempts (successes + errors) before giving up.
   * An error is thrown when the limit is reached.
   */
  maxAttempts?: number;
  /**
   * Return `true` to stop polling and resolve the session with the latest result.
   * Alias for the more verbose `stopCondition` option — use whichever reads more naturally.
   *
   * When both `until` and `stopCondition` are provided, **`until` takes precedence**.
   *
   * @example
   * until: (response) => response.data.status === 'completed'
   */
  until?: (data: T) => boolean;
  /**
   * Return `true` to stop polling and resolve the session with the latest
   * result. When omitted polling continues until `timeout` or `maxAttempts`.
   *
   * @deprecated Prefer {@link PollingOptions.until} for clearer intent. Both are supported.
   */
  stopCondition?: (data: T) => boolean;
  /**
   * Dynamic interval calculator. Called after every successful poll with the
   * latest result; the returned value becomes the wait time before the next
   * attempt. Overrides `interval` and `backoff` when present.
   *
   * Useful for polls that should speed up or slow down based on response state
   * (e.g. poll faster as a job approaches 100% completion).
   *
   * @example
   * adaptiveInterval: (response) =>
   *   response.data.progress < 50 ? 5000 : 1000 // slow then fast
   */
  adaptiveInterval?: (data: T) => number;
  /**
   * Called when the polling task throws. Receives the error and the current
   * attempt count (including this failed attempt).
   * Return `false` to stop polling and re-throw the error.
   * Any other return value (including `void`) continues polling.
   */
  onError?: (error: unknown, attempts: number) => boolean | void;
  /**
   * Exponential back-off applied to the interval after each attempt.
   * - `true` — use defaults: `factor: 1.5`, `maxInterval: 30_000`
   * - `false` / omitted — constant interval
   * - Object — custom multiplier and ceiling
   *
   * Ignored when `adaptiveInterval` is provided.
   *
   * @example
   * backoff: { factor: 2, maxInterval: 30_000 }
   */
  backoff?: boolean | {
    /** Multiplier applied after each attempt. @example 1.5 */
    factor: number;
    /** Maximum interval ceiling in milliseconds. @example 30000 */
    maxInterval: number;
  };
}
declare class PollingController<T = unknown> {
  private task;
  private options;
  private isRunning;
  private attempts;
  private currentInterval;
  private abortController;
  constructor(task: () => Promise<T>, options: PollingOptions<T>);
  start(): Promise<T | void>;
  stop(): void;
  get signal(): AbortSignal;
}
/**
 * Helper function for simple polling.
 *
 * @example
 * ```ts
 * const { promise, cancel } = poll(
 *   () => client.get<JobStatus>('/jobs/42'),
 *   {
 *     interval: 2000,
 *     until: (res) => res.data.status === 'done',
 *     timeout: 120_000,
 *   }
 * );
 *
 * const result = await promise;
 * ```
 */
declare function poll<T>(task: () => Promise<T>, options: PollingOptions<T>): {
  promise: Promise<T | void>;
  cancel: () => void;
};
//#endregion
//#region src/utils/batch-transport.d.ts
interface BatchRequestItem {
  url: string;
  config: HTTPOptions;
}
interface BatchTransportConfig extends BatchOptions {
  /**
   * Predicate to determine if a request should be batched.
   */
  shouldBatch: (url: string, config: HTTPOptions) => boolean;
  /**
   * Function to execute a batch of requests.
   * Must return an array of responses corresponding to the input items.
   */
  executeBatch: (items: BatchRequestItem[]) => Promise<HTTPResponse<unknown>[]>;
}
type TransportFunction = <T = unknown>(url: string, options: HTTPOptions) => Promise<HTTPResponse<T>>;
/**
 * Creates a transport adapter that automatically groups eligible requests into batches.
 *
 * @param innerTransport The original transport function (e.g., fetch-based transport)
 * @param config Configuration for batching behavior
 * @returns A new transport function that handles batching
 */
declare function createBatchTransport(innerTransport: TransportFunction, config: BatchTransportConfig): <T = unknown>(url: string, options: HTTPOptions) => Promise<HTTPResponse<T>>;
//#endregion
//#region src/utils/logger.d.ts
/**
 * Numeric log-level constants.
 *
 * Implemented as an `as const` object (not an `enum`) to keep the emitted JS
 * tree-shakeable and to avoid the dual-lookup overhead of TypeScript enums.
 *
 * @example
 * new ConsoleLogger(LogLevel.DEBUG)
 * new ConsoleLogger({ level: LogLevel.WARN, format: 'json' })
 */
declare const LogLevel: {
  /** No output at all. */
  readonly NONE: 0;
  /** Fatal / unrecoverable errors only. */
  readonly ERROR: 1;
  /** Degraded-service warnings and above. */
  readonly WARN: 2;
  /** General operational messages and above (default). */
  readonly INFO: 3;
  /** Verbose diagnostic messages and above. */
  readonly DEBUG: 4;
};
/** The type of a valid {@link LogLevel} value. */
type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
/**
 * Configuration options for {@link ConsoleLogger}.
 */
interface ConsoleLoggerOptions {
  /**
   * Minimum severity level to emit. Messages below this level are silently discarded.
   * @default LogLevel.INFO
   */
  level?: LogLevel;
  /**
   * Output format.
   * - `'text'` — human-readable `[LEVEL prefix] message` lines (default)
   * - `'json'` — structured JSON objects suitable for log aggregators (Datadog, Splunk, etc.)
   * @default 'text'
   */
  format?: 'text' | 'json';
  /**
   * Optional prefix prepended to every log message (text format only).
   * @example '[MyApp:HTTP]'
   */
  prefix?: string;
  /**
   * Header names whose values should be replaced with `'[REDACTED]'` before logging.
   * Case-insensitive. Useful for hiding auth tokens and cookies.
   * @example ['Authorization', 'Cookie', 'X-Api-Key']
   */
  redactHeaders?: string[];
}
/**
 * Simple `console`-based logger that implements the {@link Logger} interface.
 *
 * Supports configurable log levels, structured JSON output, custom prefixes,
 * and header redaction for security-conscious production environments.
 *
 * @example
 * ```ts
 * // Development: human-readable, debug-level, redact auth headers
 * const logger = new ConsoleLogger({
 *   level: LogLevel.DEBUG,
 *   prefix: '[MyApp:HTTP]',
 *   redactHeaders: ['Authorization', 'Cookie'],
 * });
 *
 * // Production: JSON format for log aggregators, warnings and above only
 * const logger = new ConsoleLogger({
 *   level: LogLevel.WARN,
 *   format: 'json',
 *   redactHeaders: ['Authorization', 'Cookie', 'X-Api-Key'],
 * });
 *
 * const client = new HTTPBuilder().withLogger(logger).build();
 * ```
 */
declare class ConsoleLogger implements Logger {
  private readonly level;
  private readonly format;
  private readonly prefix;
  private readonly redactSet;
  constructor(levelOrOptions?: LogLevel | ConsoleLoggerOptions);
  /** @internal Redact sensitive header values before logging. */
  private redactMeta;
  /** @internal Emit a log message at the given level. */
  private emit;
  debug(message: string, meta?: LogMeta): void;
  info(message: string, meta?: LogMeta): void;
  warn(message: string, meta?: LogMeta): void;
  error(message: string, meta?: LogMeta): void;
}
//#endregion
//#region src/utils/network.d.ts
interface NetworkMonitorOptions {
  checkInterval?: number;
  /**
   * URL to HEAD-ping for active connectivity checks.
   *
   * ⚠️  The old default `'https://www.google.com'` caused CORS failures in browsers
   * and was unreliable in restricted networks (China, corporate firewalls).
   * The new default `/favicon.ico` is same-origin and requires no CORS headers.
   *
   * Override with a CORS-permissive health endpoint owned by you if you need
   * cross-origin connectivity checks.
   *
   * @default '/favicon.ico'
   */
  pingUrl?: string;
}
type NetworkEvents = {
  online: [];
  offline: [];
};
declare class NetworkMonitor extends EventEmitter<NetworkEvents> {
  private static _instance;
  private isOnline;
  private checkIntervalId;
  /**
   * URL used for active connectivity checks.
   * Defaults to `/favicon.ico` (same-origin, no CORS needed).
   * Override via `configure({ pingUrl: '...' })` or the constructor.
   */
  private pingUrl;
  private readonly _onlineBound;
  private readonly _offlineBound;
  constructor(options?: NetworkMonitorOptions);
  /**
   * Returns the shared singleton instance.
   *
   * For testing or environments that need isolated instances, instantiate
   * `new NetworkMonitor()` directly and call `.destroy()` when done.
   */
  static getInstance(): NetworkMonitor;
  /**
   * Destroy the singleton and reset the cached reference.
   * Useful between test cases to prevent state bleed.
   */
  static resetInstance(): void;
  configure(options: NetworkMonitorOptions): void;
  startPolling(interval: number): void;
  stopPolling(): void;
  /**
   * Release all resources held by this monitor:
   * - Stops the polling interval
   * - Removes `window.online` / `window.offline` event listeners
   *
   * Call this when the monitor is no longer needed to prevent memory leaks,
   * particularly in SSR environments, tests, or hot-reload scenarios.
   */
  destroy(): void;
  private checkConnection;
  private handleOnline;
  private handleOffline;
  get online(): boolean;
}
//#endregion
//#region src/utils/pagination.d.ts
interface PaginationOptions<T> {
  pageParam?: string;
  limitParam?: string;
  limit?: number;
  initialPage?: number;
  totalPath?: string;
  resultsPath?: string;
  stopCondition?: (response: HTTPResponse<unknown>, pageItems: T[], totalFetched: number) => boolean;
}
declare function paginate<T>(client: HTTPClient, url: string, options?: PaginationOptions<T>): AsyncGenerator<T[]>;
//#endregion
//#region src/utils/pipeline.d.ts
type TransformFn<In, Out> = (input: In) => Out;
declare class Pipeline<In, Out> {
  private readonly fn;
  private constructor();
  static from<T>(): Pipeline<T, T>;
  map<NewOut>(fn: TransformFn<Out, NewOut>): Pipeline<In, NewOut>;
  tap(fn: (input: Out) => void): Pipeline<In, Out>;
  execute(input: In): Out;
}
declare class AsyncPipeline<In, Out> {
  private readonly fn;
  private constructor();
  static from<T>(): AsyncPipeline<T, T>;
  map<NewOut>(fn: (input: Out) => NewOut | Promise<NewOut>): AsyncPipeline<In, NewOut>;
  tap(fn: (input: Out) => void | Promise<void>): AsyncPipeline<In, Out>;
  execute(input: In): Promise<Out>;
}
//#endregion
//#region src/utils/rate-limiter.d.ts
/**
 * Token Bucket implementation for rate limiting.
 */
declare class RateLimiter {
  private tokens;
  private lastRefill;
  private readonly maxTokens;
  private readonly refillRate;
  private readonly interval;
  /**
   * Serializes token acquisition so that concurrent callers cannot both observe
   * the same token and over-consume. Each call chains onto the tail of a promise
   * queue, guaranteeing only one caller runs `_acquireToken` at a time.
   *
   * Without this, two concurrent callers both calling `getTimeToWait()` at the
   * same instant would observe the same "1 token available" state, both sleep
   * for 0 ms, and both call `tryConsume()` — consuming 1 token twice (TOCTOU).
   */
  private acquisitionQueue;
  /**
   * @param limit Maximum number of requests allowed in the interval
   * @param interval Interval in milliseconds
   */
  constructor(limit: number, interval: number);
  private refill;
  /**
   * Attempts to consume a token.
   * @returns true if a token was consumed, false otherwise
   */
  tryConsume(): boolean;
  /**
   * Returns the time in milliseconds to wait before the next token is available.
   */
  getTimeToWait(): number;
  /**
   * Internal: waits for a token and consumes it. Called serially via
   * `acquisitionQueue` so concurrent callers never race on token state.
   */
  private _acquireToken;
  /**
   * Waits until a token is available, then consumes it.
   *
   * Thread-safe: concurrent callers are serialised through an internal promise
   * chain so that each caller acquires exactly one token in FIFO order.
   */
  waitForToken(): Promise<void>;
  /**
   * Resets the limiter to its initial state.
   */
  reset(): void;
}
//#endregion
//#region src/utils/recorder.d.ts
interface RecordedRequest {
  id: string;
  timestamp: number;
  url: string;
  method: string;
  requestHeaders: HeadersRecord;
  requestBody: JsonValue | null;
  status: number;
  responseHeaders: HeadersRecord;
  responseBody: JsonValue | null;
  duration: number;
}
declare class NetworkRecorder {
  private records;
  private isRecording;
  private client?;
  constructor(client?: HTTPClient);
  attach(client: HTTPClient): void;
  private captureResponse;
  /**
   * Manually record a request/response pair.
   * Useful for tests and examples where you want to inject fixtures directly.
   */
  record(entry: Omit<RecordedRequest, 'id' | 'timestamp'> & Partial<Pick<RecordedRequest, 'id' | 'timestamp'>>): void;
  start(): void;
  stop(): void;
  getRecords(): RecordedRequest[];
  /** Alias for {@link getRecords}. */
  getAll(): RecordedRequest[];
  clear(): void;
  generateFixtures(): string;
}
//#endregion
//#region src/utils/network-errors.d.ts
/**
 * @file network-errors.ts
 *
 * Runtime-agnostic network error detection and classification.
 *
 * Node.js surfaces OS-level network failures as Error objects with a `.code`
 * property (e.g. `ETIMEDOUT`, `ECONNRESET`). Browsers surface them as generic
 * TypeError with a descriptive message. Deno and Bun have their own error
 * class hierarchies. This module normalises them all into a single, typed API.
 *
 * Used internally by the retry engine to distinguish *transient* failures
 * (should retry) from *permanent* ones (should not retry).
 */
/**
 * POSIX / Node.js error codes that indicate a transient, retriable network failure.
 *
 * These codes appear on the `.code` property of Node.js system errors and on
 * `DOMException` in some runtime environments.
 */
declare const TRANSIENT_NETWORK_CODES: ReadonlySet<string>;
/**
 * Returns `true` when `error` represents a transient network-level failure
 * that is safe to retry (e.g. DNS failure, TCP reset, connection refused).
 *
 * Works across Node.js, Bun, Deno, Cloudflare Workers, and browsers.
 */
declare function isTransientNetworkError(error: unknown): boolean;
/**
 * Returns `true` when `error` is a timeout specifically (distinguished from
 * other network failures to allow separate retry budgets).
 */
declare function isTimeoutError(error: unknown): boolean;
/**
 * Returns `true` when `error` is a DNS resolution failure.
 * Useful for filtering out config errors (wrong host) from retry logic.
 */
declare function isDnsError(error: unknown): boolean;
/**
 * Classify a network error for structured logging / telemetry.
 */
type NetworkErrorClass = 'timeout' | 'dns' | 'connection_refused' | 'connection_reset' | 'network_unavailable' | 'other_transient' | 'non_transient';
declare function classifyNetworkError(error: unknown): NetworkErrorClass;
//#endregion
//#region src/utils/retry.d.ts
/**
 * Thrown by {@link withRetry} when all retry attempts are exhausted or
 * `retryCondition` returns `false`. Carries structured metadata about the
 * failed run so callers don't need to cast the caught value.
 */
declare class RetryError extends Error {
  /** Total number of attempts made before giving up. */
  readonly attempts: number;
  /** Wall-clock time elapsed across all attempts, in milliseconds. */
  readonly durationMs: number;
  /** The original error that caused the final failure. */
  readonly cause: Error;
  constructor(cause: Error, attempts: number, durationMs: number);
}
/**
 * Executes a function with automatic retry logic based on configuration.
 *
 * @template T The return type of the function
 * @param fn The async function to execute
 * @param options Configuration options for the retry behavior
 * @returns Promise resolving to the result with metadata about attempts and duration
 *
 * @example
 * ```ts
 * const data = await withRetry(() => fetch('/api/data'), {
 *   maxRetries: 3,
 *   backoffFactor: 2
 * });
 * ```
 */
declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<RetryResult<T>>;
//#endregion
//#region src/utils/tracing.d.ts
interface TracingConfig {
  /**
   * Header name for the trace ID.
   * Well-known tracing headers are suggested by IntelliSense.
   * @default 'x-request-id'
   */
  headerName?: KnownRequestHeader;
  /**
   * Function to generate a trace ID.
   * Defaults to a random UUID-like string.
   */
  generateId?: () => string;
}
/**
 * Creates a request interceptor that injects a unique Trace ID into every request.
 * Useful for distributed tracing and log correlation.
 *
 * @example
 * client.interceptors.request.push(
 *   createTraceInterceptor({ headerName: 'X-Correlation-ID' })
 * );
 */
declare function createTraceInterceptor(config?: TracingConfig): {
  onFulfilled: (options: HTTPOptions) => HTTPOptions;
};
//#endregion
//#region src/utils/dedup.d.ts
/** Methods that are safe to deduplicate (idempotent, no side effects). */
declare const DEDUP_SAFE_METHODS: Set<"GET" | "HEAD" | "OPTIONS">;
interface DedupStats {
  /** Number of requests currently sharing an in-flight promise. */
  inflight: number;
  /** Cumulative number of duplicate calls that were collapsed. */
  savedRequests: number;
}
/**
 * Produce a stable deduplication key from the request method, resolved URL,
 * and (optionally) a serialised body.
 *
 * The key must be cheap to compute and collision-resistant for practical use.
 * We intentionally do NOT hash (CPU cost), relying on the URL + body string
 * to be unique in practice for in-flight windows.
 *
 * Body serialisation is guarded against circular references — such requests
 * are treated as non-deduplicated rather than crashing the entire pipeline.
 */
declare function buildDedupKey(method: string, url: string, body?: JsonValue | string | null): string;
/**
 * Lightweight in-flight request deduplicator.
 *
 * Maintains a `Map<key, Promise>` of in-flight requests. Any call that arrives
 * with the same key before the first Promise settles receives that exact
 * Promise reference — zero extra network calls.
 *
 * Thread/async-safe: the Map entry is deleted synchronously inside `.finally()`
 * so the slot is cleared before any microtask continuation can race.
 */
declare class RequestDeduplicator {
  private readonly inflight;
  private _savedRequests;
  /**
   * Return an existing in-flight Promise for `key` if one exists, otherwise
   * call `fn()`, store its Promise, and return it.
   *
   * @param key   Dedup key — see {@link buildDedupKey}.
   * @param fn    Factory that starts the actual network request.
   */
  deduplicate<T>(key: string, fn: () => Promise<T>): Promise<T>;
  /** Force-remove a key (e.g. after a cache invalidation). */
  evict(key: string): void;
  /** Drop all in-flight entries. Pending callers will still resolve normally. */
  clear(): void;
  /** Live stats for monitoring / debugging. */
  stats(): DedupStats;
}
//#endregion
//#region src/utils/runtime.d.ts
/**
 * @file runtime.ts
 *
 * Runtime environment detection and capability feature-flags.
 *
 * reixo targets every modern JavaScript runtime without requiring adapters or
 * manual configuration. This module detects the current environment and exposes
 * per-capability flags so the rest of the library can branch once, consistently,
 * rather than scattering `typeof window !== 'undefined'` checks everywhere.
 *
 * Supported runtimes:
 *  - **Browser**             — Chrome, Firefox, Safari, Edge (modern)
 *  - **Node.js 18+**         — native `fetch` via undici
 *  - **Bun**                 — native `fetch`
 *  - **Deno**                — native `fetch`
 *  - **Cloudflare Workers**  — `workerd` runtime (no Node.js APIs)
 *  - **Vercel Edge Runtime** — `edge-light` (subset of Web APIs)
 *  - **Fastly Compute**      — Wasm-based, Web APIs only
 */
type RuntimeName = 'browser' | 'node' | 'bun' | 'deno' | 'workerd' | 'edge-light' | 'fastly' | 'unknown';
/**
 * Detect the current JavaScript runtime environment.
 *
 * Detection is performed once and memoised — safe to call frequently.
 */
declare function detectRuntime(): RuntimeName;
interface RuntimeCapabilities {
  /** Runtime name — for logging / debugging. */
  name: RuntimeName;
  /** `fetch` is available natively (no polyfill needed). */
  hasFetch: boolean;
  /** `ReadableStream` + `TransformStream` are available (streaming bodies). */
  hasStreams: boolean;
  /** `crypto.randomUUID()` and `crypto.getRandomValues()` are available. */
  hasCrypto: boolean;
  /**
   * `XMLHttpRequest` is available.
   * Needed for accurate upload-progress events in browsers.
   */
  hasXHR: boolean;
  /**
   * Node.js-style system error codes (`.code` property on errors) may appear.
   * Used by the network-error classifier to detect ETIMEDOUT, ECONNRESET, etc.
   */
  hasNodeErrorCodes: boolean;
  /**
   * HTTP/2 multiplexing is available through the fetch adapter.
   * True for Bun, Deno, Node 18+ (undici), and Cloudflare Workers.
   */
  hasHTTP2: boolean;
}
/** Return the runtime capabilities, computing them once and caching the result. */
declare function getRuntimeCapabilities(): RuntimeCapabilities;
/** `true` when running inside a browser tab/worker. */
declare const isBrowser: () => boolean;
/** `true` when running inside Node.js. */
declare const isNode: () => boolean;
/** `true` when running on Cloudflare Workers or Vercel Edge. */
declare const isEdgeRuntime: () => boolean;
//#endregion
//#region src/utils/upload.d.ts
interface UploadOptions {
  chunkSize?: number;
  retries?: number;
  headers?: Record<string, string>;
  onProgress?: (progress: {
    uploaded: number;
    total: number;
    percentage: number;
  }) => void;
  parallel?: number;
}
declare class ResumableUploader {
  private readonly chunkSize;
  private readonly retries;
  private readonly parallel;
  /** AbortController shared across all in-flight chunk requests. */
  private _abortController;
  constructor(options?: UploadOptions);
  /**
   * Abort all in-flight chunk uploads.
   *
   * Any pending `upload()` call will reject with a `DOMException(AbortError)`.
   * The upload state is NOT cleared — you can inspect `completedChunks` to
   * determine how much was already transferred.
   *
   * Note: true resumability (persisting chunk state and restarting from the
   * last completed chunk) is tracked in todos/05-missing-features.md.
   */
  abort(): void;
  upload(url: string, file: File | Blob, options?: UploadOptions): Promise<void>;
  private processInBatches;
}
//#endregion
//#region src/index.d.ts
declare const Reixo: {
  HTTPBuilder: typeof HTTPBuilder;
  HTTPClient: typeof HTTPClient;
  TaskQueue: typeof TaskQueue;
  CircuitBreaker: typeof CircuitBreaker;
  CircuitState: {
    readonly CLOSED: "CLOSED";
    readonly OPEN: "OPEN";
    readonly HALF_OPEN: "HALF_OPEN";
  };
  BatchProcessor: typeof BatchProcessor;
  createAuthInterceptor: typeof createAuthInterceptor;
  HTTPError: typeof HTTPError;
  GraphQLClient: typeof GraphQLClient;
  WebSocketClient: typeof WebSocketClient;
  SSEClient: typeof SSEClient;
  poll: typeof poll;
  InfiniteQuery: typeof InfiniteQuery;
};
//#endregion
export { AbortError, AsyncPipeline, type AuthConfig, type BatchOptions, BatchProcessor, type BatchRequestItem, type BatchTransportConfig, type BodyData, type CacheEntry, CacheManager, type CacheMetadata, type CacheOptions, CircuitBreaker, type CircuitBreakerOptions, CircuitOpenError, CircuitState, ConsoleLogger, type ConsoleLoggerOptions, DEDUP_SAFE_METHODS, type DedupStats, type Err, GraphQLClient, type GraphQLError, type GraphQLResponse, HTTPBuilder, HTTPClient, type HTTPClientConfig, HTTPError, type HTTPMethod, type HTTPOptions, type HTTPResponse, type HeadersRecord, type HeadersWithSuggestions, type InfiniteData, InfiniteQuery, type InfiniteQueryOptions, type JsonArray, type JsonObject, type JsonPrimitive, type JsonValue, type KnownRequestHeader, LogLevel, type LogMeta, MemoryAdapter, type Metrics, MetricsCollector, type MimeType, MockAdapter, type MockResponseData, NetworkError, type NetworkErrorClass, NetworkMonitor, NetworkRecorder, type OTelConfig, type OTelSpanHooks, type Ok, type PaginationOptions, type ParamScalar, type ParamsValue, type PersistentQueueOptions, Pipeline, PollingController, type PollingOptions, type QueueEvents, type QueueOptions, type QueueTask, RateLimiter, type RecordedRequest, Reixo, RequestDeduplicator, type RequestInterceptor, type RequestMetrics, type ResponseInterceptor, type Result, ResumableUploader, RetryError, type RetryOptions, type RetryResult, type RuntimeCapabilities, type RuntimeName, SSEClient, type SSEConfig, type SSEEvents, type SpanContext, type StorageAdapter, TRANSIENT_NETWORK_CODES, TaskQueue, TimeoutError, type TracingConfig, type TransformFn, ValidationError, type ValidationSchema, WebSocketClient, type WebSocketConfig, type WebSocketEvents, WebStorageAdapter, buildDedupKey, classifyNetworkError, createAuthInterceptor, createBatchTransport, createOTelInterceptor, createTraceInterceptor, detectRuntime, err, formatTraceparent, getRuntimeCapabilities, http, isBrowser, isDnsError, isEdgeRuntime, isNode, isTimeoutError, isTransientNetworkError, mapResult, ok, paginate, parseTraceparent, poll, toResult, unwrap, unwrapOr, withRetry };
//# sourceMappingURL=index.d.mts.map