@flui-cloud/cli 0.0.1

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

@@ -0,0 +1,24 @@
+import { KubernetesService } from '../../../infrastructure/shared/services/kubernetes.service';
+import { CreatePvcFromSnapshotInput, CreateSnapshotInput, DeleteSnapshotInput, IVolumeOperations, ListSnapshotsInput, SnapshotResult, SnapshotSummary, VolumeOperationsCapabilities } from '../../interfaces/volume-operations.interface';
+/**
+ * Scaleway Block Storage exposes CSI VolumeSnapshot via the scaleway-csi
+ * driver (v0.3+) backed by the SBS API. Snapshots are first-class objects
+ * billed separately from volumes (~€0.000044/GB-hour ≈ €0.032/GB-mo) and
+ * can be retained as long as needed.
+ */
+export declare class ScalewayVolumeOperationsService implements IVolumeOperations {
+    private readonly k8s;
+    private readonly logger;
+    readonly capabilities: VolumeOperationsCapabilities;
+    constructor(k8s: KubernetesService);
+    createSnapshot(input: CreateSnapshotInput): Promise<SnapshotResult>;
+    deleteSnapshot(input: DeleteSnapshotInput): Promise<void>;
+    listSnapshots(input: ListSnapshotsInput): Promise<SnapshotSummary[]>;
+    createPvcFromSnapshot(input: CreatePvcFromSnapshotInput): Promise<{
+        pvcName: string;
+    }>;
+    private waitForSnapshotReady;
+    private renderSnapshotManifest;
+    private parseStorageGb;
+    private yamlString;
+}

package/lib/src/modules/providers/implementations/scaleway/scaleway-volume-operations.service.js

