@flui-cloud/cli 0.0.1

package/lib/src/modules/infrastructure/clusters/clusters.service.js

@@ -0,0 +1,265 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var ClustersService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClustersService = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const kubernetes_service_1 = require("../shared/services/kubernetes.service");
+const build_job_service_1 = require("../../app-builds/services/build-job.service");
+const cluster_entity_1 = require("./entities/cluster.entity");
+// Import new modular services
+const cluster_validation_service_1 = require("./services/cluster-validation.service");
+const cluster_creation_service_1 = require("./services/cluster-creation.service");
+const cluster_deletion_service_1 = require("./services/cluster-deletion.service");
+const cluster_mapper_service_1 = require("./services/cluster-mapper.service");
+const cluster_operations_service_1 = require("./services/cluster-operations.service");
+const cluster_power_management_service_1 = require("./services/cluster-power-management.service");
+const encryption_service_1 = require("../../shared/encryption/services/encryption.service");
+/**
+ * Main orchestrator service for cluster operations
+ * Delegates to specialized services for better separation of concerns
+ */
+let ClustersService = ClustersService_1 = class ClustersService {
+    constructor(clusterRepository, clusterValidationService, clusterCreationService, clusterDeletionService, clusterMapperService, clusterOperationsService, clusterPowerManagementService, encryptionService, kubernetesService) {
+        this.clusterRepository = clusterRepository;
+        this.clusterValidationService = clusterValidationService;
+        this.clusterCreationService = clusterCreationService;
+        this.clusterDeletionService = clusterDeletionService;
+        this.clusterMapperService = clusterMapperService;
+        this.clusterOperationsService = clusterOperationsService;
+        this.clusterPowerManagementService = clusterPowerManagementService;
+        this.encryptionService = encryptionService;
+        this.kubernetesService = kubernetesService;
+        this.logger = new common_1.Logger(ClustersService_1.name);
+    }
+    /**
+     * Create a new K3s cluster
+     */
+    async createCluster(dto) {
+        // Validate request
+        await this.clusterValidationService.validateCreateClusterRequest(dto);
+        // Delegate to creation service
+        return await this.clusterCreationService.createCluster(dto);
+    }
+    /**
+     * Delete a cluster
+     */
+    async deleteCluster(clusterId, force = false) {
+        // Delegate to deletion service
+        return await this.clusterDeletionService.deleteCluster(clusterId, force);
+    }
+    /**
+     * Get cluster by ID
+     */
+    async getCluster(clusterId, includeRealStatus = false) {
+        const cluster = await this.clusterRepository.findOne({
+            where: { id: clusterId },
+            relations: ['nodes'],
+        });
+        if (!cluster) {
+            throw new common_1.NotFoundException(`Cluster ${clusterId} not found`);
+        }
+        // If real-time status is requested, enrich with provider data
+        if (includeRealStatus) {
+            return this.clusterPowerManagementService.enrichClusterWithRealStatus(cluster);
+        }
+        return this.clusterMapperService.mapToDto(cluster);
+    }
+    /**
+     * List all clusters (excluding deleted)
+     */
+    async listClusters() {
+        const clusters = await this.clusterRepository.find({
+            where: {
+                status: (0, typeorm_2.Not)(cluster_entity_1.ClusterStatus.DELETED),
+            },
+            relations: ['nodes'],
+            order: {
+                createdAt: 'DESC',
+            },
+        });
+        return this.clusterMapperService.mapToDtos(clusters);
+    }
+    /**
+     * Register an existing externally-managed cluster
+     */
+    async registerCluster(dto) {
+        return await this.clusterOperationsService.registerCluster(dto);
+    }
+    /**
+     * Get cluster entity by ID (for internal use)
+     */
+    async getClusterEntity(clusterId) {
+        const cluster = await this.clusterRepository.findOne({
+            where: { id: clusterId },
+            relations: ['nodes'],
+        });
+        if (!cluster) {
+            throw new common_1.NotFoundException(`Cluster ${clusterId} not found`);
+        }
+        return cluster;
+    }
+    /**
+     * Get kubeconfig for cluster
+     */
+    async getKubeconfig(clusterId) {
+        return await this.clusterOperationsService.getKubeconfig(clusterId);
+    }
+    /**
+     * Get cluster nodes
+     */
+    async getClusterNodes(clusterId) {
+        return await this.clusterOperationsService.getClusterNodes(clusterId);
+    }
+    /**
+     * Update cluster metadata
+     */
+    async updateClusterMetadata(clusterId, metadata) {
+        return await this.clusterOperationsService.updateClusterMetadata(clusterId, metadata);
+    }
+    /**
+     * Update node metadata
+     */
+    async updateNodeMetadata(clusterId, nodeId, metadata) {
+        return await this.clusterOperationsService.updateNodeMetadata(clusterId, nodeId, metadata);
+    }
+    /**
+     * Reconcile cluster tags (deprecated - stub implementation)
+     */
+    async reconcileClusterTags(clusterId, force, includeFirewalls) {
+        return await this.clusterOperationsService.reconcileClusterTags(clusterId, force, includeFirewalls);
+    }
+    /**
+     * Reconcile cluster firewalls (deprecated - use new desired-state API)
+     */
+    async reconcileClusterFirewalls(clusterId, options) {
+        return await this.clusterOperationsService.reconcileClusterFirewalls(clusterId, options);
+    }
+    /**
+     * Stop all servers in a cluster (async operation)
+     */
+    async stopCluster(clusterId) {
+        return await this.clusterPowerManagementService.stopClusterAsync(clusterId);
+    }
+    /**
+     * Start all servers in a cluster (async operation)
+     */
+    async startCluster(clusterId) {
+        return await this.clusterPowerManagementService.startClusterAsync(clusterId);
+    }
+    /**
+     * Reconcile cluster status with real provider state
+     */
+    async reconcileClusterStatus(clusterId, autoFix = false) {
+        return await this.clusterPowerManagementService.reconcileClusterStatus(clusterId, autoFix);
+    }
+    /**
+     * Check whether a cluster has sufficient resources for a new deployment.
+     *
+     * @param clusterId      - Target cluster UUID
+     * @param cpuRequest     - CPU request in millicores (e.g. 250 for "250m")
+     * @param memoryRequest  - Memory request in mebibytes (e.g. 256 for "256Mi")
+     * @param replicas       - Number of replicas (default 1)
+     * @param profileName    - Human-readable profile name for the response (optional)
+     */
+    async checkResourceAvailability(clusterId, cpuRequest, memoryRequest, replicas = 1, profileName = null) {
+        const cluster = await this.clusterRepository.findOne({
+            where: { id: clusterId },
+        });
+        if (!cluster) {
+            throw new common_1.NotFoundException(`Cluster ${clusterId} not found`);
+        }
+        const kubeconfig = await this.getKubeconfig(clusterId);
+        const [total, used] = await Promise.all([
+            this.kubernetesService.getNodeAllocatable(kubeconfig),
+            this.kubernetesService.getPodResourceRequests(kubeconfig),
+        ]);
+        // Apply 10% safety margin
+        const availableCpu = Math.floor(total.cpu * 0.9) - used.cpu;
+        const availableMemory = Math.floor(total.memory * 0.9) - used.memory;
+        const requiredCpu = cpuRequest * replicas;
+        const requiredMemory = memoryRequest * replicas;
+        const hasEnoughCpu = availableCpu >= requiredCpu;
+        const hasEnoughMemory = availableMemory >= requiredMemory;
+        const autoscalingEnabled = cluster.autoscalingEnabled ?? false;
+        let canDeploy;
+        let reason = null;
+        if (hasEnoughCpu && hasEnoughMemory) {
+            canDeploy = true;
+        }
+        else if (autoscalingEnabled) {
+            canDeploy = true;
+            reason = 'autoscaling_pending';
+        }
+        else {
+            canDeploy = false;
+            reason = 'insufficient_resources';
+        }
+        const formatCpu = (mc) => `${mc}m`;
+        const formatMem = (mi) => mi >= 1024 ? `${(mi / 1024).toFixed(1).replace('.0', '')}Gi` : `${mi}Mi`;
+        return {
+            canDeploy,
+            reason,
+            profile: profileName,
+            required: {
+                cpu: formatCpu(requiredCpu),
+                memory: formatMem(requiredMemory),
+            },
+            available: {
+                cpu: formatCpu(Math.max(availableCpu, 0)),
+                memory: formatMem(Math.max(availableMemory, 0)),
+            },
+            total: { cpu: formatCpu(total.cpu), memory: formatMem(total.memory) },
+            used: { cpu: formatCpu(used.cpu), memory: formatMem(used.memory) },
+            autoscalingEnabled,
+        };
+    }
+    async getBuildResources(clusterId) {
+        const check = await this.checkResourceAvailability(clusterId, build_job_service_1.BUILD_JOB_CPU_REQUEST, build_job_service_1.BUILD_JOB_MEMORY_REQUEST);
+        let status;
+        if (check.canDeploy && check.reason === null) {
+            status = 'ok';
+        }
+        else if (check.autoscalingEnabled) {
+            status = 'autoscaling_required';
+        }
+        else {
+            status = 'insufficient';
+        }
+        return {
+            status,
+            required: check.required,
+            available: check.available,
+            total: check.total,
+            used: check.used,
+            autoscalingEnabled: check.autoscalingEnabled,
+        };
+    }
+};
+exports.ClustersService = ClustersService;
+exports.ClustersService = ClustersService = ClustersService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(cluster_entity_1.ClusterEntity)),
+    __metadata("design:paramtypes", [typeorm_2.Repository,
+        cluster_validation_service_1.ClusterValidationService,
+        cluster_creation_service_1.ClusterCreationService,
+        cluster_deletion_service_1.ClusterDeletionService,
+        cluster_mapper_service_1.ClusterMapperService,
+        cluster_operations_service_1.ClusterOperationsService,
+        cluster_power_management_service_1.ClusterPowerManagementService,
+        encryption_service_1.EncryptionService,
+        kubernetes_service_1.KubernetesService])
+], ClustersService);

