type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS' | 'QUERY';
type ResponseType = 'auto' | 'json' | 'text' | 'html' | 'xml' | 'dom' | 'blob' | 'arrayBuffer' | 'response' | 'stream';
type StormFetchAdapterName = 'auto' | 'fetch' | 'xhr' | 'http' | 'http2';
type RequestPriority = 'low' | 'normal' | 'high';
interface QueryObject {
    [key: string]: QueryValue;
}
type QueryValue = string | number | boolean | null | undefined | Date | QueryObject | Array<string | number | boolean | Date | QueryObject | null | undefined>;
type QueryParams = Record<string, QueryValue>;
type PathParams = Record<string, string | number | boolean>;
type HeadersInput = HeadersInit | Record<string, string>;
/** File descriptor accepted by React Native's FormData implementation. */
interface ReactNativeFile {
    uri: string;
    name: string;
    type: string;
}
interface StormFetchProgressEvent {
    loaded: number;
    total?: number;
    progress?: number;
    bytes: number;
    rate?: number;
    estimated?: number;
    lengthComputable: boolean;
    upload: boolean;
    download: boolean;
    event?: unknown;
}
interface BasicAuthConfig {
    username: string;
    password: string;
}
interface ProxyConfig {
    protocol?: 'http' | 'https';
    host: string;
    port: number;
    auth?: BasicAuthConfig;
    noProxy?: string | string[];
}
interface StormFetchTlsOptions {
    ca?: string | string[] | BufferSource;
    cert?: string | string[] | BufferSource;
    key?: string | string[] | BufferSource;
    servername?: string;
    rejectUnauthorized?: boolean;
    certificatePins?: string[];
}
interface StormFetchBeforeRedirectContext {
    from: URL;
    to: URL;
    status: number;
    headers: Headers;
    config: ResolvedFastApiRequestConfig;
    requestOptions: Record<string, unknown>;
}
interface ParamsSerializerOptions {
    indexes?: boolean | null;
    dots?: boolean;
    maxDepth?: number;
    strict?: boolean;
    encode?: (value: string) => string;
    serialize?: (params: QueryParams) => string;
}
type StormFetchJsonReviver = (key: string, value: unknown, context?: {
    source?: string;
}) => unknown;
type StormFetchFormDataHeaderPolicy = 'none' | 'content-only' | 'all';
interface StormFetchFormSerializerOptions {
    format?: 'auto' | 'json' | 'urlencoded' | 'multipart';
    /** Maximum nested object/array depth. Defaults to 32; Infinity disables the cap. */
    maxDepth?: number;
    /** Uses dot notation for nested keys instead of brackets. */
    dots?: boolean;
    /** Array key style: true = [0], false = [], null = repeated key. */
    indexes?: boolean | null;
}
type StormFetchFormSerializer = 'auto' | 'json' | 'urlencoded' | 'multipart' | StormFetchFormSerializerOptions | ((data: unknown, config: ResolvedFastApiRequestConfig) => unknown);
type StormFetchResponseEncoding = 'utf8' | 'utf16le' | 'latin1' | 'ascii' | 'base64' | 'hex';
type StormFetchMaxRate = number | [number | undefined, number | undefined];
interface StormFetchFetchEnv {
    fetch?: typeof fetch;
    Request?: typeof Request;
    Response?: typeof Response;
    Headers?: typeof Headers;
    FormData?: typeof FormData;
    Blob?: typeof Blob;
}
type StormFetchTransport = <TData = unknown, TBody = unknown>(config: ResolvedFastApiRequestConfig<TBody>) => Promise<FastApiResponse<TData, TBody>>;
interface RetryOptions {
    retry?: number;
    retryDelay?: number;
    retryUnsafe?: boolean;
    retryPolicy?: RetryPolicy;
}
interface CacheOptions {
    cache?: boolean;
    cacheTTL?: number;
    cacheStorage?: CacheStorageType | StormFetchCacheStorage | AsyncStormFetchCacheStorage;
    cacheTags?: string[];
    invalidateTags?: string[];
    staleTime?: number;
    staleWhileRevalidate?: boolean;
}
interface FastApiRequestConfig<TBody = unknown> extends RetryOptions, CacheOptions {
    url?: string;
    method?: HttpMethod;
    baseURL?: string;
    headers?: HeadersInput;
    query?: QueryParams;
    params?: QueryParams;
    pathParams?: PathParams;
    body?: TBody;
    data?: TBody;
    timeout?: number;
    credentials?: RequestCredentials;
    signal?: AbortSignal;
    responseType?: ResponseType;
    cacheMode?: RequestCache;
    mode?: RequestMode;
    redirect?: RequestRedirect;
    referrerPolicy?: ReferrerPolicy;
    dedupe?: boolean;
    silent?: boolean;
    requestId?: string;
    meta?: Record<string, unknown>;
    transformRequest?: RequestTransformer[];
    transformResponse?: ResponseTransformer[];
    adapter?: StormFetchAdapter;
    auth?: BasicAuthConfig;
    proxy?: ProxyConfig | false;
    trustProxyEnv?: boolean;
    httpAgent?: unknown;
    httpsAgent?: unknown;
    transport?: StormFetchTransport;
    socketPath?: string;
    allowedSocketPaths?: string[];
    tls?: StormFetchTlsOptions;
    paramsSerializer?: ParamsSerializerOptions | ((params: QueryParams) => string);
    validateStatus?: ((status: number) => boolean) | null;
    onUploadProgress?: (event: StormFetchProgressEvent) => void;
    onDownloadProgress?: (event: StormFetchProgressEvent) => void;
    xsrfCookieName?: string;
    xsrfHeaderName?: string;
    withXSRFToken?: boolean;
    maxRedirects?: number;
    beforeRedirect?: (context: StormFetchBeforeRedirectContext) => void | false | Partial<ResolvedFastApiRequestConfig> | Promise<void | false | Partial<ResolvedFastApiRequestConfig>>;
    maxBodyLength?: number;
    maxContentLength?: number;
    maxDecompressionRatio?: number;
    maxJsonDepth?: number;
    maxJsonKeys?: number;
    maxFormDepth?: number;
    maxResponseJsonDepth?: number;
    maxResponseJsonKeys?: number;
    parseReviver?: StormFetchJsonReviver;
    formDataHeaderPolicy?: StormFetchFormDataHeaderPolicy;
    formSerializer?: StormFetchFormSerializer;
    decompress?: boolean;
    maxRate?: StormFetchMaxRate;
    responseEncoding?: StormFetchResponseEncoding;
    strictConfig?: boolean;
    timeoutErrorMessage?: string;
    transitional?: {
        clarifyTimeoutError?: boolean;
        silentJSONParsing?: boolean;
        forcedJSONParsing?: boolean;
    };
    env?: StormFetchFetchEnv;
    fetchOptions?: Record<string, unknown>;
    family?: 0 | 4 | 6;
    lookup?: unknown;
    insecureHTTPParser?: boolean;
    httpVersion?: '1.1' | '2';
    http2Options?: Record<string, unknown>;
    localAddress?: string;
    offlineQueue?: boolean;
    offlineDependencies?: string[];
    offlinePriority?: number;
    offlineExpiresAt?: number;
    offlineGroup?: string;
    normalizeError?: ErrorNormalizer | false;
    priority?: RequestPriority;
    idempotencyKey?: string;
    requestSchema?: SchemaValidator<TBody>;
    responseSchema?: SchemaValidator<unknown>;
    traceId?: string;
}
interface ResolvedFastApiRequestConfig<TBody = unknown> extends Omit<FastApiRequestConfig<TBody>, 'headers' | 'method'> {
    url: string;
    method: HttpMethod;
    headers: Record<string, string>;
}
interface FastApiResponse<TData = unknown, TBody = unknown> {
    data: TData;
    status: number;
    statusText: string;
    headers: Headers;
    config: ResolvedFastApiRequestConfig<TBody>;
    requestId: string;
    duration: number;
    request?: unknown;
}
interface FastApiError<TData = unknown, TBody = unknown> extends Error {
    status?: number;
    data?: TData;
    code?: string;
    fieldErrors?: Record<string, string | string[]>;
    traceId?: string;
    raw?: unknown;
    request?: unknown;
    response?: FastApiResponse<TData, TBody>;
    config: ResolvedFastApiRequestConfig<TBody>;
    requestId: string;
    duration: number;
    isNetworkError: boolean;
    isTimeoutError: boolean;
    isAbortError: boolean;
    isStormFetchError: true;
    toJSON(): Record<string, unknown>;
}
type RequestTransformer = (config: ResolvedFastApiRequestConfig) => ResolvedFastApiRequestConfig | Promise<ResolvedFastApiRequestConfig>;
type ResponseTransformer = <T>(response: FastApiResponse<T>) => FastApiResponse<T> | Promise<FastApiResponse<T>>;
type RequestInterceptor = RequestTransformer;
type ResponseInterceptor = ResponseTransformer;
type ErrorInterceptor = <T = unknown>(error: FastApiError<T>) => unknown;
type RetryPolicy = 'network-only' | 'safe' | 'aggressive';
type CacheStorageType = 'memory' | 'localStorage' | 'sessionStorage';
interface StormFetchCacheStorage {
    getItem(key: string): string | null;
    setItem(key: string, value: string): void;
    removeItem(key: string): void;
    key?(index: number): string | null;
    readonly length?: number;
}
/** Promise-based storage supported by AsyncStorage, MMKV wrappers, and custom stores. */
interface AsyncStormFetchCacheStorage {
    getItem(key: string): Promise<string | null>;
    setItem(key: string, value: string): Promise<void>;
    removeItem(key: string): Promise<void>;
    getAllKeys?(): Promise<string[]>;
}
type SchemaValidator<T = unknown> = ((value: unknown) => T) | {
    parse(value: unknown): T;
} | {
    safeParse(value: unknown): {
        success: boolean;
        data?: T;
        error?: unknown;
    };
};
type StormFetchAdapter = StormFetchAdapterName | (<TData = unknown, TBody = unknown>(config: ResolvedFastApiRequestConfig<TBody>) => Promise<FastApiResponse<TData, TBody>>);
interface CircuitBreakerOptions {
    failureThreshold?: number;
    resetTimeout?: number;
    successThreshold?: number;
    fallback?: (config: ResolvedFastApiRequestConfig, error?: FastApiError) => unknown | Promise<unknown>;
}
type StormFetchPolicyMatcher = string | RegExp | ((config: FastApiRequestConfig & {
    url: string;
}) => boolean);
interface StormFetchPolicy {
    match: StormFetchPolicyMatcher;
    config: FastApiRequestConfig;
}
interface StormFetchHistoryEntry {
    id: string;
    url: string;
    method: HttpMethod;
    startedAt: number;
    endedAt?: number;
    duration?: number;
    status?: number;
    ok: boolean;
    request: ResolvedFastApiRequestConfig;
    response?: FastApiResponse;
    error?: NormalizedErrorShape;
}
interface StormFetchHarLog {
    log: {
        version: '1.2';
        creator: {
            name: 'StormFetch';
            version: string;
        };
        entries: Array<Record<string, unknown>>;
    };
}
type StormFetchHostMatcher = string | RegExp | ((host: string, url: URL) => boolean);
type StormFetchMethodMatcher = HttpMethod | '*';
type StormFetchCredentialForwardPolicy = 'always' | 'same-origin' | 'same-host' | 'never' | StormFetchHostMatcher[];
type StormFetchIpResolver = (hostname: string) => string[] | Promise<string[]>;
interface StormFetchSecurityOptions {
    allowedHosts?: StormFetchHostMatcher[];
    blockedHosts?: StormFetchHostMatcher[];
    allowedCidrs?: string[];
    blockedCidrs?: string[];
    allowedMethods?: StormFetchMethodMatcher[];
    allowedProtocols?: Array<'http:' | 'https:'>;
    allowAbsoluteUrls?: boolean;
    allowPathTraversal?: boolean;
    allowHttp?: boolean;
    allowPrivateNetwork?: boolean;
    blockCloudMetadata?: boolean;
    validateDns?: boolean;
    resolveHost?: StormFetchIpResolver;
    maxUrlLength?: number;
    maxQueryDepth?: number;
    maxJsonDepth?: number;
    maxJsonKeys?: number;
    sensitiveHeaders?: string[];
    sensitiveDataPatterns?: RegExp[];
    redactSensitiveHeaders?: boolean;
    redactSensitiveData?: boolean;
    requireSameOriginXSRF?: boolean;
    credentialPolicy?: Record<string, StormFetchCredentialForwardPolicy>;
    cookiePolicy?: StormFetchCredentialForwardPolicy;
    allowedRedirectHosts?: StormFetchHostMatcher[];
    blockedRedirectHosts?: StormFetchHostMatcher[];
    maxRedirectHosts?: number;
    blockRedirectToPrivateNetwork?: boolean;
    blockQuerySecrets?: boolean | string[];
    signRequest?: (config: ResolvedFastApiRequestConfig) => ResolvedFastApiRequestConfig | void | Promise<ResolvedFastApiRequestConfig | void>;
    guard?: (config: ResolvedFastApiRequestConfig) => void | Promise<void>;
}
type StormFetchEventType = 'request:start' | 'request:success' | 'request:error' | 'request:retry' | 'cache:hit' | 'cache:stale' | 'cache:invalidate' | 'offline:queued' | 'offline:flush' | 'offline:dead-letter' | 'transfer:start' | 'transfer:progress' | 'transfer:complete' | 'transfer:error' | 'circuit:open' | 'security:block' | 'security:redact' | 'security:credential-strip';
interface StormFetchEvent {
    type: StormFetchEventType;
    timestamp: number;
    requestId?: string;
    method?: HttpMethod;
    url?: string;
    duration?: number;
    status?: number;
    attempt?: number;
    data?: unknown;
}
interface StormFetchHmacSigningOptions {
    secret: string | (() => string | Promise<string>);
    algorithm?: 'SHA-256' | 'SHA-384' | 'SHA-512';
    headerName?: string;
    timestampHeaderName?: string;
    nonceHeaderName?: string;
    createNonce?: () => string;
    now?: () => number;
    includeBody?: boolean;
}
interface StormFetchSecureLoggerOptions {
    logger?: Pick<Console, 'debug' | 'error' | 'warn'>;
    level?: 'debug' | 'error' | 'warn';
}
interface StormFetchSpan {
    setAttribute?(name: string, value: string | number | boolean): void;
    recordException?(error: unknown): void;
    end(): void;
}
interface StormFetchObservabilityOptions {
    onEvent?: (event: StormFetchEvent) => void;
    startSpan?: (name: string, config: ResolvedFastApiRequestConfig) => StormFetchSpan | undefined;
    traceHeaderName?: string;
    createTraceId?: () => string;
}
interface OfflineQueueRecord {
    id: string;
    config: FastApiRequestConfig & {
        url: string;
        method: HttpMethod;
    };
    createdAt: number;
    attempts: number;
    nextAttemptAt?: number;
    lastError?: NormalizedErrorShape;
    dependencies?: string[];
    priority?: number;
    expiresAt?: number;
    group?: string;
}
interface OfflineQueueStorage {
    load(): Promise<OfflineQueueRecord[]>;
    save(records: OfflineQueueRecord[]): Promise<void>;
    loadDeadLetters?(): Promise<OfflineDeadLetter[]>;
    saveDeadLetters?(records: OfflineDeadLetter[]): Promise<void>;
}
interface OfflineQueueCryptoProvider {
    encrypt(plainText: string): string | Promise<string>;
    decrypt(cipherText: string): string | Promise<string>;
}
interface OfflineQueueMigration {
    from: number;
    to: number;
    migrate(records: OfflineQueueRecord[]): OfflineQueueRecord[] | Promise<OfflineQueueRecord[]>;
}
interface OfflineDeadLetter extends OfflineQueueRecord {
    failedAt: number;
    reason: NormalizedErrorShape;
}
interface OfflineQueueSnapshot {
    pending: OfflineQueueRecord[];
    deadLetters: OfflineDeadLetter[];
}
type OfflineConflictResolution = 'retry' | 'discard' | {
    config: FastApiRequestConfig & {
        url: string;
        method: HttpMethod;
    };
};
interface NativeTransferResult {
    uri?: string;
    status?: number;
    headers?: Record<string, string>;
    data?: unknown;
}
interface NativeTransferOptions {
    url: string;
    fileUri?: string;
    destinationUri?: string;
    method?: HttpMethod;
    headers?: Record<string, string>;
    body?: Record<string, unknown>;
    onProgress?: (event: StormFetchProgressEvent) => void;
    signal?: AbortSignal;
    background?: boolean;
}
interface NativeTransferAdapter {
    upload(options: NativeTransferOptions): Promise<NativeTransferResult>;
    download(options: NativeTransferOptions): Promise<NativeTransferResult>;
    startUpload?(options: NativeTransferOptions): NativeTransferTask;
    startDownload?(options: NativeTransferOptions): NativeTransferTask;
}
interface NativeTransferTask {
    readonly id: string;
    readonly result: Promise<NativeTransferResult>;
    pause(): void | Promise<void>;
    resume(): void | Promise<void>;
    cancel(reason?: unknown): void | Promise<void>;
}
interface NormalizedErrorShape {
    message?: string;
    code?: string;
    fieldErrors?: Record<string, string | string[]>;
    traceId?: string;
    raw?: unknown;
}
type ErrorNormalizer = (error: FastApiError) => NormalizedErrorShape | void;
type StormFetchPluginCapability = 'adapter' | 'auth' | 'cache' | 'observability' | 'serializer' | 'security' | 'transport';
interface StormFetchPlugin {
    name?: string;
    version?: string;
    apiVersion?: string;
    capabilities?: StormFetchPluginCapability[];
    setup(client: FastApiClient): void | (() => void) | Promise<void | (() => void)>;
    dispose?(): void | Promise<void>;
}
interface StormFetchInstalledPlugin {
    name: string;
    version: string;
    apiVersion: string;
    capabilities: StormFetchPluginCapability[];
}
interface InterceptorManager<THandler> {
    use(handler: THandler, options?: InterceptorOptions): () => void;
    eject(handler: THandler): void;
    clear(): void;
    handlers(context?: unknown): THandler[];
}
interface InterceptorOptions {
    /** Runs this interceptor only when the predicate accepts the current config/response/error. */
    runWhen?: (context: unknown) => boolean;
    /** Automatically ejects the interceptor after its first matching execution. */
    once?: boolean;
    /** Runs before existing interceptors instead of after them. */
    prepend?: boolean;
}
interface FastApiClientOptions extends Omit<FastApiRequestConfig, 'url' | 'method' | 'body' | 'data'> {
    baseURL?: string;
    headers?: HeadersInput;
    timeout?: number;
    debug?: boolean;
    rateLimit?: number;
    token?: () => string | null | Promise<string | null>;
    refreshToken?: (error: FastApiError) => Promise<string | null>;
    onUnauthorized?: (error: FastApiError) => void;
    onSuccess?: (response: FastApiResponse) => void;
    onError?: (error: FastApiError) => void;
    language?: () => string | null;
    plugins?: StormFetchPlugin[];
    /** Supplies network state in runtimes such as React Native (for example, from NetInfo). */
    isOnline?: () => boolean | Promise<boolean>;
    /** Saves data returned by download(). Required for auto-save outside a browser. */
    fileSaver?: StormFetchFileSaver;
    maxConcurrent?: number;
    maxConcurrentPerHost?: number;
    circuitBreaker?: CircuitBreakerOptions | false;
    security?: StormFetchSecurityOptions;
    observability?: StormFetchObservabilityOptions;
    offlineStorage?: OfflineQueueStorage;
    offlineMaxAttempts?: number;
    offlineRetryDelay?: number | ((attempt: number, record: OfflineQueueRecord) => number);
    offlineIdempotencyHeader?: string | false;
    resolveOfflineConflict?: (record: OfflineQueueRecord, error: unknown) => OfflineConflictResolution | Promise<OfflineConflictResolution>;
    onOfflineDeadLetter?: (entry: OfflineDeadLetter) => void | Promise<void>;
    nativeTransfer?: NativeTransferAdapter;
    domParser?: StormFetchDomParser;
    graphqlEndpoint?: string;
    historyLimit?: number;
    policies?: StormFetchPolicy[];
}
interface DownloadOptions extends Omit<FastApiRequestConfig, 'responseType'> {
    fileName?: string;
    /** Override the client-level file saver for this download. */
    fileSaver?: StormFetchFileSaver;
    /** Set false to return the downloaded Blob without attempting to save it. */
    autoSave?: boolean;
}
type StormFetchFileSaver = (data: Blob, fileName: string, response: FastApiResponse<Blob>) => void | Promise<void>;
interface FastApiClient {
    defaults: FastApiClientOptions;
    interceptors: {
        request: InterceptorManager<RequestInterceptor>;
        response: InterceptorManager<ResponseInterceptor>;
        error: InterceptorManager<ErrorInterceptor>;
    };
    request<TData = unknown, TBody = unknown>(config: FastApiRequestConfig<TBody> & {
        url: string;
        method?: HttpMethod;
    }): Promise<FastApiResponse<TData, TBody>>;
    fetch<TData = unknown, TBody = unknown>(url: string, config?: FastApiRequestConfig<TBody>): Promise<FastApiResponse<TData, TBody>>;
    get<TData = unknown>(url: string, config?: FastApiRequestConfig): Promise<FastApiResponse<TData>>;
    post<TData = unknown, TBody = unknown>(url: string, data?: TBody, config?: FastApiRequestConfig<TBody>): Promise<FastApiResponse<TData, TBody>>;
    put<TData = unknown, TBody = unknown>(url: string, data?: TBody, config?: FastApiRequestConfig<TBody>): Promise<FastApiResponse<TData, TBody>>;
    patch<TData = unknown, TBody = unknown>(url: string, data?: TBody, config?: FastApiRequestConfig<TBody>): Promise<FastApiResponse<TData, TBody>>;
    delete<TData = unknown>(url: string, config?: FastApiRequestConfig): Promise<FastApiResponse<TData>>;
    head(url: string, config?: FastApiRequestConfig): Promise<FastApiResponse<undefined>>;
    options<TData = unknown>(url: string, config?: FastApiRequestConfig): Promise<FastApiResponse<TData>>;
    query<TData = unknown, TBody = unknown>(url: string, data?: TBody, config?: FastApiRequestConfig<TBody>): Promise<FastApiResponse<TData, TBody>>;
    GET<TData = unknown>(url: string, config?: FastApiRequestConfig): Promise<FastApiResponse<TData>>;
    POST<TData = unknown, TBody = unknown>(url: string, data?: TBody, config?: FastApiRequestConfig<TBody>): Promise<FastApiResponse<TData, TBody>>;
    PUT<TData = unknown, TBody = unknown>(url: string, data?: TBody, config?: FastApiRequestConfig<TBody>): Promise<FastApiResponse<TData, TBody>>;
    PATCH<TData = unknown, TBody = unknown>(url: string, data?: TBody, config?: FastApiRequestConfig<TBody>): Promise<FastApiResponse<TData, TBody>>;
    DELETE<TData = unknown>(url: string, config?: FastApiRequestConfig): Promise<FastApiResponse<TData>>;
    HEAD(url: string, config?: FastApiRequestConfig): Promise<FastApiResponse<undefined>>;
    OPTIONS<TData = unknown>(url: string, config?: FastApiRequestConfig): Promise<FastApiResponse<TData>>;
    QUERY<TData = unknown, TBody = unknown>(url: string, data?: TBody, config?: FastApiRequestConfig<TBody>): Promise<FastApiResponse<TData, TBody>>;
    postJson<TData = unknown, TBody = unknown>(url: string, data?: TBody, config?: FastApiRequestConfig<TBody>): Promise<FastApiResponse<TData, TBody>>;
    postForm<TData = unknown>(url: string, data: Record<string, unknown> | URLSearchParams, config?: FastApiRequestConfig): Promise<FastApiResponse<TData, URLSearchParams>>;
    postMultipart<TData = unknown>(url: string, data: Record<string, unknown> | FormData, config?: FastApiRequestConfig): Promise<FastApiResponse<TData, FormData>>;
    graphql<TData = unknown, TVariables = Record<string, unknown>>(query: string, variables?: TVariables, config?: FastApiRequestConfig): Promise<FastApiResponse<TData, {
        query: string;
        variables?: TVariables;
    }>>;
    batch<TResponses extends readonly unknown[] = unknown[]>(requests: readonly StormFetchBatchRequest[]): Promise<{
        [K in keyof TResponses]: FastApiResponse<TResponses[K]>;
    }>;
    poll<TData = unknown>(url: string, intervalOrOptions?: number | StormFetchPollOptions<TData>, config?: FastApiRequestConfig): StormFetchPollController<TData>;
    getHtml(url: string, config?: FastApiRequestConfig): Promise<FastApiResponse<string>>;
    getXml(url: string, config?: FastApiRequestConfig): Promise<FastApiResponse<string>>;
    getDom(url: string, config?: FastApiRequestConfig & {
        mimeType?: StormFetchDomMimeType;
    }): Promise<FastApiResponse<StormFetchDomDocument>>;
    parseDom(html: string, mimeType?: StormFetchDomMimeType): StormFetchDomDocument;
    scrape<TShape extends StormFetchScrapeSchema>(url: string, schema: TShape, config?: FastApiRequestConfig): Promise<FastApiResponse<StormFetchScrapeResult<TShape>>>;
    resource<TData = unknown, TCreate = Partial<TData>, TUpdate = Partial<TCreate>>(basePath: string): StormFetchResource<TData, TCreate, TUpdate>;
    download(url: string, fileName?: string, config?: DownloadOptions): Promise<FastApiResponse<Blob>>;
    clearCache(key?: string): void;
    clearCacheAsync(key?: string): Promise<void>;
    invalidateTags(tags: string[]): Promise<void>;
    cacheManager: StormFetchCacheManager;
    prefetch<TData = unknown>(url: string, config?: FastApiRequestConfig): Promise<FastApiResponse<TData>>;
    dehydrateCache(): Promise<StormFetchCacheSnapshot>;
    hydrateCache(snapshot: StormFetchCacheSnapshot): Promise<void>;
    cacheKeys(): string[];
    history(): StormFetchHistoryEntry[];
    clearHistory(): void;
    replay<TData = unknown>(requestId: string): Promise<FastApiResponse<TData>>;
    toCurl(requestIdOrConfig: string | ResolvedFastApiRequestConfig): string;
    toHAR(): StormFetchHarLog;
    policy(match: StormFetchPolicyMatcher, config: FastApiRequestConfig): () => void;
    streamText(url: string, config?: FastApiRequestConfig): AsyncIterable<string>;
    streamJson<TData = unknown>(url: string, config?: FastApiRequestConfig): Promise<TData>;
    streamNdjson<TData = unknown>(url: string, config?: FastApiRequestConfig): AsyncIterable<TData>;
    sse(url: string, options?: StormFetchSseOptions): StormFetchSseController;
    contract<TContract extends StormFetchContractDefinition>(definition: TContract): StormFetchContract<TContract>;
    createFormData(data: Record<string, unknown>): FormData;
    flushOfflineQueue?(): Promise<void>;
    offlineQueueSnapshot?(): Promise<OfflineQueueSnapshot>;
    retryOfflineRequest?(id: string): Promise<void>;
    discardOfflineRequest?(id: string): Promise<void>;
    retryOfflineBatch?(ids?: string[]): Promise<void>;
    reconcileOfflineRequest?(id: string, config: FastApiRequestConfig & {
        url: string;
        method: HttpMethod;
    }): Promise<void>;
    subscribe?(listener: (event: StormFetchEvent) => void): () => void;
    nativeUpload?(options: NativeTransferOptions): Promise<NativeTransferResult>;
    nativeDownload?(options: NativeTransferOptions): Promise<NativeTransferResult>;
    startNativeUpload?(options: NativeTransferOptions): NativeTransferTask;
    startNativeDownload?(options: NativeTransferOptions): NativeTransferTask;
    usePlugin?(plugin: StormFetchPlugin): Promise<() => Promise<void>>;
    removePlugin?(name: string): Promise<void>;
    installedPlugins?(): StormFetchInstalledPlugin[];
    dispose?(): Promise<void>;
}
interface ReactLike {
    useCallback<T extends (...args: never[]) => unknown>(callback: T, deps: unknown[]): T;
    useEffect(effect: () => void | (() => void), deps?: unknown[]): void;
    useState<T>(initial: T | (() => T)): [T, (next: T | ((current: T) => T)) => void];
}
interface StormQueryOptions<TData> {
    enabled?: boolean;
    initialData?: TData;
    onSuccess?: (data: TData) => void;
    onError?: (error: FastApiError) => void;
    refetchOnFocus?: boolean;
    refetchOnReconnect?: boolean;
    config?: FastApiRequestConfig;
}
type StormFetchRuntime = 'browser' | 'react-native' | 'node' | 'deno' | 'bun' | 'unknown';
interface StormFetchRuntimeInfo {
    runtime: StormFetchRuntime;
    isBrowser: boolean;
    isReactNative: boolean;
    isNode: boolean;
    isDeno: boolean;
    isBun: boolean;
    hasFetch: boolean;
    hasXHR: boolean;
    hasFormData: boolean;
    hasBlob: boolean;
}
interface StormQueryState<TData> {
    data?: TData;
    error?: FastApiError;
    loading: boolean;
    refetch: () => Promise<void>;
    reset: () => void;
}
interface StormMutationState<TData, TBody> {
    data?: TData;
    error?: FastApiError;
    loading: boolean;
    mutate: (body?: TBody, config?: FastApiRequestConfig<TBody>) => Promise<FastApiResponse<TData, TBody>>;
    reset: () => void;
}
interface StormMutationOptions<TData, TBody, TContext = unknown> {
    invalidateTags?: string[];
    optimisticData?: (current: TData | undefined, body?: TBody) => TData;
    onMutate?: (body?: TBody) => TContext | Promise<TContext>;
    onSuccess?: (data: TData, body?: TBody, context?: TContext) => void;
    onError?: (error: FastApiError, body?: TBody, context?: TContext) => void;
}
interface StormInfiniteQueryState<TData, TPageParam> {
    pages: TData[];
    error?: FastApiError;
    loading: boolean;
    fetchingNextPage: boolean;
    hasNextPage: boolean;
    fetchNextPage: () => Promise<void>;
    refetch: () => Promise<void>;
    reset: () => void;
    pageParams: TPageParam[];
}
interface StormInfiniteQueryOptions<TData, TPageParam> {
    enabled?: boolean;
    initialPageParam: TPageParam;
    getNextPageParam: (lastPage: TData, pages: TData[], pageParams: TPageParam[]) => TPageParam | undefined;
    createConfig: (pageParam: TPageParam, pages: TData[]) => FastApiRequestConfig;
    onSuccess?: (pages: TData[]) => void;
    onError?: (error: FastApiError) => void;
}
interface MockRoute<TData = unknown> {
    method?: HttpMethod;
    url: string | RegExp | ((config: ResolvedFastApiRequestConfig) => boolean);
    status?: number;
    statusText?: string;
    headers?: HeadersInput;
    delay?: number;
    data: TData | ((config: ResolvedFastApiRequestConfig) => TData | Promise<TData> | FastApiResponse<TData> | Promise<FastApiResponse<TData>>);
}
interface MockAdapterOptions {
    routes?: MockRoute[];
    delay?: number;
    passthrough?: StormFetchAdapter;
    scenario?: string;
    scenarios?: Record<string, MockRoute[]>;
}
interface StormFetchMockServer {
    adapter: StormFetchAdapter;
    setScenario(name: string): void;
    addRoute(route: MockRoute, scenario?: string): void;
    requests(): ResolvedFastApiRequestConfig[];
    clearRequests(): void;
}
type StormFetchDomMimeType = 'text/html' | 'application/xml' | 'text/xml' | 'application/xhtml+xml';
interface StormFetchDomParser {
    parse(html: string, mimeType: StormFetchDomMimeType): StormFetchDomDocument;
}
interface StormFetchDomDocument {
    querySelector(selector: string): StormFetchDomElement | null;
    querySelectorAll(selector: string): Iterable<StormFetchDomElement> | ArrayLike<StormFetchDomElement>;
}
interface StormFetchDomElement {
    textContent?: string | null;
    getAttribute(name: string): string | null;
}
type StormFetchScrapeRule = string | readonly [string] | {
    selector: string;
    attr?: string;
    all?: boolean;
    trim?: boolean;
};
type StormFetchScrapeSchema = Record<string, StormFetchScrapeRule>;
type StormFetchScrapeValue<TRule> = TRule extends readonly [string] ? string[] : TRule extends {
    all: true;
} ? string[] : string | undefined;
type StormFetchScrapeResult<TShape extends StormFetchScrapeSchema> = {
    [K in keyof TShape]: StormFetchScrapeValue<TShape[K]>;
};
interface StormFetchBatchRequest<TData = unknown, TBody = unknown> extends FastApiRequestConfig<TBody> {
    url: string;
    method?: HttpMethod;
    data?: TBody;
    map?: (response: FastApiResponse<TData, TBody>) => unknown;
}
interface StormFetchPollOptions<TData = unknown> {
    interval?: number;
    immediate?: boolean;
    maxAttempts?: number;
    stopWhen?: (response: FastApiResponse<TData>) => boolean;
    onData?: (response: FastApiResponse<TData>) => void;
    onError?: (error: FastApiError) => void;
    config?: FastApiRequestConfig;
}
interface StormFetchPollController<TData = unknown> {
    stop(): void;
    subscribe(listener: (response: FastApiResponse<TData>) => void): () => void;
    readonly stopped: boolean;
}
interface StormFetchResource<TData = unknown, TCreate = Partial<TData>, TUpdate = Partial<TCreate>> {
    list(config?: FastApiRequestConfig): Promise<FastApiResponse<TData[]>>;
    detail(id: string | number, config?: FastApiRequestConfig): Promise<FastApiResponse<TData>>;
    create(data: TCreate, config?: FastApiRequestConfig<TCreate>): Promise<FastApiResponse<TData, TCreate>>;
    replace(id: string | number, data: TCreate, config?: FastApiRequestConfig<TCreate>): Promise<FastApiResponse<TData, TCreate>>;
    update(id: string | number, data: TUpdate, config?: FastApiRequestConfig<TUpdate>): Promise<FastApiResponse<TData, TUpdate>>;
    remove(id: string | number, config?: FastApiRequestConfig): Promise<FastApiResponse<unknown>>;
}
interface StormFetchCacheSnapshotEntry {
    key: string;
    value: unknown;
    ttl: number;
    tags: string[];
    staleTime?: number;
}
interface StormFetchCacheSnapshot {
    version: number;
    entries: StormFetchCacheSnapshotEntry[];
}
interface StormFetchCacheManager {
    prefetch<TData = unknown>(url: string, config?: FastApiRequestConfig): Promise<FastApiResponse<TData>>;
    invalidate(tags: string[]): Promise<void>;
    clear(key?: string): Promise<void>;
    keys(): string[];
    dehydrate(): Promise<StormFetchCacheSnapshot>;
    hydrate(snapshot: StormFetchCacheSnapshot): Promise<void>;
    subscribe(listener: (event: StormFetchEvent) => void): () => void;
}
interface StormFetchSseMessage {
    event?: string;
    data: string;
    id?: string;
    retry?: number;
}
interface StormFetchSseOptions extends FastApiRequestConfig {
    onMessage?: (message: StormFetchSseMessage) => void;
    onError?: (error: unknown) => void;
}
interface StormFetchSseController {
    close(): void;
    readonly closed: boolean;
}
interface StormFetchContractEndpoint {
    method: HttpMethod;
    url: string;
}
type StormFetchContractDefinition = Record<string, StormFetchContractEndpoint>;
type StormFetchContract<TContract extends StormFetchContractDefinition> = {
    [K in keyof TContract]: <TData = unknown, TBody = unknown>(dataOrConfig?: TBody | FastApiRequestConfig<TBody>, config?: FastApiRequestConfig<TBody>) => Promise<FastApiResponse<TData, TBody>>;
};
interface StormFetchServerClientOptions extends FastApiClientOptions {
    cookies?: string | Record<string, string>;
    headers?: HeadersInput;
}
interface EndpointDefinition<TData = unknown, TBody = unknown> {
    data: TData;
    body?: TBody;
}
type EndpointMap = Record<string, Partial<Record<HttpMethod, EndpointDefinition>>>;
type EndpointResponse<TEndpoints extends EndpointMap, TMethod extends HttpMethod, TUrl extends keyof TEndpoints & string> = TEndpoints[TUrl][TMethod] extends EndpointDefinition<infer TData, unknown> ? TData : unknown;
type EndpointBody<TEndpoints extends EndpointMap, TMethod extends HttpMethod, TUrl extends keyof TEndpoints & string> = TEndpoints[TUrl][TMethod] extends EndpointDefinition<unknown, infer TBody> ? TBody : unknown;
type TypedStormFetchClient<TEndpoints extends EndpointMap> = Omit<FastApiClient, 'get' | 'post' | 'put' | 'patch' | 'delete'> & {
    get<TUrl extends keyof TEndpoints & string>(url: TUrl, config?: FastApiRequestConfig): Promise<FastApiResponse<EndpointResponse<TEndpoints, 'GET', TUrl>>>;
    post<TUrl extends keyof TEndpoints & string>(url: TUrl, data?: EndpointBody<TEndpoints, 'POST', TUrl>, config?: FastApiRequestConfig<EndpointBody<TEndpoints, 'POST', TUrl>>): Promise<FastApiResponse<EndpointResponse<TEndpoints, 'POST', TUrl>, EndpointBody<TEndpoints, 'POST', TUrl>>>;
    put<TUrl extends keyof TEndpoints & string>(url: TUrl, data?: EndpointBody<TEndpoints, 'PUT', TUrl>, config?: FastApiRequestConfig<EndpointBody<TEndpoints, 'PUT', TUrl>>): Promise<FastApiResponse<EndpointResponse<TEndpoints, 'PUT', TUrl>, EndpointBody<TEndpoints, 'PUT', TUrl>>>;
    patch<TUrl extends keyof TEndpoints & string>(url: TUrl, data?: EndpointBody<TEndpoints, 'PATCH', TUrl>, config?: FastApiRequestConfig<EndpointBody<TEndpoints, 'PATCH', TUrl>>): Promise<FastApiResponse<EndpointResponse<TEndpoints, 'PATCH', TUrl>, EndpointBody<TEndpoints, 'PATCH', TUrl>>>;
    delete<TUrl extends keyof TEndpoints & string>(url: TUrl, config?: FastApiRequestConfig): Promise<FastApiResponse<EndpointResponse<TEndpoints, 'DELETE', TUrl>>>;
};
type StormFetchClient = FastApiClient;
type StormFetchClientOptions = FastApiClientOptions;
type StormFetchRequestConfig<TBody = unknown> = FastApiRequestConfig<TBody>;
type StormFetchResponse<TData = unknown, TBody = unknown> = FastApiResponse<TData, TBody>;
type StormFetchError<TData = unknown, TBody = unknown> = FastApiError<TData, TBody>;