@@ -0,0 +1,199 @@
+"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 ScalewayVolumeOperationsService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScalewayVolumeOperationsService = void 0;
+const common_1 = require("@nestjs/common");
+const kubernetes_service_1 = require("../../../infrastructure/shared/services/kubernetes.service");
+const VOLUME_SNAPSHOT_API_VERSION = 'snapshot.storage.k8s.io/v1';
+const DEFAULT_VOLUME_SNAPSHOT_CLASS = 'scw-snapshot';
+const SCALEWAY_SNAPSHOT_PRICE_PER_GB_HOUR_EUR = 0.000044;
+const SNAPSHOT_READY_TIMEOUT_SECONDS = 5 * 60;
+/**
+ * Scaleway Block Storage exposes CSI VolumeSnapshot via the scaleway-csi
+ * driver (v0.3+) backed by the SBS API. Snapshots are first-class objects
+ * billed separately from volumes (~€0.000044/GB-hour ≈ €0.032/GB-mo) and
+ * can be retained as long as needed.
+ */
+let ScalewayVolumeOperationsService = ScalewayVolumeOperationsService_1 = class ScalewayVolumeOperationsService {
+    constructor(k8s) {
+        this.k8s = k8s;
+        this.logger = new common_1.Logger(ScalewayVolumeOperationsService_1.name);
+        this.capabilities = {
+            supportsSnapshotRetention: true,
+            supportsCsiSnapshot: true,
+            requiresCopyPodFallback: false,
+            snapshotCostPerGbMonthEur: parseFloat((SCALEWAY_SNAPSHOT_PRICE_PER_GB_HOUR_EUR * 24 * 30).toFixed(4)),
+        };
+    }
+    async createSnapshot(input) {
+        const sourcePvc = await this.k8s.getResource(input.kubeconfig, 'PersistentVolumeClaim', input.sourcePvcName, input.namespace);
+        if (!sourcePvc) {
+            throw new Error(`Source PVC ${input.namespace}/${input.sourcePvcName} not found`);
+        }
+        const sizeGb = this.parseStorageGb(sourcePvc?.spec?.resources?.requests?.storage ?? '0');
+        const manifest = this.renderSnapshotManifest({
+            name: input.snapshotName,
+            namespace: input.namespace,
+            sourcePvcName: input.sourcePvcName,
+            labels: input.labels,
+            snapshotClass: DEFAULT_VOLUME_SNAPSHOT_CLASS,
+        });
+        await this.k8s.applyManifest(input.kubeconfig, manifest);
+        this.logger.log(`[scaleway-snapshot] Created VolumeSnapshot ${input.namespace}/${input.snapshotName} from ${input.sourcePvcName}`);
+        const ready = await this.waitForSnapshotReady(input.kubeconfig, input.namespace, input.snapshotName, SNAPSHOT_READY_TIMEOUT_SECONDS);
+        return {
+            snapshotId: input.snapshotName,
+            kind: 'csi-snapshot',
+            namespace: input.namespace,
+            sourceSizeGb: sizeGb,
+            createdAt: new Date().toISOString(),
+            ready,
+        };
+    }
+    async deleteSnapshot(input) {
+        try {
+            await this.k8s.deleteResource(input.kubeconfig, 'VolumeSnapshot', input.snapshotId, input.namespace);
+        }
+        catch (err) {
+            if (input.ignoreNotFound && err?.message?.includes('not found')) {
+                return;
+            }
+            throw err;
+        }
+    }
+    async listSnapshots(input) {
+        const namespace = input.namespace ?? '';
+        if (!namespace) {
+            this.logger.debug('[scaleway-snapshot] cluster-wide list requires namespace iteration; returning empty result. Caller should pass per-namespace queries.');
+            return [];
+        }
+        const items = await this.k8s.listResourcesByLabel(input.kubeconfig, 'VolumeSnapshot', namespace, input.labelSelector ?? '');
+        return items.map((snap) => {
+            const labels = snap?.metadata?.labels ?? {};
+            const restoreSize = snap?.status?.restoreSize;
+            const sizeGb = restoreSize ? this.parseStorageGb(restoreSize) : undefined;
+            const sourcePvcName = snap?.spec?.source?.persistentVolumeClaimName;
+            return {
+                snapshotId: snap?.metadata?.name,
+                kind: 'csi-snapshot',
+                namespace: snap?.metadata?.namespace,
+                sourcePvcName,
+                appId: labels['flui-app-id'],
+                sizeGb,
+                createdAt: snap?.metadata?.creationTimestamp ??
+                    new Date().toISOString(),
+                ready: Boolean(snap?.status?.readyToUse),
+                labels,
+            };
+        });
+    }
+    async createPvcFromSnapshot(input) {
+        const labelLines = Object.entries(input.labels)
+            .map(([k, v]) => `    ${this.yamlString(k)}: ${this.yamlString(v)}`)
+            .join('\n');
+        const manifest = [
+            'apiVersion: v1',
+            'kind: PersistentVolumeClaim',
+            'metadata:',
+            `  name: ${input.newPvcName}`,
+            `  namespace: ${input.namespace}`,
+            '  labels:',
+            labelLines,
+            'spec:',
+            '  accessModes:',
+            '    - ReadWriteOnce',
+            `  storageClassName: ${input.storageClassName}`,
+            '  resources:',
+            '    requests:',
+            `      storage: ${input.sizeGb}Gi`,
+            '  dataSource:',
+            `    name: ${input.snapshotId}`,
+            '    kind: VolumeSnapshot',
+            '    apiGroup: snapshot.storage.k8s.io',
+            '',
+        ].join('\n');
+        await this.k8s.applyManifest(input.kubeconfig, manifest);
+        return { pvcName: input.newPvcName };
+    }
+    async waitForSnapshotReady(kubeconfig, namespace, snapshotName, timeoutSeconds) {
+        const pollIntervalMs = 3000;
+        const start = Date.now();
+        while (Date.now() - start < timeoutSeconds * 1000) {
+            const snap = await this.k8s.getResource(kubeconfig, 'VolumeSnapshot', snapshotName, namespace);
+            if (snap?.status?.readyToUse)
+                return true;
+            if (snap?.status?.error) {
+                const msg = snap.status.error.message ?? 'unknown';
+                throw new Error(`VolumeSnapshot ${namespace}/${snapshotName} reported error: ${msg}`);
+            }
+            await new Promise((r) => setTimeout(r, pollIntervalMs));
+        }
+        this.logger.warn(`[scaleway-snapshot] VolumeSnapshot ${namespace}/${snapshotName} not ready within ${timeoutSeconds}s — caller can poll separately`);
+        return false;
+    }
+    renderSnapshotManifest(args) {
+        const labelLines = Object.entries(args.labels)
+            .map(([k, v]) => `    ${this.yamlString(k)}: ${this.yamlString(v)}`)
+            .join('\n');
+        return [
+            `apiVersion: ${VOLUME_SNAPSHOT_API_VERSION}`,
+            'kind: VolumeSnapshot',
+            'metadata:',
+            `  name: ${args.name}`,
+            `  namespace: ${args.namespace}`,
+            '  labels:',
+            labelLines,
+            'spec:',
+            `  volumeSnapshotClassName: ${args.snapshotClass}`,
+            '  source:',
+            `    persistentVolumeClaimName: ${args.sourcePvcName}`,
+            '',
+        ].join('\n');
+    }
+    parseStorageGb(value) {
+        if (!value)
+            return 0;
+        const match = String(value).match(/^(\d+(?:\.\d+)?)([KMGTP]i?)?$/);
+        if (!match)
+            return 0;
+        const num = Number.parseFloat(match[1]);
+        const unit = match[2];
+        switch (unit) {
+            case 'Ki':
+                return num / (1024 * 1024);
+            case 'Mi':
+                return num / 1024;
+            case 'Gi':
+                return num;
+            case 'Ti':
+                return num * 1024;
+            case 'K':
+                return num / 1_000_000;
+            case 'M':
+                return num / 1000;
+            case 'G':
+                return num;
+            case 'T':
+                return num * 1000;
+            default:
+                return num;
+        }
+    }
+    yamlString(value) {
+        return JSON.stringify(value);
+    }
+};
+exports.ScalewayVolumeOperationsService = ScalewayVolumeOperationsService;
+exports.ScalewayVolumeOperationsService = ScalewayVolumeOperationsService = ScalewayVolumeOperationsService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [kubernetes_service_1.KubernetesService])
+], ScalewayVolumeOperationsService);

