@flui-cloud/cli 0.0.1

package/lib/src/modules/providers/interfaces/cloud-provider.interface.d.ts

@@ -0,0 +1,215 @@
+import { InstanceEntity } from '../../instances/entities/instance.entity';
+import { ServerResponseDto } from '../../infrastructure/servers/dto/server-response.dto';
+import { DeleteServerDto } from '../../infrastructure/servers/dto/delete-server.dto';
+import { SSHKeyDto } from '../../access/dto/ssh-key.dto';
+import { NodeSizeDto } from '../dto/node-size.dto';
+import { PricingDto, PricingQueryDto } from '../dto/pricing.dto';
+import { CreateVNetConfig, VNetCreationResult, VNetDetails, VNetDeletionResult, AddSubnetConfig, DeleteSubnetConfig, AddRouteConfig, DeleteRouteConfig, AttachServerToVNetConfig, DetachServerFromVNetConfig, ServerVNetAttachmentResult, ChangeIpRangeConfig } from './network-provider.interface';
+export interface Label {
+    key: string;
+    value: string;
+}
+export interface CreateServerConfig {
+    name: string;
+    server_type?: string;
+    image?: string;
+    location?: string;
+    ssh_keys?: string[];
+    environment?: string;
+    cluster_name?: string;
+    user_data?: string;
+    labels?: Label[];
+    firewalls?: string[];
+    /** Disk size in GB. Used by providers that require explicit volume sizing (e.g. Scaleway SBS network volumes). Ignored by providers with local storage included in the server type. */
+    diskSizeGb?: number;
+    /** Provider VNet/network IDs to attach the server to at creation. */
+    networks?: string[];
+    /**
+     * Flui-managed block storage Volumes to create and attach to the server at
+     * creation time. Used by §14 of the scaling architecture: master nodes get
+     * one Volume that hosts the NFS export for shared cluster storage.
+     *
+     * The provider implementation creates the Volume(s), waits for them to be
+     * ready, attaches them to the new server, and returns the Linux device
+     * path(s) so the bootstrap script can format/mount.
+     */
+    attachedVolumes?: AttachedVolumeRequest[];
+}
+export interface AttachedVolumeRequest {
+    /** Size in GB. */
+    sizeGb: number;
+    /** Human-friendly label (used for naming the Volume in the provider's panel). */
+    name: string;
+    /**
+     * Optional location/zone hint. If omitted, provider uses the same location
+     * as the server.
+     */
+    location?: string;
+    /** Provider labels propagated to the Volume. */
+    labels?: Label[];
+}
+export interface AttachedVolumeResult {
+    /** Provider Volume id. */
+    volumeId: string;
+    /** Linux device path (e.g. /dev/disk/by-id/scsi-0HC_Volume_12345). */
+    devicePath: string;
+    sizeGb: number;
+}
+export interface ServerCreationResult {
+    /** Volumes created and attached. Empty if attachedVolumes was not requested. */
+    attachedVolumes?: AttachedVolumeResult[];
+    serverId: string;
+    ipAddress?: string;
+    privateIp?: string;
+    status: string;
+    actionId?: number;
+}
+export interface ServerDeletionResult {
+    actionId?: number;
+    message: string;
+}
+export interface SSHKeyCreationResult {
+    id: string;
+    fingerprint?: string;
+}
+export interface SSHKeyDetails {
+    id: string;
+    name: string;
+    publicKey: string;
+    fingerprint: string;
+    labels?: Record<string, string>;
+}
+/**
+ * Flui SSH key data passed to the provider for resolution.
+ * The provider uses this to create or retrieve the key on the cloud platform
+ * and return the provider-specific key ID.
+ */
+export interface SshKeyInfo {
+    /** Local Flui UUID */
+    fluiId: string;
+    name: string;
+    publicKey: string;
+    fingerprint: string;
+    /** Cached provider key ID, if already synced */
+    existingProviderId?: string;
+}
+export interface ChangeServerTypeConfig {
+    /** Target provider server type name (e.g. `cx32` on Hetzner, `PRO2-S` on Scaleway). */
+    targetServerType: string;
+    /**
+     * Hetzner-only: if true, also grow the local OS disk to the target type's
+     * size. This is one-way — once enabled, the server can never be resized
+     * back down to a smaller type. Default false to preserve future flexibility.
+     * Ignored by providers without local-disk semantics.
+     */
+    upgradeDisk?: boolean;
+}
+export interface ProviderVolumeSummary {
+    volumeId: string;
+    name: string;
+    sizeGb: number;
+    region?: string;
+    attachedServerId?: string | null;
+    labels: Record<string, string>;
+    createdAt?: string;
+}
+export interface ProviderSnapshot {
+    id: string;
+    name: string;
+    serverId?: string;
+    sizeBytes?: number;
+    status: string;
+    createdAt?: string;
+    description?: string;
+}
+export interface ICloudProvider {
+    listInstances(filters?: any): Promise<InstanceEntity[]>;
+    listServersAsDto(): Promise<ServerResponseDto[]>;
+    getServerDetailsAsDto(serverId: string): Promise<ServerResponseDto | null>;
+    createServer(config: CreateServerConfig): Promise<ServerCreationResult>;
+    deleteServer(config: DeleteServerDto): Promise<ServerDeletionResult>;
+    getServerStatus(serverId: string): Promise<string>;
+    testConnection(): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    powerOnServer?(serverId: string): Promise<void>;
+    powerOffServer?(serverId: string): Promise<void>;
+    updateServerLabels?(serverId: string, labels: Record<string, string>): Promise<void>;
+    listSSHKeys?(): Promise<SSHKeyDto[]>;
+    createSSHKey?(name: string, publicKey: string, labels?: Record<string, string>): Promise<SSHKeyCreationResult>;
+    deleteSSHKey?(providerKeyId: string): Promise<void>;
+    getSSHKey?(providerKeyId: string): Promise<SSHKeyDetails>;
+    /**
+     * Resolve Flui SSH keys to provider-specific key IDs.
+     * Creates keys on the provider if not yet present.
+     * Returns provider key IDs in the same order as the input array.
+     */
+    resolveSSHKeys?(keys: SshKeyInfo[]): Promise<string[]>;
+    getNodeSizes?(includeAvailability?: boolean): Promise<NodeSizeDto[]>;
+    getPricing?(query: PricingQueryDto): Promise<PricingDto>;
+    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;
+    }>;
+    changeIpRange?(config: ChangeIpRangeConfig): Promise<{
+        actionId?: number;
+    }>;
+    attachServerToVNet?(config: AttachServerToVNetConfig): Promise<ServerVNetAttachmentResult>;
+    detachServerFromVNet?(config: DetachServerFromVNetConfig): Promise<{
+        actionId?: number;
+    }>;
+    /**
+     * Vertical scaling primitives.
+     *
+     * Maintenance-window semantics: the caller is responsible for stopping the
+     * server before invoking `changeServerType` (Hetzner requires the server to
+     * be off, Scaleway requires `stopped` state, etc.) and for waiting for the
+     * k3s node to rejoin Ready after `powerOnServer`. These primitives only
+     * perform the provider-side action and do not orchestrate the cluster.
+     *
+     * Volume `expandVolume` is online-safe on the provider side, but the
+     * caller still needs to run `resize2fs` (or equivalent) over SSH on the
+     * server that mounts the volume before the new size becomes usable.
+     */
+    changeServerType?(serverId: string, config: ChangeServerTypeConfig): Promise<{
+        actionId?: number;
+    }>;
+    expandVolume?(volumeId: string, newSizeGb: number): Promise<{
+        actionId?: number;
+    }>;
+    /**
+     * Volume lifecycle primitives — used on cluster destroy to clean up the
+     * Flui-managed shared storage Volume created at master-create time. The
+     * caller must `detachVolume` before `deleteVolume` (most providers reject
+     * delete-while-attached).
+     */
+    detachVolume?(volumeId: string): Promise<{
+        actionId?: number;
+    }>;
+    deleteVolume?(volumeId: string): Promise<void>;
+    /**
+     * List all Flui-managed Volumes at the provider, optionally filtered by a
+     * label selector. Used by the orphan-volume scan to find Volumes that
+     * belong to deleted clusters. The provider must include each Volume's
+     * label set so the caller can decide ownership.
+     */
+    listFluiManagedVolumes?(): Promise<ProviderVolumeSummary[]>;
+    supportsServerSnapshots?(): boolean;
+    createServerSnapshot?(serverId: string, name: string, description?: string): Promise<ProviderSnapshot>;
+    listServerSnapshots?(serverId: string): Promise<ProviderSnapshot[]>;
+    deleteServerSnapshot?(snapshotId: string): Promise<void>;
+    restoreServerFromSnapshot?(serverId: string, snapshotId: string): Promise<void>;
+}

