import { ProviderDefinitionsService } from './provider-definitions.service';
import { ConfigurationModeService } from './configuration-mode.service';
import { ProviderConfigurationRepository } from '../repositories/provider-configuration.repository';
import { AccessService } from '../../access/services/access.service';
import { CloudProvider } from '../../providers/enums/cloud-provider.enum';
import { ProviderDefinition } from '../entities/provider-definition.entity';
import { ProviderConfigurationDto } from '../dto/provider-configuration.dto';
import { ConfigureProviderDto } from '../dto/configure-provider.dto';
import { ProviderFiltersDto } from '../dto/provider-filters.dto';
import { ValidationResultDto } from '../dto/validation-result.dto';
import { HealthStatusDto } from '../dto/health-status.dto';
import { ProviderCredentialsDto } from '../dto/credentials.dto';
import { ProviderFactory } from '../../../modules/providers/services/provider.factory';
import { CapabilitiesProviderFactory } from '../../../modules/providers/core/factories/capabilities-provider.factory';
import { NodeSizeOptionDto } from '../dto/node-size-option.dto';
import { PricingQueryDto } from '../dto/pricing-query.dto';
import { PricingResponseDto } from '../dto/pricing-response.dto';
import { CacheService } from '../../../modules/common/cache/cache.service';
export declare class ManagementService {
    private readonly providerDefinitions;
    private readonly configurationMode;
    private readonly providerConfigRepo;
    private readonly accessService;
    private readonly providerFactory;
    private readonly capabilitiesFactory;
    private readonly cacheService;
    private readonly logger;
    constructor(providerDefinitions: ProviderDefinitionsService, configurationMode: ConfigurationModeService, providerConfigRepo: ProviderConfigurationRepository, accessService: AccessService, providerFactory: ProviderFactory, capabilitiesFactory: CapabilitiesProviderFactory, cacheService: CacheService);
    getAvailableProviders(): Promise<ProviderDefinition[]>;
    getProvider(provider: CloudProvider): Promise<ProviderDefinition>;
    getProviderLogo(provider: CloudProvider): {
        data: Buffer;
        contentType: string;
    };
    getUserProviderConfigurations(filters?: ProviderFiltersDto): Promise<ProviderConfigurationDto[]>;
    getProviderConfiguration(provider: CloudProvider): Promise<ProviderConfigurationDto>;
    configureProvider(configDto: ConfigureProviderDto): Promise<ProviderConfigurationDto>;
    validateProvider(provider: CloudProvider, credentials: ProviderCredentialsDto): Promise<ValidationResultDto>;
    enableProvider(provider: CloudProvider, enabled: boolean): Promise<ProviderConfigurationDto>;
    getProviderHealth(provider: CloudProvider): Promise<HealthStatusDto>;
    getProviderRegions(provider: CloudProvider): Promise<import("../entities/provider-region.entity").ProviderRegion[]>;
    getProviderInstanceTypes(provider: CloudProvider): Promise<import("../../providers/interfaces/provider-capabilities.interface").InstanceTypeInfo[]>;
    getConfigurationMode(): Promise<{
        mode: import("./configuration-mode.service").ConfigurationMode;
        capabilities: import("./configuration-mode.service").ConfigurationCapabilities;
    }>;
    private enrichConfigurationsWithProviderData;
    rotateProviderCredentials(provider: CloudProvider, credentials: ProviderCredentialsDto): Promise<ProviderConfigurationDto>;
    updateProviderCredentialsExpiry(provider: CloudProvider, expiresAt: Date | null): Promise<ProviderConfigurationDto>;
    updateProviderRegions(provider: CloudProvider, enabledRegions: string[]): Promise<ProviderConfigurationDto>;
    private storeProviderCredentials;
    private validateProviderCredentials;
    private getMaskedCredentials;
    removeProviderConfiguration(configId: string): Promise<void>;
    /**
     * Get available node sizes (server types) for a provider
     * Uses partial caching strategy:
     * - Server type metadata (CPU, RAM, prices, etc.) is cached for 24 hours
     * - Real-time availability is ALWAYS fetched fresh (not cached)
     * Optionally filtered by region to show only available server types in that location
     */
    getNodeSizes(provider: CloudProvider, region?: string, skipCache?: boolean): Promise<NodeSizeOptionDto[]>;
    /**
     * Get pricing information for a provider
     * Cached for 24 hours (CONFIGURATION category)
     */
    getPricing(provider: CloudProvider, query: PricingQueryDto, skipCache?: boolean): Promise<PricingResponseDto>;
    /**
     * Clear node sizes cache for a specific provider
     */
    clearNodeSizesCache(provider: CloudProvider): Promise<void>;
}