package/lib/src/modules/providers/implementations/scaleway/scaleway-vpc.adapter.d.ts

@@ -0,0 +1,30 @@
+import { VNetCreationResult, VNetDetails } from '../../interfaces/network-provider.interface';
+import { ICredentialProvider } from '../../interfaces/credential-provider.interface';
+import { ScalewayIamAdapter } from './scaleway-iam.adapter';
+export declare class ScalewayVpcAdapter {
+    private readonly credentialProvider;
+    private readonly iamAdapter;
+    private readonly logger;
+    constructor(credentialProvider: ICredentialProvider, iamAdapter: ScalewayIamAdapter);
+    /** Encode region + private network UUID into a Flui vnetId */
+    buildVnetId(region: string, privateNetworkId: string): string;
+    /** Decode a Flui vnetId back to { region, id } */
+    parseVnetId(vnetId: string): {
+        region: string;
+        id: string;
+    };
+    /** Derive region from a Scaleway zone (e.g. 'fr-par-1' → 'fr-par') */
+    zoneToRegion(zone: string): string;
+    private createPrivateNetworksApi;
+    private createSubnetsApi;
+    private createBaremetalPrivateNetworksApi;
+    createPrivateNetwork(region: string, name: string, tags: string[], subnets: string[]): Promise<VNetCreationResult>;
+    deletePrivateNetwork(region: string, privateNetworkId: string): Promise<void>;
+    getPrivateNetwork(region: string, privateNetworkId: string): Promise<VNetDetails | null>;
+    listPrivateNetworks(region: string): Promise<VNetDetails[]>;
+    addSubnets(region: string, privateNetworkId: string, subnets: string[]): Promise<void>;
+    deleteSubnets(region: string, privateNetworkId: string, subnets: string[]): Promise<void>;
+    attachBaremetalToPrivateNetwork(zone: string, serverId: string, privateNetworkId: string): Promise<void>;
+    detachBaremetalFromPrivateNetwork(zone: string, serverId: string, privateNetworkId: string): Promise<void>;
+    private mapPrivateNetwork;
+}

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