package/lib/src/modules/infrastructure/clusters/constants/storage-conventions.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Storage conventions for Flui workload clusters.
+ *
+ * Architecture (decided 2026-05-10, see APPLICATION_SCALING_AND_RESOURCE_MANAGEMENT.md §14):
+ *
+ *   Master VM
+ *   ├── nfs-kernel-server (NFSv4 export)
+ *   └── Volume Flui-managed (provider block storage, attached, ext4)
+ *       └── Mounted at FLUI_SHARED_STORAGE_PATH
+ *
+ *   Worker VM
+ *   ├── cachefilesd (read-cache to local NVMe)
+ *   └── NFS mount of master:FLUI_SHARED_STORAGE_PATH at the same path
+ *
+ *   local-path-provisioner is reconfigured to write to FLUI_SHARED_STORAGE_PATH
+ *   on every node, so PVCs of catalog apps with `storageClassName=flui-shared`
+ *   become subdirectories on the master's Volume — visible from any worker.
+ */
+/** Mountpoint on every node where the shared NFS volume lives. */
+export declare const FLUI_SHARED_STORAGE_PATH = "/var/lib/flui/storage";
+/** Local NVMe path on workers used by cachefilesd. */
+export declare const FLUI_FSCACHE_PATH = "/var/cache/fscache";
+/** Default size of the master's backing Volume in GB. */
+export declare const FLUI_SHARED_VOLUME_DEFAULT_SIZE_GB = 20;
+/**
+ * Storage classes exposed by Flui to catalog manifests.
+ * `flui-shared` is the default for non-database catalog apps.
+ * `flui-dedicated` is for catalog apps that opt out of NFS (databases).
+ * `flui-local` is the legacy/fallback path on bundled disk (no Flui-managed Volume).
+ */
+export declare enum FluiStorageClass {
+    SHARED = "flui-shared",
+    DEDICATED = "flui-dedicated",
+    LOCAL = "flui-local"
+}
+/** Filesystem label applied to the Flui-managed Volume by the bootstrap script. */
+export declare const FLUI_SHARED_VOLUME_FS_LABEL = "flui-data";
+/** Default cache size on workers (GB) for cachefilesd. */
+export declare const FLUI_FSCACHE_DEFAULT_SIZE_GB = 5;
+/**
+ * NFS export options used on the master.
+ * - rw: writable from clients
+ * - async: server doesn't fsync each write — drastically improves write IOPS,
+ *   acceptable risk because the master also has the Volume locally and the
+ *   catalog apps that go on shared storage are not write-critical (databases
+ *   use `flui-dedicated` instead).
+ * - no_subtree_check: speedup, standard for whole-volume exports.
+ * - no_root_squash: K3s containerd runs as root inside containers — without
+ *   this, file ownership inside containers becomes nobody:nogroup.
+ */
+export declare const NFS_EXPORT_OPTIONS = "rw,async,no_subtree_check,no_root_squash";
+/**
+ * NFS mount options used on workers.
+ * - vers=4.2: full POSIX locking and modern features
+ * - bg: keep retrying in background if master temporarily unreachable
+ * - fsc: enable fscache
+ * - async: client batches writes
+ * - hard: block on outage rather than returning EIO (combined with bg)
+ */
+export declare const NFS_MOUNT_OPTIONS = "vers=4.2,bg,fsc,async,hard,_netdev";

