/**
 * Engine module for FetchEngine.
 *
 * Contains the core engine class, event definitions, and internal types.
 */
import { ObserverEngine } from '@logosdx/observer';
import { HookEngine } from '@logosdx/hooks';
import type { EventMap, EventData as EventsEventData, DedupeEventData as EventsDedupeEventData, CacheEventData as EventsCacheEventData, RateLimitEventData as EventsRateLimitEventData, RetryEventData as EventsRetryEventData, StateEventData as EventsStateEventData, PropertyEventData as EventsPropertyEventData, OptionsEventData as EventsOptionsEventData } from './events.ts';
import type { FetchEngineCore, FetchLifecycle, FetchPlugin } from './types.ts';
import { FetchState } from '../state/index.ts';
import { ConfigStore } from '../options/index.ts';
import { HeadersManager } from '../properties/headers.ts';
import { ParamsManager } from '../properties/params.ts';
import { PropertyStore } from '../properties/store.ts';
import type { EngineConfig, EngineType, EngineRequestConfig, EngineLifecycle, ValidateConfig, CallConfig, DetermineTypeFn as OptionsDetermineTypeFn, InstanceHeaders as OptionsInstanceHeaders, InstanceParams as OptionsInstanceParams, InstanceState as OptionsInstanceState } from '../options/types.ts';
import type { HttpMethods, DictAndT } from '../types.ts';
import { FetchPromise } from './fetch-promise.ts';
import type { FetchStreamPromise, ResponseDirective } from './fetch-promise.ts';
export * from './events.ts';
export * from './types.ts';
export { FetchPromise } from './fetch-promise.ts';
export type { FetchStreamPromise, ResponseDirective } from './fetch-promise.ts';
export type { CallConfig } from '../options/types.ts';
/**
 * Response headers type for type inference.
 */
export interface InstanceResponseHeaders extends Record<string, string> {
}
/**
 * Creates a wrapper around `fetch` with configurable defaults, retry logic,
 * request deduplication, caching, and rate limiting.
 *
 * Provides resilient HTTP client for production applications that need
 * reliable API communication with comprehensive error handling.
 *
 * @template H - Type of request headers
 * @template P - Type of request params
 * @template S - Type of instance state
 * @template RH - Type of response headers
 *
 * @example
 * ```typescript
 * // Basic setup with error handling
 * const api = new FetchEngine({
 *     baseUrl: 'https://api.example.com',
 *     defaultType: 'json',
 *     headers: { 'Authorization': 'Bearer token' }
 * });
 *
 * const [user, err] = await attempt(() => api.get('/users/123'));
 * if (err) {
 *     console.error('Failed to fetch user:', err);
 *     return;
 * }
 * ```
 *
 * @example
 * ```typescript
 * // Advanced setup with plugins
 * const api = new FetchEngine({
 *     baseUrl: 'https://api.example.com',
 *     plugins: [
 *         retryPlugin({ maxAttempts: 3, baseDelay: 1000 }),
 *         cachePlugin({ ttl: 60000 }),
 *         dedupePlugin(true)
 *     ]
 * });
 * ```
 */