package/lib/src/modules/providers/interfaces/cloud-provider.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/src/modules/providers/interfaces/credential-provider.interface.d.ts

@@ -0,0 +1,23 @@
+import { CloudProvider } from '../enums/cloud-provider.enum';
+import { BearerTokenDto } from '../../access/dto/bearer-token.dto';
+export interface AccessKeyPair {
+    /** The access key ID (public identifier) */
+    accessKey: string;
+    /** The secret key used for API authentication */
+    secretKey: string;
+}
+export interface ICredentialProvider {
+    /**
+     * Get active API token for a specific cloud provider (type: api_key).
+     */
+    getActiveApiToken(provider: CloudProvider): Promise<string>;
+    /**
+     * Get active access key pair for a specific cloud provider (type: access_key_secret).
+     * Returns both the access key ID and the secret key.
+     */
+    getActiveAccessKeyPair(provider: CloudProvider): Promise<AccessKeyPair>;
+    /**
+     * Get active bearer token for a specific cloud provider (type: user_password / bearer_token).
+     */
+    getActiveBearerToken(provider: CloudProvider): Promise<BearerTokenDto>;
+}

package/lib/src/modules/providers/interfaces/credential-provider.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/src/modules/providers/interfaces/dns-provider.interface.d.ts

@@ -0,0 +1,55 @@
+export declare enum DnsRecordType {
+    A = "A",
+    AAAA = "AAAA",
+    CNAME = "CNAME",
+    TXT = "TXT",
+    MX = "MX",
+    SRV = "SRV"
+}
+export interface DnsZoneInfo {
+    zoneId: string;
+    name: string;
+    ttl: number;
+    recordCount: number;
+    status: string;
+}
+export interface DnsRecordInfo {
+    recordId: string;
+    zoneId: string;
+    type: DnsRecordType;
+    name: string;
+    value: string;
+    ttl: number;
+    labels?: Record<string, string>;
+}
+export interface CreateDnsRecordConfig {
+    zoneId: string;
+    type: DnsRecordType;
+    name: string;
+    value: string;
+    ttl?: number;
+    labels?: Record<string, string>;
+}
+export interface UpdateDnsRecordConfig {
+    recordId: string;
+    zoneId: string;
+    type: DnsRecordType;
+    name: string;
+    value: string;
+    ttl?: number;
+}
+export interface IDnsProvider {
+    listZones(): Promise<DnsZoneInfo[]>;
+    getZone(zoneId: string): Promise<DnsZoneInfo | null>;
+    getZoneByName(name: string): Promise<DnsZoneInfo | null>;
+    listRecords(zoneId: string): Promise<DnsRecordInfo[]>;
+    getRecord(zoneId: string, recordId: string): Promise<DnsRecordInfo | null>;
+    createRecord(config: CreateDnsRecordConfig): Promise<DnsRecordInfo>;
+    updateRecord(config: UpdateDnsRecordConfig): Promise<DnsRecordInfo>;
+    deleteRecord(zoneId: string, recordId: string): Promise<void>;
+    bulkCreateRecords(zoneId: string, records: CreateDnsRecordConfig[]): Promise<DnsRecordInfo[]>;
+    testConnection(): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+}