package/lib/src/modules/infrastructure/clusters/constants/storage-conventions.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * Storage conventions for Flui workload clusters.
+ *
+ * Architecture (decided 2026-05-10, see APPLICATION_SCALING_AND_RESOURCE_MANAGEMENT.md §14):
+ *
+ *   Master VM
+ *   ├── nfs-kernel-server (NFSv4 export)
+ *   └── Volume Flui-managed (provider block storage, attached, ext4)
+ *       └── Mounted at FLUI_SHARED_STORAGE_PATH
+ *
+ *   Worker VM
+ *   ├── cachefilesd (read-cache to local NVMe)
+ *   └── NFS mount of master:FLUI_SHARED_STORAGE_PATH at the same path
+ *
+ *   local-path-provisioner is reconfigured to write to FLUI_SHARED_STORAGE_PATH
+ *   on every node, so PVCs of catalog apps with `storageClassName=flui-shared`
+ *   become subdirectories on the master's Volume — visible from any worker.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NFS_MOUNT_OPTIONS = exports.NFS_EXPORT_OPTIONS = exports.FLUI_FSCACHE_DEFAULT_SIZE_GB = exports.FLUI_SHARED_VOLUME_FS_LABEL = exports.FluiStorageClass = exports.FLUI_SHARED_VOLUME_DEFAULT_SIZE_GB = exports.FLUI_FSCACHE_PATH = exports.FLUI_SHARED_STORAGE_PATH = void 0;
+/** Mountpoint on every node where the shared NFS volume lives. */
+exports.FLUI_SHARED_STORAGE_PATH = '/var/lib/flui/storage';
+/** Local NVMe path on workers used by cachefilesd. */
+exports.FLUI_FSCACHE_PATH = '/var/cache/fscache';
+/** Default size of the master's backing Volume in GB. */
+exports.FLUI_SHARED_VOLUME_DEFAULT_SIZE_GB = 20;
+/**
+ * Storage classes exposed by Flui to catalog manifests.
+ * `flui-shared` is the default for non-database catalog apps.
+ * `flui-dedicated` is for catalog apps that opt out of NFS (databases).
+ * `flui-local` is the legacy/fallback path on bundled disk (no Flui-managed Volume).
+ */
+var FluiStorageClass;
+(function (FluiStorageClass) {
+    FluiStorageClass["SHARED"] = "flui-shared";
+    FluiStorageClass["DEDICATED"] = "flui-dedicated";
+    FluiStorageClass["LOCAL"] = "flui-local";
+})(FluiStorageClass || (exports.FluiStorageClass = FluiStorageClass = {}));
+/** Filesystem label applied to the Flui-managed Volume by the bootstrap script. */
+exports.FLUI_SHARED_VOLUME_FS_LABEL = 'flui-data';
+/** Default cache size on workers (GB) for cachefilesd. */
+exports.FLUI_FSCACHE_DEFAULT_SIZE_GB = 5;
+/**
+ * NFS export options used on the master.
+ * - rw: writable from clients
+ * - async: server doesn't fsync each write — drastically improves write IOPS,
+ *   acceptable risk because the master also has the Volume locally and the
+ *   catalog apps that go on shared storage are not write-critical (databases
+ *   use `flui-dedicated` instead).
+ * - no_subtree_check: speedup, standard for whole-volume exports.
+ * - no_root_squash: K3s containerd runs as root inside containers — without
+ *   this, file ownership inside containers becomes nobody:nogroup.
+ */
+exports.NFS_EXPORT_OPTIONS = 'rw,async,no_subtree_check,no_root_squash';
+/**
+ * NFS mount options used on workers.
+ * - vers=4.2: full POSIX locking and modern features
+ * - bg: keep retrying in background if master temporarily unreachable
+ * - fsc: enable fscache
+ * - async: client batches writes
+ * - hard: block on outage rather than returning EIO (combined with bg)
+ */
+exports.NFS_MOUNT_OPTIONS = 'vers=4.2,bg,fsc,async,hard,_netdev';

