/**
 * Platform Services Manager
 * Orchestrates platform services (MongoDB, SmartStorage, and others) and their resources
 */
import type { IPlatformResource, IPlatformService, IService, TPlatformServiceType } from '../../types.js';
import type { IPlatformServiceProvider } from './providers/base.js';
import type { Onebox } from '../onebox.js';
export declare class PlatformServicesManager {
    private oneboxRef;
    private providers;
    constructor(oneboxRef: Onebox);
    /**
     * Initialize the platform services manager
     */
    init(): Promise<void>;
    private reconcileLegacyServiceSecrets;
    /**
     * Register a platform service provider
     */
    registerProvider(provider: IPlatformServiceProvider): void;
    /**
     * Get a provider by type
     */
    getProvider(type: TPlatformServiceType): IPlatformServiceProvider | undefined;
    /**
     * Get all registered providers
     */
    getAllProviders(): IPlatformServiceProvider[];
    /**
     * Ensure a platform service is running, deploying it if necessary
     */
    ensureRunning(type: TPlatformServiceType): Promise<IPlatformService>;
    /**
     * Wait for a platform service to become healthy
     */
    private waitForHealthy;
    /**
     * Stop a platform service
     */
    stopPlatformService(type: TPlatformServiceType): Promise<void>;
    /**
     * Provision platform resources for a user service based on its requirements
     */
    private persistProvisionedResource;
    provisionForService(service: IService): Promise<Record<string, string>>;
    /**
     * Cleanup platform resources when a user service is deleted
     */
    cleanupForService(serviceId: number): Promise<void>;
    /**
     * Get injected environment variables for a service
     */
    getInjectedEnvVars(serviceId: number): Promise<Record<string, string>>;
    /**
     * Get all platform services with their status
     */
    getAllPlatformServices(): Promise<IPlatformService[]>;
    /**
     * One-time migration of every MinIO-backed bucket resource onto
     * smartstorage (corestore): provisions a scoped bucket per service,
     * stream-copies all objects, swaps the service env vars (container
     * recreate), and replaces the resource record. MinIO itself is left
     * running as rollback until it is decommissioned explicitly.
     */
    migrateS3ResourcesToSmartstorage(): Promise<{
        migrated: Array<{
            serviceName: string;
            oldBucket: string;
            newBucket: string;
            objectsCopied: number;
        }>;
        errors: string[];
    }>;
    /**
     * Stream-copies every object from one S3 bucket to another through the
     * host-published ports and verifies the object count afterwards.
     */
    private copyS3Bucket;
    /**
     * Get resources for a specific user service
     */
    getResourcesForService(serviceId: number): Promise<Array<{
        resource: IPlatformResource;
        platformService: IPlatformService;
        credentials: Record<string, string>;
    }>>;
}