package/lib/src/modules/providers/interfaces/dns-provider.interface.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DnsRecordType = void 0;
+var DnsRecordType;
+(function (DnsRecordType) {
+    DnsRecordType["A"] = "A";
+    DnsRecordType["AAAA"] = "AAAA";
+    DnsRecordType["CNAME"] = "CNAME";
+    DnsRecordType["TXT"] = "TXT";
+    DnsRecordType["MX"] = "MX";
+    DnsRecordType["SRV"] = "SRV";
+})(DnsRecordType || (exports.DnsRecordType = DnsRecordType = {}));

package/lib/src/modules/providers/interfaces/firewall-provider.interface.d.ts

@@ -0,0 +1,47 @@
+export interface IFirewallProvider {
+    createFirewall(config: CreateFirewallConfig): Promise<FirewallCreationResult>;
+    getFirewall(firewallId: string): Promise<FirewallDetails | null>;
+    listFirewalls(filters?: FirewallFilters): Promise<FirewallDetails[]>;
+    updateFirewallRules(firewallId: string, rules: FirewallRule[]): Promise<void>;
+    deleteFirewall(firewallId: string): Promise<void>;
+    applyToServers(firewallId: string, serverIds: string[]): Promise<void>;
+    removeFromServers(firewallId: string, serverIds: string[]): Promise<void>;
+}
+export interface FirewallRule {
+    id?: string;
+    description: string;
+    direction: 'in' | 'out';
+    protocol: 'tcp' | 'udp' | 'icmp';
+    port?: string;
+    sourceIps?: string[];
+    destinationIps?: string[];
+}
+export interface CreateFirewallConfig {
+    name: string;
+    labels: Array<{
+        key: string;
+        value: string;
+    }>;
+    rules: FirewallRule[];
+    applyToServerIds?: string[];
+    applyToLabelSelector?: string;
+}
+export interface FirewallCreationResult {
+    firewallId: string;
+    appliedToServerIds?: string[];
+}
+export interface FirewallDetails {
+    id: string;
+    name: string;
+    rules: FirewallRule[];
+    labels: Record<string, string>;
+    appliedTo: Array<{
+        serverId: string;
+        serverName?: string;
+    }>;
+}
+export interface FirewallFilters {
+    clusterId?: string;
+    name?: string;
+    labelSelector?: string;
+}

