@flui-cloud/cli 0.0.1

package/lib/src/modules/providers/implementations/scaleway/scaleway-instances.adapter.js

@@ -0,0 +1,289 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var ScalewayInstancesAdapter_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScalewayInstancesAdapter = exports.INSTANCE_ZONES = void 0;
+const common_1 = require("@nestjs/common");
+const axios_1 = __importDefault(require("axios"));
+const instances_1 = require("./generated/instances");
+exports.INSTANCE_ZONES = [
+    instances_1.CreateServerZoneEnum.FrPar1,
+    instances_1.CreateServerZoneEnum.FrPar2,
+    instances_1.CreateServerZoneEnum.FrPar3,
+    instances_1.CreateServerZoneEnum.NlAms1,
+    instances_1.CreateServerZoneEnum.NlAms2,
+    instances_1.CreateServerZoneEnum.NlAms3,
+    instances_1.CreateServerZoneEnum.PlWaw1,
+    instances_1.CreateServerZoneEnum.PlWaw2,
+    instances_1.CreateServerZoneEnum.PlWaw3,
+];
+let ScalewayInstancesAdapter = ScalewayInstancesAdapter_1 = class ScalewayInstancesAdapter {
+    constructor() {
+        this.logger = new common_1.Logger(ScalewayInstancesAdapter_1.name);
+        this.baseUrl = 'https://api.scaleway.com';
+        this.timeout = 15000;
+    }
+    createAxiosInstance() {
+        return axios_1.default.create({
+            timeout: this.timeout,
+            headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+                'User-Agent': 'Flui-Cloud-API/1.0',
+            },
+            validateStatus: (status) => status >= 200 && status < 300,
+        });
+    }
+    createConfiguration(token) {
+        return new instances_1.Configuration({
+            basePath: this.baseUrl,
+            baseOptions: {
+                headers: {
+                    'X-Auth-Token': token,
+                    'User-Agent': 'Flui-Cloud-API/1.0',
+                    'Content-Type': 'application/json',
+                    Accept: 'application/json',
+                },
+            },
+        });
+    }
+    createInstancesApi(token) {
+        return new instances_1.InstancesApi(this.createConfiguration(token), this.baseUrl, this.createAxiosInstance());
+    }
+    createInstanceTypesApi(token) {
+        return new instances_1.InstanceTypesApi(this.createConfiguration(token), this.baseUrl, this.createAxiosInstance());
+    }
+    createSecurityGroupsApi(token) {
+        return new instances_1.SecurityGroupsApi(this.createConfiguration(token), this.baseUrl, this.createAxiosInstance());
+    }
+    createPrivateNicsApi(token) {
+        return new instances_1.PrivateNICsApi(this.createConfiguration(token), this.baseUrl, this.createAxiosInstance());
+    }
+    /**
+     * Resolve a Scaleway IPAM IP UUID to its inline address (e.g. "10.10.1.3").
+     * IPv6 addresses are filtered out — callers want the v4 used by K3s join.
+     */
+    async resolveIpamIpv4(token, region, ipId) {
+        const url = `${this.baseUrl}/ipam/v1/regions/${region}/ips/${ipId}`;
+        try {
+            const resp = await this.createAxiosInstance().get(url, {
+                headers: { 'X-Auth-Token': token },
+            });
+            const data = resp.data;
+            if (!data?.address || data.is_ipv6)
+                return null;
+            // Scaleway returns "10.10.1.3/24" — strip prefix length.
+            return data.address.split('/')[0];
+        }
+        catch (err) {
+            this.logger.warn(`[Scaleway] IPAM lookup ${ipId} failed: ${err.message}`);
+            return null;
+        }
+    }
+    /**
+     * Resolve the IPv4 address of the first NIC attached to a Private Network.
+     * Returns null if the server has no NIC or IPAM hasn't allocated an IPv4 yet.
+     */
+    async getInstancePrivateIp(token, zone, server) {
+        const nics = server.private_nics ?? [];
+        if (nics.length === 0)
+            return null;
+        const region = zone.replace(/-\d+$/, '');
+        for (const nic of nics) {
+            const inline = nic.private_ip;
+            if (inline)
+                return String(inline);
+            const ipIds = nic.ipam_ip_ids ?? [];
+            for (const ipId of ipIds) {
+                const ipv4 = await this.resolveIpamIpv4(token, region, ipId);
+                if (ipv4)
+                    return ipv4;
+            }
+        }
+        return null;
+    }
+    /**
+     * Attach a Scaleway Instance to a Private Network by creating a Private NIC.
+     * Idempotent: returns the existing NIC if one already attaches the server to
+     * the same private network.
+     */
+    async attachToPrivateNetwork(token, zone, serverId, privateNetworkId) {
+        const api = this.createPrivateNicsApi(token);
+        const list = await api.listPrivateNICs(zone, serverId);
+        const existing = (list.data?.private_nics ?? []).find((n) => n.private_network_id === privateNetworkId);
+        if (existing) {
+            this.logger.log(`[Scaleway] Server ${serverId} already attached to private network ${privateNetworkId} (NIC ${existing.id})`);
+            return existing;
+        }
+        const resp = await api.createPrivateNIC(zone, serverId, { private_network_id: privateNetworkId });
+        const nic = resp.data?.private_nic;
+        if (!nic) {
+            throw new Error(`createPrivateNIC for server ${serverId} returned no NIC payload`);
+        }
+        this.logger.log(`[Scaleway] Attached server ${serverId} to private network ${privateNetworkId} (NIC ${nic.id})`);
+        return nic;
+    }
+    // ─── Server methods ────────────────────────────────────────────────────────
+    async listServers(token, zone) {
+        const api = this.createInstancesApi(token);
+        const allServers = [];
+        let page = 1;
+        const perPage = 50;
+        while (true) {
+            const response = await api.listServers(zone, perPage, page);
+            const servers = response.data.servers || [];
+            allServers.push(...servers);
+            const totalCount = Number.parseInt(response.headers?.['x-total-count'] || '0', 10);
+            if (allServers.length >= totalCount || servers.length < perPage) {
+                break;
+            }
+            page++;
+        }
+        return allServers;
+    }
+    async getServer(token, zone, serverId) {
+        const api = this.createInstancesApi(token);
+        const response = await api.getServer(zone, serverId);
+        return response.data.server || null;
+    }
+    async createServer(token, zone, payload) {
+        const api = this.createInstancesApi(token);
+        const response = await api.createServer(zone, payload);
+        return response.data.server;
+    }
+    async deleteServer(token, zone, serverId) {
+        // Scaleway instances must be terminated via the 'terminate' action, not the DELETE API.
+        // The DELETE API returns 400 if the server is not in 'stopped' state.
+        // The 'terminate' action works from any state (running, stopped, etc.) and also deallocates volumes.
+        await this.serverAction(token, zone, serverId, instances_1.ServerActionRequestActionEnum.Terminate);
+    }
+    async serverAction(token, zone, serverId, action) {
+        const api = this.createInstancesApi(token);
+        const request = { action };
+        await api.serverAction(zone, serverId, request);
+    }
+    async updateServerTags(token, zone, serverId, tags) {
+        const api = this.createInstancesApi(token);
+        const request = { tags };
+        await api.updateServer(zone, serverId, request);
+    }
+    /**
+     * Change the commercial_type of a stopped Instance. Scaleway constraints:
+     * - server must be in `stopped` state
+     * - cannot be in a placement group
+     * - cross-OS family (Linux↔Windows) not allowed
+     * - local-storage requirements of the target type must be satisfied
+     *
+     * The caller is responsible for stopping the server beforehand and for
+     * starting it after. Returns when the API accepts the request; the change
+     * is applied during the next power-on.
+     */
+    async updateServerCommercialType(token, zone, serverId, commercialType) {
+        const api = this.createInstancesApi(token);
+        const request = { commercial_type: commercialType };
+        await api.updateServer(zone, serverId, request);
+    }
+    async listServerTypes(token, zone) {
+        const api = this.createInstanceTypesApi(token);
+        const response = await api.listServersTypes(zone);
+        const serversMap = response.data.servers;
+        if (!serversMap)
+            return [];
+        return Object.entries(serversMap).map(([name, type]) => ({
+            ...type,
+            name,
+        }));
+    }
+    // ─── User data (cloud-init) ────────────────────────────────────────────────
+    /**
+     * Set cloud-init user data on an instance.
+     * The generated UserDataApi uses the browser File type — bypass with raw axios.
+     */
+    async setUserData(token, zone, serverId, cloudInit) {
+        const url = `https://api.scaleway.com/instance/v1/zones/${zone}/servers/${serverId}/user_data/cloud-init`;
+        await axios_1.default.patch(url, cloudInit, {
+            headers: {
+                'X-Auth-Token': token,
+                'Content-Type': 'text/plain',
+            },
+            timeout: this.timeout,
+        });
+    }
+    // ─── Security Group methods ────────────────────────────────────────────────
+    async createSecurityGroup(token, zone, payload) {
+        const api = this.createSecurityGroupsApi(token);
+        try {
+            const response = await api.createSecurityGroup(zone, payload);
+            return response.data.security_group;
+        }
+        catch (error) {
+            this.logger.error(`createSecurityGroup 400 body: ${JSON.stringify(error?.response?.data)}`);
+            throw error;
+        }
+    }
+    async getSecurityGroup(token, zone, sgId) {
+        try {
+            const api = this.createSecurityGroupsApi(token);
+            const response = await api.getSecurityGroup(zone, sgId);
+            return response.data.security_group || null;
+        }
+        catch (error) {
+            if (error?.response?.status === 404)
+                return null;
+            throw error;
+        }
+    }
+    async listSecurityGroups(token, zone) {
+        const api = this.createSecurityGroupsApi(token);
+        const response = await api.listSecurityGroups(zone);
+        return response.data.security_groups || [];
+    }
+    async listSecurityGroupRules(token, zone, sgId) {
+        const api = this.createSecurityGroupsApi(token);
+        const all = [];
+        let page = 1;
+        // Scaleway paginates rules; per_page maxes at 100.
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const response = await api.listSecurityGroupRules(zone, sgId, 100, page);
+            const rules = response.data.rules || [];
+            all.push(...rules);
+            if (rules.length < 100)
+                break;
+            page++;
+        }
+        return all;
+    }
+    async setSecurityGroupRules(token, zone, sgId, rules) {
+        const api = this.createSecurityGroupsApi(token);
+        const request = { rules };
+        await api.setSecurityGroupRules(zone, sgId, request);
+    }
+    async deleteSecurityGroup(token, zone, sgId) {
+        const api = this.createSecurityGroupsApi(token);
+        await api.deleteSecurityGroup(zone, sgId);
+    }
+    async applySecurityGroupToServer(token, zone, serverId, sgId) {
+        const api = this.createInstancesApi(token);
+        const securityGroup = { id: sgId };
+        const request = { security_group: securityGroup };
+        await api.updateServer(zone, serverId, request);
+    }
+    async removeSecurityGroupFromServer(token, zone, serverId) {
+        const api = this.createInstancesApi(token);
+        const request = { security_group: undefined };
+        await api.updateServer(zone, serverId, request);
+    }
+};
+exports.ScalewayInstancesAdapter = ScalewayInstancesAdapter;
+exports.ScalewayInstancesAdapter = ScalewayInstancesAdapter = ScalewayInstancesAdapter_1 = __decorate([
+    (0, common_1.Injectable)()
+], ScalewayInstancesAdapter);