@@ -0,0 +1,180 @@
+"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 ScalewayVpcAdapter_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScalewayVpcAdapter = void 0;
+const common_1 = require("@nestjs/common");
+const vpc_1 = require("./generated/vpc");
+const private_network_1 = require("./generated/private-network");
+const cloud_provider_enum_1 = require("../../enums/cloud-provider.enum");
+const scaleway_iam_adapter_1 = require("./scaleway-iam.adapter");
+let ScalewayVpcAdapter = ScalewayVpcAdapter_1 = class ScalewayVpcAdapter {
+    constructor(credentialProvider, iamAdapter) {
+        this.credentialProvider = credentialProvider;
+        this.iamAdapter = iamAdapter;
+        this.logger = new common_1.Logger(ScalewayVpcAdapter_1.name);
+    }
+    // ─── VNet ID helpers ─────────────────────────────────────────────────────────
+    /** Encode region + private network UUID into a Flui vnetId */
+    buildVnetId(region, privateNetworkId) {
+        return `${region}:${privateNetworkId}`;
+    }
+    /** Decode a Flui vnetId back to { region, id } */
+    parseVnetId(vnetId) {
+        const colonIdx = vnetId.indexOf(':');
+        if (colonIdx === -1) {
+            return { region: 'fr-par', id: vnetId };
+        }
+        return {
+            region: vnetId.substring(0, colonIdx),
+            id: vnetId.substring(colonIdx + 1),
+        };
+    }
+    /** Derive region from a Scaleway zone (e.g. 'fr-par-1' → 'fr-par') */
+    zoneToRegion(zone) {
+        const parts = zone.split('-');
+        // e.g. 'fr-par-1' → ['fr','par','1'] → 'fr-par'
+        // e.g. 'nl-ams-1' → ['nl','ams','1'] → 'nl-ams'
+        // e.g. 'pl-waw-2' → ['pl','waw','2'] → 'pl-waw'
+        if (parts.length >= 3) {
+            return `${parts[0]}-${parts[1]}`;
+        }
+        return zone;
+    }
+    // ─── API factories ───────────────────────────────────────────────────────────
+    async createPrivateNetworksApi() {
+        const token = await this.credentialProvider.getActiveApiToken(cloud_provider_enum_1.CloudProvider.SCALEWAY);
+        return new vpc_1.PrivateNetworksApi(new vpc_1.Configuration({
+            baseOptions: { headers: { 'X-Auth-Token': token } },
+        }));
+    }
+    async createSubnetsApi() {
+        const token = await this.credentialProvider.getActiveApiToken(cloud_provider_enum_1.CloudProvider.SCALEWAY);
+        return new vpc_1.SubnetsApi(new vpc_1.Configuration({
+            baseOptions: { headers: { 'X-Auth-Token': token } },
+        }));
+    }
+    async createBaremetalPrivateNetworksApi() {
+        const token = await this.credentialProvider.getActiveApiToken(cloud_provider_enum_1.CloudProvider.SCALEWAY);
+        return new private_network_1.PrivateNetworksApi(new vpc_1.Configuration({
+            baseOptions: { headers: { 'X-Auth-Token': token } },
+        }));
+    }
+    // ─── Private Network (VNet) operations ──────────────────────────────────────
+    async createPrivateNetwork(region, name, tags, subnets) {
+        const projectId = await this.iamAdapter.getDefaultProjectId();
+        this.logger.log(`Creating Scaleway private network: name=${name} region=${region} project_id=${projectId} subnets=${JSON.stringify(subnets)}`);
+        const api = await this.createPrivateNetworksApi();
+        let resp;
+        try {
+            resp = await api.createPrivateNetwork(region, { name, project_id: projectId, tags, subnets });
+        }
+        catch (err) {
+            const status = err?.response?.status;
+            const detail = err?.response?.data ?? err?.message;
+            this.logger.error(`Scaleway createPrivateNetwork failed: status=${status} detail=${JSON.stringify(detail)}`);
+            throw err;
+        }
+        const pn = resp.data;
+        const ipRange = pn.subnets?.[0]?.subnet ?? subnets[0] ?? '';
+        this.logger.log(`Scaleway private network created: id=${pn.id} region=${region} ipRange=${ipRange}`);
+        return {
+            vnetId: this.buildVnetId(region, pn.id ?? ''),
+            ipRange,
+            subnets: (pn.subnets ?? []).map((s) => ({
+                ipRange: s.subnet ?? '',
+                type: 'cloud',
+                networkZone: region,
+            })),
+        };
+    }
+    async deletePrivateNetwork(region, privateNetworkId) {
+        const api = await this.createPrivateNetworksApi();
+        await api.deletePrivateNetwork(region, privateNetworkId);
+    }
+    async getPrivateNetwork(region, privateNetworkId) {
+        try {
+            const api = await this.createPrivateNetworksApi();
+            const resp = await api.getPrivateNetwork(region, privateNetworkId);
+            return this.mapPrivateNetwork(resp.data);
+        }
+        catch (e) {
+            if (e.response?.status === 404)
+                return null;
+            throw e;
+        }
+    }
+    async listPrivateNetworks(region) {
+        const api = await this.createPrivateNetworksApi();
+        const resp = await api.listPrivateNetworks(region);
+        return (resp.data.private_networks ?? []).map((pn) => this.mapPrivateNetwork(pn));
+    }
+    // ─── Subnet operations ───────────────────────────────────────────────────────
+    async addSubnets(region, privateNetworkId, subnets) {
+        const api = await this.createSubnetsApi();
+        await api.addSubnets(region, privateNetworkId, {
+            subnets,
+        });
+    }
+    async deleteSubnets(region, privateNetworkId, subnets) {
+        const api = await this.createSubnetsApi();
+        await api.deleteSubnets(region, privateNetworkId, { subnets });
+    }
+    // ─── Server attachment (Elastic Metal only) ──────────────────────────────────
+    async attachBaremetalToPrivateNetwork(zone, serverId, privateNetworkId) {
+        const api = await this.createBaremetalPrivateNetworksApi();
+        await api.addServerPrivateNetwork(zone, serverId, { private_network_id: privateNetworkId });
+        this.logger.log(`Elastic Metal server ${serverId} attached to private network ${privateNetworkId} in zone ${zone}`);
+    }
+    async detachBaremetalFromPrivateNetwork(zone, serverId, privateNetworkId) {
+        const api = await this.createBaremetalPrivateNetworksApi();
+        await api.deleteServerPrivateNetwork(zone, serverId, privateNetworkId);
+        this.logger.log(`Elastic Metal server ${serverId} detached from private network ${privateNetworkId} in zone ${zone}`);
+    }
+    // ─── Mapping helpers ─────────────────────────────────────────────────────────
+    mapPrivateNetwork(pn) {
+        const region = pn.region ?? 'fr-par';
+        const subnets = (pn.subnets ?? []).map((s) => ({
+            id: s.id,
+            ipRange: s.subnet ?? '',
+            type: 'cloud',
+            networkZone: region,
+        }));
+        return {
+            id: this.buildVnetId(region, pn.id ?? ''),
+            name: pn.name ?? '',
+            ipRange: pn.subnets?.[0]?.subnet ?? '',
+            subnets,
+            routes: [],
+            attachedServerIds: [],
+            labels: (pn.tags ?? []).reduce((acc, tag) => {
+                const eqIdx = tag.indexOf('=');
+                if (eqIdx === -1) {
+                    acc[tag] = '';
+                }
+                else {
+                    acc[tag.substring(0, eqIdx)] = tag.substring(eqIdx + 1);
+                }
+                return acc;
+            }, {}),
+            created: pn.created_at,
+        };
+    }
+};
+exports.ScalewayVpcAdapter = ScalewayVpcAdapter;
+exports.ScalewayVpcAdapter = ScalewayVpcAdapter = ScalewayVpcAdapter_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)('ICredentialProvider')),
+    __metadata("design:paramtypes", [Object, scaleway_iam_adapter_1.ScalewayIamAdapter])
+], ScalewayVpcAdapter);