export type { HeadersInput as $, StormFetchServerClientOptions as A, EndpointMap as B, FastApiError as C, DownloadOptions as D, ErrorInterceptor as E, FastApiClient as F, PathParams as G, HttpMethod as H, InterceptorManager as I, ReactNativeFile as J, OfflineQueueStorage as K, OfflineQueueRecord as L, StormFetchRuntimeInfo as M, NativeTransferOptions as N, OfflineQueueSnapshot as O, ParamsSerializerOptions as P, QueryParams as Q, RequestTransformer as R, StormFetchBatchRequest as S, TypedStormFetchClient as T, AsyncStormFetchCacheStorage as U, BasicAuthConfig as V, CacheOptions as W, CacheStorageType as X, CircuitBreakerOptions as Y, EndpointDefinition as Z, ErrorNormalizer as _, FastApiClientOptions as a, StormMutationState as a$, InterceptorOptions as a0, MockAdapterOptions as a1, MockRoute as a2, NativeTransferAdapter as a3, NormalizedErrorShape as a4, OfflineConflictResolution as a5, OfflineDeadLetter as a6, OfflineQueueCryptoProvider as a7, OfflineQueueMigration as a8, ProxyConfig as a9, StormFetchFormSerializer as aA, StormFetchFormSerializerOptions as aB, StormFetchHmacSigningOptions as aC, StormFetchHostMatcher as aD, StormFetchIpResolver as aE, StormFetchJsonReviver as aF, StormFetchMaxRate as aG, StormFetchMethodMatcher as aH, StormFetchMockServer as aI, StormFetchObservabilityOptions as aJ, StormFetchPluginCapability as aK, StormFetchPolicy as aL, StormFetchProgressEvent as aM, StormFetchRequestConfig as aN, StormFetchResponse as aO, StormFetchResponseEncoding as aP, StormFetchRuntime as aQ, StormFetchScrapeRule as aR, StormFetchSecureLoggerOptions as aS, StormFetchSecurityOptions as aT, StormFetchSpan as aU, StormFetchSseMessage as aV, StormFetchTlsOptions as aW, StormFetchTransport as aX, StormInfiniteQueryOptions as aY, StormInfiniteQueryState as aZ, StormMutationOptions as a_, QueryObject as aa, QueryValue as ab, ReactLike as ac, RequestInterceptor as ad, RequestPriority as ae, ResponseInterceptor as af, ResponseType as ag, RetryOptions as ah, RetryPolicy as ai, SchemaValidator as aj, StormFetchAdapter as ak, StormFetchAdapterName as al, StormFetchBeforeRedirectContext as am, StormFetchCacheSnapshotEntry as an, StormFetchCacheStorage as ao, StormFetchClient as ap, StormFetchClientOptions as aq, StormFetchContractEndpoint as ar, StormFetchCredentialForwardPolicy as as, StormFetchDomElement as at, StormFetchDomParser as au, StormFetchError as av, StormFetchEventType as aw, StormFetchFetchEnv as ax, StormFetchFileSaver as ay, StormFetchFormDataHeaderPolicy as az, ResponseTransformer as b, StormQueryOptions as b0, StormQueryState as b1, FastApiRequestConfig as c, FastApiResponse as d, StormFetchPollOptions as e, StormFetchPollController as f, StormFetchDomMimeType as g, StormFetchDomDocument as h, StormFetchScrapeSchema as i, StormFetchScrapeResult as j, StormFetchResource as k, StormFetchCacheManager as l, StormFetchCacheSnapshot as m, StormFetchHistoryEntry as n, ResolvedFastApiRequestConfig as o, StormFetchHarLog as p, StormFetchPolicyMatcher as q, StormFetchSseOptions as r, StormFetchSseController as s, StormFetchContractDefinition as t, StormFetchContract as u, NativeTransferResult as v, NativeTransferTask as w, StormFetchPlugin as x, StormFetchInstalledPlugin as y, StormFetchEvent as z };