/**
 * Configuration Validation Utilities
 *
 * Validation utilities for feature flag configuration in NestJS applications.
 * Provides error reporting and environment-specific validation.
 *
 */
import { type CoreFeatureFlagEnvironmentConfig, type CoreFeatureFlagValidationResult } from '@plyaz/types/core';
/**
 * FeatureFlagConfigValidator - Comprehensive configuration validation for feature flags
 *
 * @description Validates feature flag configuration objects to ensure they meet system requirements
 * and best practices. Provides detailed error reporting and warnings for potential issues.
 *
 * **Validation Categories:**
 * - Provider validation (memory, file, redis, api, database)
 * - Cache configuration validation
 * - Database connection validation
 * - Environment-specific settings validation
 *
 * **Usage Flow:**
 * 1. Configuration is loaded from environment variables
 * 2. Validator checks all settings for correctness
 * 3. Errors prevent system startup
 * 4. Warnings are logged but don't block startup
 *
 * @example Basic Validation
 * ```typescript
 * const config = {
 *   provider: 'database',
 *   isCacheEnabled: true,
 *   cacheTtl: 300,
 *   databaseConfig: {
 *     connectionString: 'https://project.supabase.co',
 *     tableName: 'feature_flags'
 *   }
 * };
 *
 * const result = FeatureFlagConfigValidator.validate(config);
 *
 * if (result.isValid) {
 *   console.log('Configuration is valid!');
 * } else {
 *   console.error('Configuration errors:', result.errors);
 * }
 * ```
 *
 * @example Error Handling
 * ```typescript
 * try {
 *   FeatureFlagConfigValidator.validateOrThrow(config);
 *   // Configuration is valid, proceed with initialization
 * } catch (error) {
 *   console.error('Invalid configuration:', error.message);
 *   process.exit(1);
 * }
 * ```
 */
export declare class FeatureFlagConfigValidator {
    /**
     * Validates feature flag configuration and returns detailed results
     *
     * @description Performs comprehensive validation of feature flag configuration,
     * checking all aspects including provider settings, cache configuration,
     * database connections, and environment-specific settings.
     *
     * @param {FeatureFlagEnvironmentConfig} config - Configuration object to validate
     * @returns {ValidationResult} Validation result with errors and warnings
     *
     * @example Successful Validation
     * ```typescript
     * const validConfig = {
     *   provider: 'memory',
     *   isCacheEnabled: true,
     *   cacheTtl: 300,
     *   refreshInterval: 60
     * };
     *
     * const result = FeatureFlagConfigValidator.validate(validConfig);
     * // result.isValid = true
     * // result.errors = []
     * // result.warnings = []
     * ```
     *
     * @example Validation with Errors
     * ```typescript
     * const invalidConfig = {
     *   provider: 'invalid_provider', // Error: invalid provider
     *   cacheTtl: -100,              // Error: negative TTL
     *   databaseConfig: {            // Error: missing connection string
     *     tableName: 'flags'
     *   }
     * };
     *
     * const result = FeatureFlagConfigValidator.validate(invalidConfig);
     * // result.isValid = false
     * // result.errors = [
     * //   { field: 'provider', message: 'Invalid provider...', code: 'INVALID_PROVIDER' },
     * //   { field: 'cacheTtl', message: 'Cache TTL must be non-negative', code: 'INVALID_CACHE_TTL' }
     * // ]
     * ```
     *
     * @example Validation with Warnings
     * ```typescript
     * const configWithWarnings = {
     *   provider: 'database',
     *   cacheTtl: 7200, // Warning: very high TTL
     *   isLoggingEnabled: true, // Warning: logging in production
     *   databaseConfig: {
     *     connectionString: 'https://project.supabase.co',
     *     tableName: 'feature_flags'
     *   }
     * };
     *
     * process.env.NODE_ENV = 'production';
     * const result = FeatureFlagConfigValidator.validate(configWithWarnings);
     * // result.isValid = true (warnings don't fail validation)
     * // result.warnings = [
     * //   { field: 'cacheTtl', message: 'Cache TTL is very high...', code: 'HIGH_CACHE_TTL' },
     * //   { field: 'isLoggingEnabled', message: 'Logging is enabled in production...', code: 'PRODUCTION_LOGGING_ENABLED' }
     * // ]
     * ```
     */
    static validate(config: CoreFeatureFlagEnvironmentConfig): CoreFeatureFlagValidationResult;
    private static validateProvider;
    private static validateCacheSettings;
    private static validateDatabaseConfig;
    private static validateConnectionString;
    private static validateTableName;
    private static validatePoolSize;
    private static validateTimeout;
    private static getWarnings;
    /**
     * Validates configuration and throws error if validation fails
     *
     * @description Convenience method that validates configuration and throws a detailed
     * error if validation fails. This is typically used during application startup
     * to ensure the system doesn't start with invalid configuration.
     *
     * @param {FeatureFlagEnvironmentConfig} config - Configuration to validate
     * @throws {DatabasePackageError} When validation fails with detailed error messages
     *
     * @example Startup Validation
     * ```typescript
     * // In FeatureFlagService.onModuleInit()
     * try {
     *   const config = FeatureFlagConfigFactory.fromOptions();
     *   FeatureFlagConfigValidator.validateOrThrow(config);
     *
     *   // Configuration is valid, proceed with initialization
     *   this.provider = FeatureFlagProviderFactory.create(config, FEATURES);
     *   await this.provider.initialize();
     * } catch (error) {
     *   this.logger.error('Configuration validation failed:', error.message);
     *   throw error; // Prevent service from starting
     * }
     * ```
     *
     * @example Error Output
     * ```typescript
     * // When validation fails, throws DatabasePackageError with message:
     * // "Configuration validation failed:
     * // provider: Invalid provider: invalid_type. Must be one of: memory, file, redis, api, database
     * // cacheTtl: Cache TTL must be non-negative
     * // databaseConfig.connectionString: Database connection string is required"
     * ```
     *
     * @example Environment Variable Validation
     * ```bash
     * # Missing required environment variables:
     * # SUPABASE_URL=  # Empty/missing
     * # FEATURE_FLAG_PROVIDER=database
     *
     * # Results in error:
     * # "Configuration validation failed:
     * # databaseConfig.connectionString: Database connection string is required"
     * ```
     */
    static validateOrThrow(config: CoreFeatureFlagEnvironmentConfig): void;
}
//# sourceMappingURL=validation.d.ts.map