package/lib/src/modules/providers/index.d.ts

@@ -0,0 +1,17 @@
+export * from './enums/cloud-provider.enum';
+export * from './enums/dns-provider.enum';
+export * from './enums/certificate-provider.enum';
+export * from './interfaces/cloud-provider.interface';
+export * from './interfaces/firewall-provider.interface';
+export * from './interfaces/dns-provider.interface';
+export * from './interfaces/certificate-provider.interface';
+export * from './interfaces/network-provider.interface';
+export * from './interfaces/credential-provider.interface';
+export * from './core/tokens';
+export * from './core/factories/provider.factory';
+export * from './core/factories/firewall-provider.factory';
+export * from './core/factories/dns-provider.factory';
+export * from './core/factories/certificate-provider.factory';
+export * from './services/credential-provider.service';
+export * from './provider-core.module';
+export * from './providers.module';

package/lib/src/modules/providers/index.js

@@ -0,0 +1,39 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Enums
+__exportStar(require("./enums/cloud-provider.enum"), exports);
+__exportStar(require("./enums/dns-provider.enum"), exports);
+__exportStar(require("./enums/certificate-provider.enum"), exports);
+// Interfaces
+__exportStar(require("./interfaces/cloud-provider.interface"), exports);
+__exportStar(require("./interfaces/firewall-provider.interface"), exports);
+__exportStar(require("./interfaces/dns-provider.interface"), exports);
+__exportStar(require("./interfaces/certificate-provider.interface"), exports);
+__exportStar(require("./interfaces/network-provider.interface"), exports);
+__exportStar(require("./interfaces/credential-provider.interface"), exports);
+// Registry tokens and registration interfaces
+__exportStar(require("./core/tokens"), exports);
+// Factories
+__exportStar(require("./core/factories/provider.factory"), exports);
+__exportStar(require("./core/factories/firewall-provider.factory"), exports);
+__exportStar(require("./core/factories/dns-provider.factory"), exports);
+__exportStar(require("./core/factories/certificate-provider.factory"), exports);
+// Services
+__exportStar(require("./services/credential-provider.service"), exports);
+// Modules
+__exportStar(require("./provider-core.module"), exports);
+__exportStar(require("./providers.module"), exports);

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