package/lib/src/modules/infrastructure/clusters/dto/build-resources.dto.d.ts

@@ -0,0 +1,19 @@
+export type BuildResourceStatus = 'ok' | 'autoscaling_required' | 'insufficient';
+export declare class ResourceAmountDto {
+    cpu: string;
+    memory: string;
+}
+export declare class BuildResourcesResponseDto {
+    /**
+     * Synthetic status the frontend uses to decide which UI state to render:
+     *   - ok                  → enough resources, proceed
+     *   - autoscaling_required → not enough now, autoscaling will add a node
+     *   - insufficient        → not enough, autoscaling disabled — user must act
+     */
+    status: BuildResourceStatus;
+    required: ResourceAmountDto;
+    available: ResourceAmountDto;
+    total: ResourceAmountDto;
+    used: ResourceAmountDto;
+    autoscalingEnabled: boolean;
+}

package/lib/src/modules/infrastructure/clusters/dto/build-resources.dto.js

@@ -0,0 +1,69 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildResourcesResponseDto = exports.ResourceAmountDto = void 0;
+const swagger_1 = require("@nestjs/swagger");
+class ResourceAmountDto {
+}
+exports.ResourceAmountDto = ResourceAmountDto;
+__decorate([
+    (0, swagger_1.ApiProperty)({ example: '800m' }),
+    __metadata("design:type", String)
+], ResourceAmountDto.prototype, "cpu", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ example: '896Mi' }),
+    __metadata("design:type", String)
+], ResourceAmountDto.prototype, "memory", void 0);
+class BuildResourcesResponseDto {
+}
+exports.BuildResourcesResponseDto = BuildResourcesResponseDto;
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        enum: ['ok', 'autoscaling_required', 'insufficient'],
+        example: 'ok',
+    }),
+    __metadata("design:type", String)
+], BuildResourcesResponseDto.prototype, "status", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        type: ResourceAmountDto,
+        description: 'Fixed resources required by the build job',
+    }),
+    __metadata("design:type", ResourceAmountDto)
+], BuildResourcesResponseDto.prototype, "required", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        type: ResourceAmountDto,
+        description: 'Resources currently available (after 10% safety margin)',
+    }),
+    __metadata("design:type", ResourceAmountDto)
+], BuildResourcesResponseDto.prototype, "available", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        type: ResourceAmountDto,
+        description: 'Total allocatable resources across all ready nodes',
+    }),
+    __metadata("design:type", ResourceAmountDto)
+], BuildResourcesResponseDto.prototype, "total", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        type: ResourceAmountDto,
+        description: 'Resources already requested by running pods',
+    }),
+    __metadata("design:type", ResourceAmountDto)
+], BuildResourcesResponseDto.prototype, "used", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        example: false,
+        description: 'Whether the cluster has autoscaling enabled',
+    }),
+    __metadata("design:type", Boolean)
+], BuildResourcesResponseDto.prototype, "autoscalingEnabled", void 0);