package/lib/src/modules/providers/interfaces/firewall-provider.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/src/modules/providers/interfaces/network-provider.interface.d.ts

@@ -0,0 +1,124 @@
+import { Label } from './cloud-provider.interface';
+export interface VNetSubnetConfig {
+    ipRange: string;
+    networkZone: string;
+    gateway?: string;
+    vswitchId?: string;
+}
+export interface VNetRouteConfig {
+    destination: string;
+    gateway: string;
+}
+export interface CreateVNetConfig {
+    name: string;
+    ipRange: string;
+    labels?: Label[];
+    subnets?: VNetSubnetConfig[];
+    routes?: VNetRouteConfig[];
+    exposeRoutesToVSwitch?: boolean;
+}
+export interface VNetCreationResult {
+    vnetId: string;
+    ipRange: string;
+    subnets?: VNetSubnetInfo[];
+}
+export interface VNetSubnetInfo {
+    id?: string;
+    ipRange: string;
+    networkZone: string;
+    gateway?: string;
+}
+export interface VNetRouteInfo {
+    destination: string;
+    gateway: string;
+}
+export interface VNetDetails {
+    id: string;
+    name: string;
+    ipRange: string;
+    subnets: VNetSubnetInfo[];
+    routes: VNetRouteInfo[];
+    attachedServerIds: string[];
+    attachedLoadBalancerIds?: string[];
+    labels?: Record<string, string>;
+    created?: string;
+}
+export interface VNetDeletionResult {
+    message: string;
+    actionId?: number;
+}
+export interface AddSubnetConfig {
+    vnetId: string;
+    ipRange?: string;
+    networkZone: string;
+    vswitchId?: string;
+}
+export interface AddSubnetResult {
+    actionId?: number;
+    subnetId?: string;
+    ipRange: string;
+    networkZone?: string;
+    gateway?: string;
+}
+export interface DeleteSubnetConfig {
+    vnetId: string;
+    ipRange: string;
+}
+export interface AddRouteConfig {
+    vnetId: string;
+    destination: string;
+    gateway: string;
+}
+export interface DeleteRouteConfig {
+    vnetId: string;
+    destination: string;
+    gateway: string;
+}
+export interface AttachServerToVNetConfig {
+    serverId: string;
+    vnetId: string;
+    ip?: string;
+    aliasIps?: string[];
+}
+export interface DetachServerFromVNetConfig {
+    serverId: string;
+    vnetId: string;
+}
+export interface ServerVNetAttachmentResult {
+    actionId?: number;
+    assignedIp?: string;
+    message: string;
+}
+export interface ChangeIpRangeConfig {
+    vnetId: string;
+    newIpRange: string;
+}
+/**
+ * Interface for network/VNet operations on cloud providers
+ * Implements virtual network management capabilities
+ */
+export interface INetworkProvider {
+    createVNet(config: CreateVNetConfig): Promise<VNetCreationResult>;
+    deleteVNet(vnetId: string): Promise<VNetDeletionResult>;
+    getVNet(vnetId: string): Promise<VNetDetails | null>;
+    listVNets(): Promise<VNetDetails[]>;
+    addSubnet(config: AddSubnetConfig): Promise<AddSubnetResult>;
+    deleteSubnet(config: DeleteSubnetConfig): Promise<{
+        actionId?: number;
+    }>;
+    addRoute(config: AddRouteConfig): Promise<{
+        actionId?: number;
+    }>;
+    deleteRoute(config: DeleteRouteConfig): Promise<{
+        actionId?: number;
+    }>;
+    changeIpRange?(config: ChangeIpRangeConfig): Promise<{
+        actionId?: number;
+    }>;
+    attachServerToVNet(config: AttachServerToVNetConfig): Promise<ServerVNetAttachmentResult>;
+    detachServerFromVNet(config: DetachServerFromVNetConfig): Promise<{
+        actionId?: number;
+    }>;
+    enableVNetProtection?(vnetId: string): Promise<void>;
+    disableVNetProtection?(vnetId: string): Promise<void>;
+}

