/**
 * Base interface for all CLI command strategies
 *
 * Strategies allow customization of command behavior through dependency injection.
 * Each strategy has a designated role and can override specific aspects of command execution.
 */
export interface CliStrategy {
    /** Unique identifier for the strategy role */
    readonly role: string;
    /** Strategy name for debugging and logging */
    readonly name: string;
}
/**
 * Strategy for customizing template selection and processing
 */
export interface TemplateStrategy extends CliStrategy {
    role: 'template';
    /**
     * Get available templates
     * @returns Array of template names
     */
    getAvailableTemplates(): Promise<string[]>;
    /**
     * Validate template selection
     * @param template - Template name to validate
     * @returns True if template is valid
     */
    validateTemplate(template: string): Promise<boolean>;
    /**
     * Process template files
     * @param templatePath - Path to template directory
     * @param targetPath - Target directory for processed files
     * @param variables - Template variables for substitution
     */
    processTemplate(templatePath: string, targetPath: string, variables: Record<string, unknown>): Promise<void>;
}
/**
 * Strategy for customizing deployment behavior
 */
export interface DeploymentStrategy extends CliStrategy {
    role: 'deployment';
    /**
     * Pre-deployment validation
     * @param config - Deployment configuration
     * @returns True if deployment should proceed
     */
    validateDeployment(config: unknown): Promise<boolean>;
    /**
     * Custom deployment steps
     * @param config - Deployment configuration
     * @param context - Deployment context
     */
    executeDeployment(config: unknown, context: unknown): Promise<void>;
    /**
     * Post-deployment actions
     * @param result - Deployment result
     */
    postDeployment(result: unknown): Promise<void>;
}
/**
 * Strategy for customizing logging and output
 */
export interface LoggingStrategy extends CliStrategy {
    role: 'logging';
    /**
     * Format log messages
     * @param level - Log level (info, warn, error, etc.)
     * @param message - Log message
     * @param metadata - Additional metadata
     * @returns Formatted message
     */
    formatMessage(level: string, message: string, metadata?: Record<string, unknown>): string;
    /**
     * Handle command output
     * @param output - Command output to process
     */
    handleOutput(output: unknown): Promise<void>;
}
/**
 * Strategy for customizing validation behavior
 */
export interface ValidationStrategy extends CliStrategy {
    role: 'validation';
    /**
     * Validate command options
     * @param options - Command options to validate
     * @returns Validation result with errors if any
     */
    validateOptions(options: unknown): Promise<{
        valid: boolean;
        errors: string[];
    }>;
    /**
     * Validate environment prerequisites
     * @param environment - Environment context
     * @returns True if environment is valid
     */
    validateEnvironment(environment: unknown): Promise<boolean>;
}
/**
 * Union type of all supported strategy types
 */
export type SupportedStrategy = TemplateStrategy | DeploymentStrategy | LoggingStrategy | ValidationStrategy;
/**
 * Map of strategy roles to their instances
 */
export type StrategyMap = {
    template?: TemplateStrategy;
    deployment?: DeploymentStrategy;
    logging?: LoggingStrategy;
    validation?: ValidationStrategy;
};
/**
 * Strategy container that holds multiple strategy instances by role
 */
export declare class StrategyContainer {
    private strategies;
    /**
     * Add a strategy instance
     * @param strategy - Strategy instance to add
     */
    addStrategy(strategy: CliStrategy): void;
    /**
     * Get strategy by role
     * @param role - Strategy role to retrieve
     * @returns Strategy instance or undefined if not found
     */
    getStrategy<T extends CliStrategy>(role: string): T | undefined;
    /**
     * Check if strategy exists for role
     * @param role - Strategy role to check
     * @returns True if strategy exists
     */
    hasStrategy(role: string): boolean;
    /**
     * Get all registered strategies
     * @returns Array of all strategy instances
     */
    getAllStrategies(): CliStrategy[];
    /**
     * Clear all strategies
     */
    clear(): void;
    /**
     * Create a new container with strategies from a map
     * @param strategyMap - Map of strategies by role
     * @returns New strategy container
     */
    static fromMap(strategyMap: StrategyMap): StrategyContainer;
}
/**
 * Type guard to check if an object is a CLI strategy
 * @param obj - Object to check
 * @returns True if object implements CliStrategy interface
 */
export declare function isCliStrategy(obj: unknown): obj is CliStrategy;
/**
 * Validate that a strategy implements the expected interface for its role
 * @param strategy - Strategy to validate
 * @returns True if strategy is valid for its role
 */
export declare function validateStrategyInterface(strategy: CliStrategy): boolean;