export declare class FetchEngine<H = FetchEngine.InstanceHeaders, P = FetchEngine.InstanceParams, S = FetchEngine.InstanceState, RH = FetchEngine.InstanceResponseHeaders> extends ObserverEngine<EventMap<S, H, P>> implements FetchEngineCore<H, P, S> {
    /**
     * Symbol to use the default value or configuration.
     *
     * When returned from `determineType`, uses built-in content-type detection.
     */
    static useDefault: symbol;
    /**
     * State store for managing instance state.
     */
    readonly state: FetchState<S>;
    /**
     * Options store for accessing all configuration.
     */
    readonly config: ConfigStore<H, P, S>;
    /**
     * Headers manager for adding/removing/resolving headers.
     */
    readonly headers: HeadersManager<H>;
    /**
     * Params manager for adding/removing/resolving URL parameters.
     */
    readonly params: ParamsManager<P>;
    /**
     * Hook engine for the request lifecycle pipeline.
     *
     * Register hooks to intercept, modify, or short-circuit requests.
     * Plugins install their hooks here at negative priorities so user
     * hooks at priority 0 run after built-in policies.
     */
    readonly hooks: HookEngine<FetchLifecycle<H, P, S>>;
    /**
     * Create a new FetchEngine instance.
     *
     * @param opts - Configuration options
     */
    constructor(opts: EngineConfig<H, P, S>);
    /**
     * Install a plugin at runtime.
     *
     * The plugin's `install()` method is called with this engine instance.
     * Returns an unsubscribe function that removes the plugin's hooks.
     *
     * @param plugin - Plugin to install
     * @returns Cleanup function to uninstall the plugin
     */
    use(plugin: FetchPlugin<H, P, S>): () => void;
    /**
     * Property store for headers (FetchEngineCore compliance).
     */
    get headerStore(): PropertyStore<DictAndT<H>>;
    /**
     * Property store for params (FetchEngineCore compliance).
     */
    get paramStore(): PropertyStore<DictAndT<P>>;
    /**
     * Makes a GET request to retrieve data.
     */
    get<Res = unknown, ResHdr = RH>(path: string, options?: CallConfig<H, P>): FetchPromise<Res, DictAndT<H>, DictAndT<P>, ResHdr>;
    /**
     * Makes a POST request to create a new resource.
     */
    post<Res = unknown, Data = unknown, ResHdr = RH>(path: string, payload?: Data, options?: CallConfig<H, P>): FetchPromise<Res, DictAndT<H>, DictAndT<P>, ResHdr>;
    /**
     * Makes a PUT request to replace a resource.
     */
    put<Res = unknown, Data = unknown, ResHdr = RH>(path: string, payload?: Data, options?: CallConfig<H, P>): FetchPromise<Res, DictAndT<H>, DictAndT<P>, ResHdr>;
    /**
     * Makes a PATCH request to partially update a resource.
     */
    patch<Res = unknown, Data = unknown, ResHdr = RH>(path: string, payload?: Data, options?: CallConfig<H, P>): FetchPromise<Res, DictAndT<H>, DictAndT<P>, ResHdr>;
    /**
     * Makes a DELETE request to remove a resource.
     */
    delete<Res = unknown, Data = unknown, ResHdr = RH>(path: string, payload?: Data, options?: CallConfig<H, P>): FetchPromise<Res, DictAndT<H>, DictAndT<P>, ResHdr>;
    /**
     * Makes an HTTP OPTIONS request to check server capabilities.
     */
    options<Res = unknown, ResHdr = RH>(path: string, opts?: CallConfig<H, P>): FetchPromise<Res, DictAndT<H>, DictAndT<P>, ResHdr>;
    /**
     * Makes an HTTP HEAD request to retrieve headers only.
     */
    head<ResHdr = RH>(path: string, opts?: CallConfig<H, P>): FetchPromise<null, DictAndT<H>, DictAndT<P>, ResHdr>;
    /**
     * Makes an HTTP request with the specified method.
     */
    request<Res = unknown, Data = unknown, ResHdr = RH>(method: HttpMethods, path: string, options?: CallConfig<H, P> & {
        payload?: Data;
    }): FetchPromise<Res, DictAndT<H>, DictAndT<P>, ResHdr>;
    /**
     * Clear all cached responses.
     */
    clearCache(): void;
    /**
     * Clear a specific cache entry.
     */
    clearCacheKey(key: string): void;
    /**
     * Delete a specific cache entry.
     */
    deleteCache(key: string): Promise<boolean>;
    /**
     * Invalidate cache entries matching a predicate.
     */
    invalidateCache(predicate: (key: string) => boolean): Promise<number>;
    /**
     * Invalidate cache entries by path pattern.
     */
    invalidatePath(pattern: string | RegExp | ((key: string) => boolean)): Promise<number>;
    /**
     * Get cache statistics.
     */
    cacheStats(): any;
    /**
     * Destroy the FetchEngine instance.
     *
     * Aborts all pending requests and cleans up resources.
     * After calling destroy(), the instance cannot be used.
     */
    destroy(): void;
    /**
     * Check if the engine has been destroyed.
     */
    isDestroyed(): boolean;
}
/**
 * Namespace for FetchEngine types.
 */