@@ -0,0 +1,38 @@
+import { DnsProvider } from '../enums/dns-provider.enum';
+export declare enum CertificateStatus {
+    PENDING = "pending",
+    ISSUING = "issuing",
+    VALID = "valid",
+    EXPIRED = "expired",
+    FAILED = "failed"
+}
+export interface CertificateInfo {
+    domain: string;
+    issuer: string;
+    status: CertificateStatus;
+    notBefore?: Date;
+    notAfter?: Date;
+    serialNumber?: string;
+}
+export interface CertificateIssuerConfig {
+    email: string;
+    server: string;
+    privateKeySecretRef: string;
+    solverType: 'dns01' | 'http01';
+    dnsProvider?: DnsProvider;
+}
+export interface CertificateManifestConfig {
+    name: string;
+    namespace: string;
+    domains: string[];
+    issuerName: string;
+    secretName: string;
+}
+export interface ICertificateProvider {
+    generateClusterIssuerManifest(config: CertificateIssuerConfig): string;
+    generateCertificateManifest(config: CertificateManifestConfig): string;
+    validateConfiguration(config: CertificateIssuerConfig): {
+        valid: boolean;
+        errors: string[];
+    };
+}

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CertificateStatus = void 0;
+var CertificateStatus;
+(function (CertificateStatus) {
+    CertificateStatus["PENDING"] = "pending";
+    CertificateStatus["ISSUING"] = "issuing";
+    CertificateStatus["VALID"] = "valid";
+    CertificateStatus["EXPIRED"] = "expired";
+    CertificateStatus["FAILED"] = "failed";
+})(CertificateStatus || (exports.CertificateStatus = CertificateStatus = {}));