import { GuardContext, GuardResultObject, GuardTiming, RouteGuard, GuardExecutionResult } from './route-guard';
/**
 * Composite guard execution strategy
 */
export type CompositeStrategy = 'all' | 'any' | 'first' | 'priority' | 'sequential' | 'parallel';
/**
 * Composite guard configuration
 */
export interface CompositeGuardConfig {
    /** Guard name */
    readonly name?: string;
    /** Guards to combine */
    readonly guards: readonly RouteGuard[];
    /** Execution strategy */
    readonly strategy?: CompositeStrategy;
    /** Short-circuit on first failure (for 'all' strategy) */
    readonly shortCircuit?: boolean;
    /** Short-circuit on first success (for 'any' strategy) */
    readonly shortCircuitSuccess?: boolean;
    /** Custom result merger */
    readonly mergeResults?: (results: readonly GuardResultObject[]) => GuardResultObject;
    /** Timeout for parallel execution */
    readonly timeout?: number;
    /** Feature flag for this composite guard */
    readonly featureFlag?: string;
}
/**
 * Composite guard execution result
 */
export interface CompositeExecutionResult {
    /** Final result */
    readonly result: GuardResultObject;
    /** Individual guard results */
    readonly guardResults: readonly GuardExecutionResult[];
    /** Total execution time (ms) */
    readonly totalDurationMs: number;
    /** Guards that passed */
    readonly passed: readonly string[];
    /** Guards that failed */
    readonly failed: readonly string[];
    /** Guards that were skipped */
    readonly skipped: readonly string[];
    /** Strategy used */
    readonly strategy: CompositeStrategy;
}
/**
 * Default composite guard configuration
 */
export declare const DEFAULT_COMPOSITE_CONFIG: Partial<CompositeGuardConfig>;
/**
 * Combines multiple guards into one
 *
 * @example
 * ```typescript
 * const guard = new CompositeGuard({
 *   guards: [authGuard, roleGuard, featureGuard],
 *   strategy: 'all',
 *   shortCircuit: true,
 * });
 *
 * const result = await guard.execute('canActivate', context);
 * ```
 */
export declare class CompositeGuard implements RouteGuard {
    readonly name: string;
    readonly priority: number;
    readonly enabled = true;
    private readonly config;
    private readonly sortedGuards;
    constructor(config: CompositeGuardConfig);
    /**
     * Execute the composite guard
     */
    execute(timing: GuardTiming, context: GuardContext): Promise<GuardResultObject>;
    /**
     * Execute with detailed results
     */
    executeWithDetails(timing: GuardTiming, context: GuardContext): Promise<CompositeExecutionResult>;
    /**
     * Check if guard applies to a path
     */
    appliesTo(path: string): boolean;
    /**
     * Get all guards in this composite
     */
    getGuards(): readonly RouteGuard[];
    /**
     * Get strategy
     */
    getStrategy(): CompositeStrategy;
    /**
     * Execute all guards (AND logic)
     */
    private executeAll;
    /**
     * Execute any guard (OR logic)
     */
    private executeAny;
    /**
     * Execute first matching guard
     */
    private executeFirst;
    /**
     * Execute in priority order (same as sequential for sorted guards)
     */
    private executePriority;
    /**
     * Execute all guards sequentially
     */
    private executeSequential;
    /**
     * Execute all guards in parallel
     */
    private executeParallel;
}
/**
 * Create a composite guard
 *
 * @param config - Composite guard configuration
 * @returns CompositeGuard instance
 */
export declare function createCompositeGuard(config: CompositeGuardConfig): CompositeGuard;
/**
 * Combine guards with AND logic (all must pass)
 *
 * @param guards - Guards to combine
 * @param options - Additional options
 * @returns CompositeGuard instance
 */
export declare function allGuards(guards: readonly RouteGuard[], options?: Partial<Omit<CompositeGuardConfig, 'guards' | 'strategy'>>): CompositeGuard;
/**
 * Combine guards with OR logic (any can pass)
 *
 * @param guards - Guards to combine
 * @param options - Additional options
 * @returns CompositeGuard instance
 */
export declare function anyGuard(guards: readonly RouteGuard[], options?: Partial<Omit<CompositeGuardConfig, 'guards' | 'strategy'>>): CompositeGuard;
/**
 * Combine guards for sequential execution
 *
 * @param guards - Guards to execute in order
 * @param options - Additional options
 * @returns CompositeGuard instance
 */
export declare function sequentialGuards(guards: readonly RouteGuard[], options?: Partial<Omit<CompositeGuardConfig, 'guards' | 'strategy'>>): CompositeGuard;
/**
 * Combine guards for parallel execution
 *
 * @param guards - Guards to execute in parallel
 * @param options - Additional options
 * @returns CompositeGuard instance
 */
export declare function parallelGuards(guards: readonly RouteGuard[], options?: Partial<Omit<CompositeGuardConfig, 'guards' | 'strategy'>>): CompositeGuard;
/**
 * Alias for allGuards
 */
export declare const combineGuards: typeof allGuards;
/**
 * Type guard for CompositeGuard
 */
export declare function isCompositeGuard(value: unknown): value is CompositeGuard;
/**
 * Type guard for CompositeExecutionResult
 */
export declare function isCompositeExecutionResult(value: unknown): value is CompositeExecutionResult;