export declare namespace FetchEngine {
    interface InstanceHeaders extends OptionsInstanceHeaders {
    }
    interface InstanceParams extends OptionsInstanceParams {
    }
    interface InstanceState extends OptionsInstanceState {
    }
    interface InstanceResponseHeaders extends Record<string, string> {
    }
    /** Response body type (json, text, blob, etc.) */
    type Type = EngineType;
    /** Full configuration options for FetchEngine */
    type Config<H = InstanceHeaders, P = InstanceParams, S = InstanceState> = EngineConfig<H, P, S>;
    /** Request options passed to callbacks */
    type RequestOpts<H = InstanceHeaders, P = InstanceParams> = EngineRequestConfig<H, P>;
    /** Function type for determining response body type */
    type DetermineTypeFn = OptionsDetermineTypeFn;
    /** Per-request configuration options */
    type CallConfig<H = InstanceHeaders, P = InstanceParams> = import('../options/types.ts').CallConfig<H, P>;
    /** Lifecycle hooks for requests */
    type Lifecycle<H = InstanceHeaders, P = InstanceParams> = EngineLifecycle<H, P>;
    /** Validation configuration */
    type Validate<H = InstanceHeaders, P = InstanceParams, S = InstanceState> = ValidateConfig<H, P, S>;
    /** Headers type that combines a custom type with string dict */
    type Headers<T = InstanceHeaders> = DictAndT<T>;
    /** Params type that combines a custom type with string dict */
    type Params<T = InstanceParams> = DictAndT<T>;
    /** Response headers type */
    type ResponseHeaders<T = InstanceResponseHeaders> = DictAndT<T>;
    /** Header key names */
    type HeaderKeys<H = InstanceHeaders> = keyof Headers<H>;
    /** Event data for FetchEngine events */
    type EventData<S = InstanceState, H = InstanceHeaders, P = InstanceParams> = EventsEventData<S, H, P>;
    /** Event data for deduplication events */
    type DedupeEventData<S = InstanceState, H = InstanceHeaders, P = InstanceParams> = EventsDedupeEventData<S, H, P>;
    /** Event data for cache events */
    type CacheEventData<S = InstanceState, H = InstanceHeaders, P = InstanceParams> = EventsCacheEventData<S, H, P>;
    /** Event data for rate limit events */
    type RateLimitEventData<S = InstanceState, H = InstanceHeaders, P = InstanceParams> = EventsRateLimitEventData<S, H, P>;
    /** Event data for retry events */
    type RetryEventData<S = InstanceState, H = InstanceHeaders, P = InstanceParams> = EventsRetryEventData<S, H, P>;
    /** Event data for state mutation events */
    type StateEventData<S = InstanceState> = EventsStateEventData<S>;
    /** Event data for property (header/param) events */
    type PropertyEventData<T = unknown> = EventsPropertyEventData<T>;
    /** Event data for options change events */
    type OptionsEventData = EventsOptionsEventData;
    /** Event map for ObserverEngine */
    type EventMap<S = InstanceState, H = InstanceHeaders, P = InstanceParams> = import('./events.ts').EventMap<S, H, P>;
    /** Promise that can be aborted and carries a response directive */
    type Promise<T = unknown, H = InstanceHeaders, P = InstanceParams, RH = InstanceResponseHeaders> = FetchPromise<T, H, P, RH>;
    type StreamPromise<H = InstanceHeaders, P = InstanceParams, RH = InstanceResponseHeaders> = FetchStreamPromise<DictAndT<H>, DictAndT<P>, DictAndT<RH>>;
    type Directive = ResponseDirective;
}