import type { _InternalHttpMethods, RequestKeyOptions, RequestSerializer } from '../types.ts';
import type { BasePolicyRule, BasePolicyConfig, PolicyInternalState } from './types.ts';
/**
 * Abstract base class for resilience policies.
 *
 * Provides the common three-method pattern used by all policies:
 * - `init`: Parse config, initialize state (O(1))
 * - `resolve`: Memoized lookup + dynamic checks (O(1) amortized)
 * - `compute`: Rule matching, memoized (O(n) first call only)
 *
 * Subclasses must implement:
 * - `getDefaultSerializer()`: Return the default serializer for this policy
 * - `getDefaultMethods()`: Return the default HTTP methods for this policy
 * - `mergeRuleWithDefaults(rule)`: Merge a rule with policy defaults
 *
 * @template TConfig - The policy config type extending BasePolicyConfig
 * @template TRule - The rule type extending BasePolicyRule
 * @template S - Instance state type
 * @template H - Headers type
 * @template P - Params type
 */
export declare abstract class ResiliencePolicy<TConfig extends BasePolicyConfig<any, any, any, TRule>, TRule extends BasePolicyRule<any, any, any>, S = any, H = any, P = any> {
    protected state: PolicyInternalState<TRule, S, H, P> | null;
    protected config: TConfig | null;
    /**
     * Get the default serializer for this policy.
     * Subclasses must implement this.
     */
    protected abstract getDefaultSerializer(): RequestSerializer<S, H, P>;
    /**
     * Get the default HTTP methods for this policy.
     * Subclasses must implement this.
     */
    protected abstract getDefaultMethods(): _InternalHttpMethods[];
    /**
     * Merge a matched rule with policy defaults.
     * Subclasses must implement this to handle policy-specific fields.
     *
     * @param rule - The matched rule (or null for global defaults)
     * @returns The merged rule with all defaults applied
     */
    protected abstract mergeRuleWithDefaults(rule: TRule | null): TRule;
    /**
     * Whether the policy is initialized and enabled.
     */
    get isEnabled(): boolean;
    /**
     * Initialize the policy with configuration.
     *
     * Parses the config (boolean or object), validates rules,
     * and sets up internal state for fast lookups.
     *
     * @param config - Boolean true for defaults, or full config object
     */
    init(config?: boolean | TConfig): void;
    /**
     * Resolve policy configuration for a specific request.
     *
     * Uses memoization for rule matching (O(n) only once per method+path).
     * Skip callbacks are always evaluated since they depend on request context.
     *
     * @param method - HTTP method (uppercase)
     * @param path - Request path
     * @param ctx - Full request context for skip callback
     * @param skipCallback - Optional skip callback from config
     * @returns Resolved rule or null if disabled
     */
    resolve(method: string, path: string, ctx: RequestKeyOptions<S, H, P>, skipCallback?: (ctx: RequestKeyOptions<S, H, P>) => boolean | undefined): TRule | null;
    /**
     * Compute rule configuration for a method+path combination.
     *
     * This is the expensive O(n) operation that gets memoized.
     * Finds matching rule and merges with policy defaults.
     *
     * @param method - HTTP method (uppercase)
     * @param path - Request path
     * @returns Computed rule or null if disabled
     */
    protected compute(method: string, path: string): TRule | null;
    /**
     * Clear the rules cache.
     *
     * Call this if you need to force re-computation of rules,
     * though typically this is not needed.
     */
    clearCache(): void;
}