package/lib/src/modules/providers/implementations/scaleway/scaleway-provider.module.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Scaleway provider module — auto-registers Scaleway into the global provider registry.
+ *
+ * Covers both Scaleway Instances (VMs) and Elastic Metal (bare metal) through
+ * a unified ScalewayProviderService backed by two internal adapters.
+ *
+ * Services depend on 'ICredentialProvider' which must be provided globally
+ * by the parent module (ProvidersModule / CliProvidersModule marked @Global()).
+ *
+ * NOTE: questo modulo NON ha dipendenze TypeORM. Per il provisioning automatico
+ * di Scaleway Object Storage (DB-dipendente, API only) vedere
+ * [ScalewayObjectStorageModule](object-storage/scaleway-object-storage.module.ts).
+ *
+ * To add Scaleway to the system: import ScalewayProviderModule in ProvidersModule.
+ */
+export declare class ScalewayProviderModule {
+}

package/lib/src/modules/providers/implementations/scaleway/scaleway-provider.module.js

@@ -0,0 +1,122 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScalewayProviderModule = void 0;
+const common_1 = require("@nestjs/common");
+const cloud_provider_enum_1 = require("../../enums/cloud-provider.enum");
+const dns_provider_enum_1 = require("../../enums/dns-provider.enum");
+const scaleway_instances_adapter_1 = require("./scaleway-instances.adapter");
+const scaleway_baremetal_adapter_1 = require("./scaleway-baremetal.adapter");
+const scaleway_provider_service_1 = require("./scaleway-provider.service");
+const scaleway_firewall_service_1 = require("./scaleway-firewall.service");
+const scaleway_dns_service_1 = require("./scaleway-dns.service");
+const scaleway_vpc_adapter_1 = require("./scaleway-vpc.adapter");
+const scaleway_iam_adapter_1 = require("./scaleway-iam.adapter");
+const scaleway_capabilities_service_1 = require("./scaleway-capabilities.service");
+const scaleway_object_storage_backend_1 = require("./object-storage/scaleway-object-storage.backend");
+const scaleway_bootstrap_seeder_service_1 = require("./scaleway-bootstrap-seeder.service");
+const shared_infrastructure_module_1 = require("../../../infrastructure/shared/shared-infrastructure.module");
+const storage_module_1 = require("../../../storage/storage.module");
+const storage_backend_provider_enum_1 = require("../../../storage/enums/storage-backend-provider.enum");
+const storage_backend_registry_token_1 = require("../../../storage/tokens/storage-backend-registry.token");
+const tokens_1 = require("../../core/tokens");
+/**
+ * Scaleway provider module — auto-registers Scaleway into the global provider registry.
+ *
+ * Covers both Scaleway Instances (VMs) and Elastic Metal (bare metal) through
+ * a unified ScalewayProviderService backed by two internal adapters.
+ *
+ * Services depend on 'ICredentialProvider' which must be provided globally
+ * by the parent module (ProvidersModule / CliProvidersModule marked @Global()).
+ *
+ * NOTE: questo modulo NON ha dipendenze TypeORM. Per il provisioning automatico
+ * di Scaleway Object Storage (DB-dipendente, API only) vedere
+ * [ScalewayObjectStorageModule](object-storage/scaleway-object-storage.module.ts).
+ *
+ * To add Scaleway to the system: import ScalewayProviderModule in ProvidersModule.
+ */
+let ScalewayProviderModule = class ScalewayProviderModule {
+};
+exports.ScalewayProviderModule = ScalewayProviderModule;
+exports.ScalewayProviderModule = ScalewayProviderModule = __decorate([
+    (0, common_1.Module)({
+        imports: [storage_module_1.StorageModule, shared_infrastructure_module_1.SharedInfrastructureModule],
+        providers: [
+            scaleway_instances_adapter_1.ScalewayInstancesAdapter,
+            scaleway_baremetal_adapter_1.ScalewayBareMetalAdapter,
+            scaleway_provider_service_1.ScalewayProviderService,
+            scaleway_firewall_service_1.ScalewayFirewallService,
+            scaleway_dns_service_1.ScalewayDnsService,
+            scaleway_vpc_adapter_1.ScalewayVpcAdapter,
+            scaleway_iam_adapter_1.ScalewayIamAdapter,
+            scaleway_capabilities_service_1.ScalewayCapabilitiesService,
+            scaleway_object_storage_backend_1.ScalewayObjectStorageBackend,
+            scaleway_bootstrap_seeder_service_1.ScalewayBootstrapSeeder,
+            (0, storage_backend_registry_token_1.multiBackupStorageProvider)({
+                provide: storage_backend_registry_token_1.BACKUP_STORAGE_BACKEND_REGISTRY,
+                useFactory: (s) => ({
+                    provider: storage_backend_provider_enum_1.StorageBackendProvider.SCALEWAY_OBJECT_STORAGE,
+                    backend: s,
+                }),
+                inject: [scaleway_object_storage_backend_1.ScalewayObjectStorageBackend],
+                multi: true,
+            }),
+            (0, tokens_1.multiProvider)({
+                provide: tokens_1.CAPABILITIES_PROVIDER_REGISTRY,
+                useFactory: (s) => ({
+                    provider: cloud_provider_enum_1.CloudProvider.SCALEWAY,
+                    service: s,
+                }),
+                inject: [scaleway_capabilities_service_1.ScalewayCapabilitiesService],
+                multi: true,
+            }),
+            (0, tokens_1.multiProvider)({
+                provide: tokens_1.CLOUD_PROVIDER_REGISTRY,
+                useFactory: (s) => ({
+                    provider: cloud_provider_enum_1.CloudProvider.SCALEWAY,
+                    service: s,
+                }),
+                inject: [scaleway_provider_service_1.ScalewayProviderService],
+                multi: true,
+            }),
+            (0, tokens_1.multiProvider)({
+                provide: tokens_1.FIREWALL_PROVIDER_REGISTRY,
+                useFactory: (s) => ({
+                    provider: cloud_provider_enum_1.CloudProvider.SCALEWAY,
+                    service: s,
+                }),
+                inject: [scaleway_firewall_service_1.ScalewayFirewallService],
+                multi: true,
+            }),
+            (0, tokens_1.multiProvider)({
+                provide: tokens_1.DNS_PROVIDER_REGISTRY,
+                useFactory: (s) => ({
+                    provider: dns_provider_enum_1.DnsProvider.SCALEWAY,
+                    service: s,
+                }),
+                inject: [scaleway_dns_service_1.ScalewayDnsService],
+                multi: true,
+            }),
+        ],
+        exports: [
+            scaleway_provider_service_1.ScalewayProviderService,
+            scaleway_firewall_service_1.ScalewayFirewallService,
+            scaleway_dns_service_1.ScalewayDnsService,
+            scaleway_vpc_adapter_1.ScalewayVpcAdapter,
+            scaleway_iam_adapter_1.ScalewayIamAdapter,
+            scaleway_capabilities_service_1.ScalewayCapabilitiesService,
+            scaleway_object_storage_backend_1.ScalewayObjectStorageBackend,
+            scaleway_bootstrap_seeder_service_1.ScalewayBootstrapSeeder,
+            tokens_1.CLOUD_PROVIDER_REGISTRY,
+            tokens_1.FIREWALL_PROVIDER_REGISTRY,
+            tokens_1.DNS_PROVIDER_REGISTRY,
+            tokens_1.CAPABILITIES_PROVIDER_REGISTRY,
+            storage_backend_registry_token_1.BACKUP_STORAGE_BACKEND_REGISTRY,
+        ],
+    })
+], ScalewayProviderModule);