package/lib/src/modules/infrastructure/clusters/dto/cluster-capacity-plan.dto.d.ts

@@ -0,0 +1,36 @@
+export declare class CapacityMasterDto {
+    nodeName: string;
+    serverType: string;
+    allocatableCpuMillicores: number;
+    allocatableMemoryMi: number;
+    usedCpuMillicores: number;
+    usedMemoryMi: number;
+    freeCpuMillicores: number;
+    freeMemoryMi: number;
+    monthlyCostEur?: string;
+}
+export declare class CapacityCandidateDto {
+    name: string;
+    direction: 'upgrade' | 'downgrade' | 'current';
+    cores: number;
+    memoryGb: number;
+    diskGb: number;
+    monthlyCostEur: string;
+    monthlyDeltaEur: string;
+    cpuType: 'shared' | 'dedicated';
+    deprecated: boolean;
+}
+export declare class CapacityStorageDto {
+    volumeId: string;
+    sizeGb: number;
+    requestedGb?: number;
+    pricePerGbMonthlyEur?: string;
+}
+export declare class ClusterCapacityPlanDto {
+    clusterId: string;
+    provider: string;
+    master?: CapacityMasterDto;
+    candidates: CapacityCandidateDto[];
+    storage?: CapacityStorageDto;
+    message?: string;
+}