package/lib/src/modules/providers/interfaces/network-provider.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/src/modules/providers/interfaces/provider-capabilities.interface.d.ts

@@ -0,0 +1,87 @@
+import { ProviderCapabilities } from '../../management/entities/provider-capabilities.entity';
+import { ProviderRegion } from '../../management/entities/provider-region.entity';
+import { ProviderCredentials } from '../../management/entities/credentials.entity';
+import { ValidationResultDto } from '../../management/dto/validation-result.dto';
+export interface IProviderCapabilitiesService {
+    getAvailableRegions(): Promise<ProviderRegion[]>;
+    getSupportedInstanceTypes(): Promise<InstanceTypeInfo[]>;
+    getProviderInfo(): Promise<ProviderInfo>;
+    /**
+     * Returns full capabilities including regions and instance types fetched from the provider API.
+     * Requires valid credentials. Use for /regions and /instance-types endpoints.
+     */
+    getCapabilities(): Promise<ProviderCapabilities>;
+    /**
+     * Returns static capabilities (feature flags, pricing metadata) without any API calls.
+     * Safe to call without credentials. Use for listing all available providers.
+     */
+    getStaticCapabilities(): ProviderCapabilities;
+    getLogo(): Buffer;
+    getLogoContentType(): string;
+    /**
+     * Validates raw credentials against the provider API before storing them.
+     * Each provider implements its own validation logic.
+     */
+    validateCredentials(credentials: ProviderCredentials): Promise<ValidationResultDto>;
+}
+export interface InstanceTypeInfo {
+    id: string;
+    name: string;
+    description: string;
+    cpu: number;
+    memory: number;
+    disk: number;
+    bandwidth: number;
+    pricing: {
+        hourly: number;
+        monthly: number;
+        currency: string;
+    };
+    available: boolean;
+}
+export interface CredentialFieldDefinition {
+    /** Internal key used by Flui in the request body (e.g. 'apiKey', 'secretKey') */
+    key: 'apiKey' | 'accessKey' | 'secretKey' | 'username' | 'password' | 'clientId' | 'clientSecret' | 'bearerToken';
+    /** Label shown in the Flui UI */
+    label: string;
+    /** Exact name the provider uses for this field (for UI consistency with provider docs) */
+    providerLabel: string;
+    /** Where to find this value in the provider console */
+    hint: string;
+    /** Whether the value should be masked in the UI */
+    secret: boolean;
+    /** Whether the field is required */
+    required: boolean;
+}
+export interface ProviderCredentialFields {
+    type: import('../../management/entities/credentials.entity').CredentialType;
+    fields: CredentialFieldDefinition[];
+    /**
+     * Whether the provider supports setting an expiry on keys.
+     * When true, Flui shows an optional "expires at" date picker.
+     * The expiry cannot be inferred from the key — it must be entered by the user.
+     */
+    supportsExpiry: boolean;
+}
+export interface DnsZoneDelegation {
+    /** Nameservers to set at the domain registrar to delegate to this provider */
+    nameservers: string[];
+    /** Official guide URL explaining how to delegate/import an external domain */
+    delegationGuideUrl: string;
+}
+export interface ProviderInfo {
+    id: string;
+    name: string;
+    displayName: string;
+    description: string;
+    logoUrl: string;
+    websiteUrl: string;
+    documentationUrl: string;
+    accessKeyDocumentationUrl?: string;
+    pricingUrl?: string;
+    supportUrl?: string;
+    /** Describes the credential fields required to configure this provider */
+    credentialFields: ProviderCredentialFields;
+    /** DNS delegation info (only present when provider supports DNS zones) */
+    dnsZoneDelegation?: DnsZoneDelegation;
+}