package/lib/src/modules/providers/implementations/scaleway/scaleway-provider.service.d.ts

@@ -0,0 +1,100 @@
+import { ICloudProvider, CreateServerConfig, ServerCreationResult, ServerDeletionResult, SSHKeyCreationResult, SSHKeyDetails, SshKeyInfo, ChangeServerTypeConfig, ProviderVolumeSummary } from '../../interfaces/cloud-provider.interface';
+import { SSHKeyDto } from '../../../access/dto/ssh-key.dto';
+import { ScalewayIamAdapter } from './scaleway-iam.adapter';
+import { ICredentialProvider } from '../../interfaces/credential-provider.interface';
+import { CreateVNetConfig, VNetCreationResult, VNetDeletionResult, VNetDetails, AddSubnetConfig, DeleteSubnetConfig, AddRouteConfig, DeleteRouteConfig, AttachServerToVNetConfig, ServerVNetAttachmentResult, DetachServerFromVNetConfig } from '../../interfaces/network-provider.interface';
+import { ScalewayVpcAdapter } from './scaleway-vpc.adapter';
+import { InstanceEntity } from '../../../instances/entities/instance.entity';
+import { ServerResponseDto } from '../../../../modules/infrastructure/servers/dto/server-response.dto';
+import { DeleteServerDto } from '../../../../modules/infrastructure/servers/dto/delete-server.dto';
+import { NodeSizeDto } from '../../dto/node-size.dto';
+import { LabelService } from '../../../common/services/label.service';
+import { ScalewayInstancesAdapter } from './scaleway-instances.adapter';
+import { ScalewayBareMetalAdapter } from './scaleway-baremetal.adapter';
+export declare class ScalewayProviderService implements ICloudProvider {
+    private readonly credentialProvider;
+    private readonly labelService;
+    private readonly instancesAdapter;
+    private readonly baremetalAdapter;
+    private readonly vpcAdapter;
+    private readonly iamAdapter;
+    private readonly logger;
+    constructor(credentialProvider: ICredentialProvider, labelService: LabelService, instancesAdapter: ScalewayInstancesAdapter, baremetalAdapter: ScalewayBareMetalAdapter, vpcAdapter: ScalewayVpcAdapter, iamAdapter: ScalewayIamAdapter);
+    /**
+     * Provision Block Storage (SBS) Volumes and attach them to a freshly created
+     * instance. Uses raw axios calls because the Scaleway Block Storage API is
+     * not in the generated client. Each volume is created, awaited, then
+     * attached via the Instance API.
+     *
+     * Returns the device paths the bootstrap script will format/mount.
+     * Convention for Scaleway SBS attached volumes: /dev/disk/by-id/scsi-0SCW_b_<volume-id>.
+     */
+    private provisionSharedVolumes;
+    private deleteSharedVolume;
+    private buildInstanceResourceId;
+    private buildBaremetalResourceId;
+    private parseResourceId;
+    private labelsToTags;
+    private tagsToLabels;
+    private mapInstanceStatus;
+    private mapBaremetalStatus;
+    private mapInstanceServerToEntity;
+    private mapBaremetalServerToEntity;
+    private mapInstanceServerToDto;
+    private mapBaremetalServerToDto;
+    testConnection(): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    listInstances(filters?: any): Promise<InstanceEntity[]>;
+    listServersAsDto(): Promise<ServerResponseDto[]>;
+    getServerDetailsAsDto(serverId: string): Promise<ServerResponseDto | null>;
+    createServer(config: CreateServerConfig): Promise<ServerCreationResult>;
+    private createInstanceServer;
+    private createBaremetalServer;
+    deleteServer(config: DeleteServerDto): Promise<ServerDeletionResult>;
+    getServerStatus(serverId: string): Promise<string>;
+    powerOnServer(serverId: string): Promise<void>;
+    changeServerType(serverId: string, config: ChangeServerTypeConfig): Promise<{
+        actionId?: number;
+    }>;
+    expandVolume(volumeId: string, newSizeGb: number): Promise<{
+        actionId?: number;
+    }>;
+    detachVolume(volumeId: string): Promise<{
+        actionId?: number;
+    }>;
+    deleteVolume(volumeId: string): Promise<void>;
+    listFluiManagedVolumes(): Promise<ProviderVolumeSummary[]>;
+    private parseVolumeRef;
+    powerOffServer(serverId: string): Promise<void>;
+    updateServerLabels(serverId: string, labels: Record<string, string>): Promise<void>;
+    getNodeSizes(includeAvailability?: boolean): Promise<NodeSizeDto[]>;
+    createVNet(config: CreateVNetConfig): Promise<VNetCreationResult>;
+    deleteVNet(vnetId: string): Promise<VNetDeletionResult>;
+    getVNet(vnetId: string): Promise<VNetDetails | null>;
+    listVNets(): Promise<VNetDetails[]>;
+    addSubnet(config: AddSubnetConfig): Promise<{
+        actionId?: number;
+    }>;
+    deleteSubnet(config: DeleteSubnetConfig): Promise<{
+        actionId?: number;
+    }>;
+    addRoute(config: AddRouteConfig): Promise<{
+        actionId?: number;
+    }>;
+    deleteRoute(config: DeleteRouteConfig): Promise<{
+        actionId?: number;
+    }>;
+    attachServerToVNet(config: AttachServerToVNetConfig): Promise<ServerVNetAttachmentResult>;
+    detachServerFromVNet(config: DetachServerFromVNetConfig): Promise<{
+        actionId?: number;
+    }>;
+    private extractRegionFromLabels;
+    resolveSSHKeys(keys: SshKeyInfo[]): Promise<string[]>;
+    listSSHKeys(): Promise<SSHKeyDto[]>;
+    createSSHKey(name: string, publicKey: string, labels?: Record<string, string>): Promise<SSHKeyCreationResult>;
+    deleteSSHKey(providerKeyId: string): Promise<void>;
+    getSSHKey(providerKeyId: string): Promise<SSHKeyDetails>;
+    private extractKeyType;
+}