package/lib/src/modules/infrastructure/clusters/dto/cluster-capacity-plan.dto.js

@@ -0,0 +1,149 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClusterCapacityPlanDto = exports.CapacityStorageDto = exports.CapacityCandidateDto = exports.CapacityMasterDto = void 0;
+const swagger_1 = require("@nestjs/swagger");
+class CapacityMasterDto {
+}
+exports.CapacityMasterDto = CapacityMasterDto;
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", String)
+], CapacityMasterDto.prototype, "nodeName", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ description: 'Provider server type (e.g. cx22, DEV1-S)' }),
+    __metadata("design:type", String)
+], CapacityMasterDto.prototype, "serverType", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ description: 'Allocatable CPU in millicores' }),
+    __metadata("design:type", Number)
+], CapacityMasterDto.prototype, "allocatableCpuMillicores", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ description: 'Allocatable memory in MiB' }),
+    __metadata("design:type", Number)
+], CapacityMasterDto.prototype, "allocatableMemoryMi", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        description: 'Sum of pod CPU requests on master in millicores',
+    }),
+    __metadata("design:type", Number)
+], CapacityMasterDto.prototype, "usedCpuMillicores", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ description: 'Sum of pod memory requests on master in MiB' }),
+    __metadata("design:type", Number)
+], CapacityMasterDto.prototype, "usedMemoryMi", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", Number)
+], CapacityMasterDto.prototype, "freeCpuMillicores", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", Number)
+], CapacityMasterDto.prototype, "freeMemoryMi", void 0);
+__decorate([
+    (0, swagger_1.ApiPropertyOptional)({
+        description: 'Monthly cost of current server type in EUR (net)',
+    }),
+    __metadata("design:type", String)
+], CapacityMasterDto.prototype, "monthlyCostEur", void 0);
+class CapacityCandidateDto {
+}
+exports.CapacityCandidateDto = CapacityCandidateDto;
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", String)
+], CapacityCandidateDto.prototype, "name", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ enum: ['upgrade', 'downgrade', 'current'] }),
+    __metadata("design:type", String)
+], CapacityCandidateDto.prototype, "direction", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ description: 'Cores' }),
+    __metadata("design:type", Number)
+], CapacityCandidateDto.prototype, "cores", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ description: 'Memory in GB' }),
+    __metadata("design:type", Number)
+], CapacityCandidateDto.prototype, "memoryGb", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ description: 'Local disk in GB' }),
+    __metadata("design:type", Number)
+], CapacityCandidateDto.prototype, "diskGb", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ description: 'Monthly price EUR (net)' }),
+    __metadata("design:type", String)
+], CapacityCandidateDto.prototype, "monthlyCostEur", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        description: 'Monthly price delta vs current type in EUR (net). Negative = cheaper.',
+    }),
+    __metadata("design:type", String)
+], CapacityCandidateDto.prototype, "monthlyDeltaEur", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ enum: ['shared', 'dedicated'] }),
+    __metadata("design:type", String)
+], CapacityCandidateDto.prototype, "cpuType", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ description: 'True if deprecated by the provider' }),
+    __metadata("design:type", Boolean)
+], CapacityCandidateDto.prototype, "deprecated", void 0);
+class CapacityStorageDto {
+}
+exports.CapacityStorageDto = CapacityStorageDto;
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", String)
+], CapacityStorageDto.prototype, "volumeId", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", Number)
+], CapacityStorageDto.prototype, "sizeGb", void 0);
+__decorate([
+    (0, swagger_1.ApiPropertyOptional)({
+        description: 'Sum of PVC requests bound to flui-shared in GB',
+    }),
+    __metadata("design:type", Number)
+], CapacityStorageDto.prototype, "requestedGb", void 0);
+__decorate([
+    (0, swagger_1.ApiPropertyOptional)({
+        description: 'Monthly cost per additional GB in EUR (net), if the provider charges by volume size.',
+    }),
+    __metadata("design:type", String)
+], CapacityStorageDto.prototype, "pricePerGbMonthlyEur", void 0);
+class ClusterCapacityPlanDto {
+}
+exports.ClusterCapacityPlanDto = ClusterCapacityPlanDto;
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", String)
+], ClusterCapacityPlanDto.prototype, "clusterId", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", String)
+], ClusterCapacityPlanDto.prototype, "provider", void 0);
+__decorate([
+    (0, swagger_1.ApiPropertyOptional)({ type: CapacityMasterDto }),
+    __metadata("design:type", CapacityMasterDto)
+], ClusterCapacityPlanDto.prototype, "master", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ type: [CapacityCandidateDto] }),
+    __metadata("design:type", Array)
+], ClusterCapacityPlanDto.prototype, "candidates", void 0);
+__decorate([
+    (0, swagger_1.ApiPropertyOptional)({ type: CapacityStorageDto }),
+    __metadata("design:type", CapacityStorageDto)
+], ClusterCapacityPlanDto.prototype, "storage", void 0);
+__decorate([
+    (0, swagger_1.ApiPropertyOptional)({
+        description: 'Explanation if some data could not be resolved (e.g. provider does not expose pricing).',
+    }),
+    __metadata("design:type", String)
+], ClusterCapacityPlanDto.prototype, "message", void 0);