package/lib/src/modules/providers/interfaces/provider-capabilities.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/src/modules/providers/interfaces/vm-backup-provider.interface.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Provider-side VM-level backup. Distinct from the Velero+Kopia application
+ * backup pipeline — this is whole-VM imaging done by the cloud provider
+ * (e.g. Hetzner Cloud Backups: +20% on server price, daily snapshots, 7-day
+ * retention). Each provider that offers something equivalent implements this.
+ */
+export type VmBackupScope = 'whole-vm-no-volumes' | 'whole-vm-with-volumes';
+export type VmBackupPricingModel = 'percent-of-server-monthly';
+export interface VmBackupCapability {
+    supported: boolean;
+    retentionDays: number;
+    scope: VmBackupScope;
+    pricingModel: VmBackupPricingModel;
+    /** For 'percent-of-server-monthly': percentage added to the node's monthly price (e.g. 20 = +20%). */
+    pricingPercent: number;
+    notes?: string;
+}
+export interface VmBackupStatus {
+    serverProviderId: string;
+    enabled: boolean;
+    /** Provider-reported backup window (UTC, free-form), null when disabled. */
+    backupWindow?: string | null;
+}
+export interface VmBackupSnapshot {
+    id: string;
+    serverProviderId: string;
+    name?: string | null;
+    description?: string | null;
+    createdAt: string;
+    sizeGb?: number | null;
+    imageType?: string;
+}
+export interface IVmBackupProvider {
+    getCapability(): VmBackupCapability;
+    enableForServer(serverProviderId: string): Promise<void>;
+    disableForServer(serverProviderId: string): Promise<void>;
+    getStatusForServer(serverProviderId: string): Promise<VmBackupStatus>;
+    listBackupsForServer(serverProviderId: string): Promise<VmBackupSnapshot[]>;
+}

package/lib/src/modules/providers/interfaces/vm-backup-provider.interface.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Provider-side VM-level backup. Distinct from the Velero+Kopia application
+ * backup pipeline — this is whole-VM imaging done by the cloud provider
+ * (e.g. Hetzner Cloud Backups: +20% on server price, daily snapshots, 7-day
+ * retention). Each provider that offers something equivalent implements this.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });