@puls-dev/hcloud 0.5.3

package/dist/plugin.js

@@ -0,0 +1,43 @@
+import { registerProvider, printSection, Config } from "@puls-dev/core";
+import { listHCloudResources } from "./list.js";
+export const hcloudPlugin = {
+    name: "hcloud",
+    isConfigured: (cfg) => !!cfg?.token,
+    list: listHCloudResources,
+    render: (inv) => {
+        const costStr = inv.totalMonthlyCost > 0 ? `  ·  $${inv.totalMonthlyCost.toFixed(2)}/mo` : "";
+        printSection(`Hetzner Cloud Servers  ·  ${inv.servers.length}${costStr}`, inv.servers, [
+            { header: "Name", width: 24, render: (s) => s.name },
+            { header: "Location", width: 10, render: (s) => s.location },
+            { header: "Type", width: 10, render: (s) => s.serverType },
+            { header: "Status", width: 8, render: (s) => s.status },
+            { header: "IP", width: 15, render: (s) => s.ip ?? "-" },
+            {
+                header: "$/mo",
+                width: 8,
+                render: (s) => (s.monthlyCost > 0 ? `$${s.monthlyCost.toFixed(2)}` : "?"),
+            },
+        ]);
+        if (inv.firewalls.length > 0) {
+            printSection(`Hetzner Cloud Firewalls  ·  ${inv.firewalls.length}`, inv.firewalls, [
+                { header: "Name", width: 32, render: (f) => f.name },
+                { header: "Servers", width: 8, render: (f) => String(f.serverCount) },
+            ]);
+        }
+        if (inv.networks.length > 0) {
+            printSection(`Hetzner Cloud Networks  ·  ${inv.networks.length}`, inv.networks, [
+                { header: "Name", width: 24, render: (n) => n.name },
+                { header: "IP Range", width: 20, render: (n) => n.ipRange },
+            ]);
+        }
+    },
+    configure: (pOpts) => {
+        Config.set({
+            providers: {
+                ...Config.get().providers,
+                hcloud: pOpts,
+            },
+        });
+    }
+};
+registerProvider(hcloudPlugin);

package/dist/server.d.ts

@@ -0,0 +1,41 @@
+import { BaseBuilder, Output } from '@puls-dev/core';
+import { SSHKeyBuilder } from './ssh_key.js';
+import { NetworkBuilder } from './network.js';
+export declare class ServerBuilder extends BaseBuilder {
+    readonly out: {
+        ip: Output<string>;
+        id: Output<number>;
+    };
+    config: any;
+    private serverId?;
+    private resolvedIp?;
+    private sshKeyPath?;
+    private _sshUser?;
+    private _provision;
+    private _forceConfigCheck;
+    private _sshKeys;
+    private _networks;
+    private _userData?;
+    private log;
+    constructor(name: string);
+    private discoverServer;
+    getMonthlyCost(state?: any): number;
+    image(image: string): this;
+    location(loc: string): this;
+    serverType(type: string): this;
+    sshKey(keyPath: string): this;
+    sshUser(user: string): this;
+    private resolveUser;
+    sshKeys(keys: (SSHKeyBuilder | number | string)[]): this;
+    networks(nets: (NetworkBuilder | number)[]): this;
+    userData(data: string): this;
+    provision(...playbookPaths: (string | string[])[]): this;
+    forceConfigCheck(): this;
+    getDiff(existing: any): {
+        field: string;
+        declared: any;
+        live: any;
+    }[];
+    deploy(): Promise<any>;
+    destroy(): Promise<any>;
+}

package/dist/server.js

@@ -0,0 +1,315 @@
+import { homedir } from 'os';
+import { OS_IMAGE, LOCATION, SERVER_TYPE } from './types/hcloud.js';
+import { Config, BaseBuilder, Output, checkPort, runProvisioner, getFileHash, resourceContextStorage } from '@puls-dev/core';
+import { SSHKeyBuilder } from './ssh_key.js';
+import { NetworkBuilder } from './network.js';
+import { getHCloudApi } from './api.js';
+export class ServerBuilder extends BaseBuilder {
+    out = {
+        ip: new Output(),
+        id: new Output(),
+    };
+    config = {
+        image: OS_IMAGE.UBUNTU_24_04,
+        location: Config.get().providers.hcloud?.defaultLocation || LOCATION.NBG1,
+        server_type: SERVER_TYPE.CX22,
+    };
+    serverId;
+    resolvedIp;
+    sshKeyPath;
+    _sshUser;
+    _provision = [];
+    _forceConfigCheck = false;
+    _sshKeys = [];
+    _networks = [];
+    _userData;
+    log(msg) {
+        console.log(`   🖥️ [HCloud.Server] ${msg}`);
+    }
+    constructor(name) {
+        super(name);
+        this.discoveryPromise = this.discoverServer(name);
+    }
+    async discoverServer(name) {
+        const api = getHCloudApi();
+        const data = await api.get(`/servers?name=${encodeURIComponent(name)}`);
+        const match = data.servers.find(s => s.name === name) ?? null;
+        if (match) {
+            this.serverId = match.id;
+            this.resolvedIp = match.public_net?.ipv4?.ip;
+            if (this.serverId)
+                this.out.id.resolve(this.serverId);
+            if (this.resolvedIp)
+                this.out.ip.resolve(this.resolvedIp);
+        }
+        return match;
+    }
+    getMonthlyCost(state) {
+        const type = state ? (state.server_type?.name ?? state.server_type) : this.config.server_type;
+        const pricing = {
+            'cx22': 3.60,
+            'cpx11': 4.80,
+            'cpx21': 7.90,
+            'cpx31': 14.80,
+            'cpx41': 29.60,
+            'cpx51': 64.20,
+            'cax11': 4.00,
+            'cax21': 8.00,
+            'cax31': 16.00,
+            'cax41': 32.00,
+        };
+        return pricing[type] ?? 0;
+    }
+    image(image) {
+        this.config.image = image;
+        return this;
+    }
+    location(loc) {
+        this.config.location = loc;
+        return this;
+    }
+    serverType(type) {
+        this.config.server_type = type;
+        return this;
+    }
+    sshKey(keyPath) {
+        this.sshKeyPath = keyPath.replace('~', homedir());
+        return this;
+    }
+    sshUser(user) {
+        this._sshUser = user;
+        return this;
+    }
+    resolveUser() {
+        return (this._sshUser ??
+            process.env.HCLOUD_SSH_USER ??
+            Config.get().providers.hcloud?.sshUser ??
+            "root");
+    }
+    sshKeys(keys) {
+        this._sshKeys = keys;
+        return this;
+    }
+    networks(nets) {
+        this._networks = nets;
+        return this;
+    }
+    userData(data) {
+        this._userData = data;
+        return this;
+    }
+    provision(...playbookPaths) {
+        this._provision.push(...playbookPaths.flat());
+        return this;
+    }
+    forceConfigCheck() {
+        this._forceConfigCheck = true;
+        return this;
+    }
+    getDiff(existing) {
+        const diffs = [];
+        if (existing.server_type?.name !== this.config.server_type) {
+            diffs.push({ field: "serverType", declared: this.config.server_type, live: existing.server_type?.name });
+        }
+        if (existing.image?.name !== this.config.image && existing.image?.name !== null) {
+            // Note: Hetzner sometimes returns null image name for custom snapshots or older images
+            diffs.push({ field: "image", declared: this.config.image, live: existing.image?.name });
+        }
+        if (existing.datacenter?.location?.name !== this.config.location) {
+            diffs.push({ field: "location", declared: this.config.location, live: existing.datacenter?.location?.name });
+        }
+        return diffs;
+    }
+    async deploy() {
+        const dryRun = this.isDryRunActive();
+        const existing = await this.discoveryPromise;
+        const api = getHCloudApi();
+        const hasChanges = existing ? this.getDiff(existing).length > 0 : true;
+        if (await this.checkProtection(hasChanges))
+            return null;
+        // Provisioning Calculations
+        const labels = existing?.labels ?? {};
+        const appliedHashes = {};
+        for (const [k, v] of Object.entries(labels)) {
+            if (k.startsWith("puls-h-")) {
+                const playbookSlug = k.substring(7);
+                appliedHashes[playbookSlug] = v;
+            }
+        }
+        const declaredPlaybooksWithHashes = this._provision.map((p) => {
+            const baseName = p.split("/").pop() ?? p;
+            const slug = baseName.toLowerCase().replace(/[^a-z0-9_-]/g, '-');
+            return { path: p, slug, hash: getFileHash(p) };
+        });
+        const playbooksToRun = this._forceConfigCheck
+            ? declaredPlaybooksWithHashes
+            : declaredPlaybooksWithHashes.filter((p) => {
+                const appliedHash = appliedHashes[p.slug];
+                return !appliedHash || appliedHash !== p.hash;
+            });
+        const playbookRunRequired = playbooksToRun.length > 0;
+        if (dryRun) {
+            this.log(`Planning server "${this.name}"...`);
+            if (!existing) {
+                this.log(`[PLAN] Create server ${this.name} (${this.config.server_type} in ${this.config.location})`);
+                if (this._provision.length > 0) {
+                    this.log(`      └─ Provision: ${this._provision.join(", ")}`);
+                }
+                this.out.id.resolve(-1);
+                this.out.ip.resolve('0.0.0.0');
+            }
+            else if (hasChanges || playbookRunRequired) {
+                if (hasChanges) {
+                    const diffs = this.getDiff(existing);
+                    this.log(`[PLAN] Recreate server ${this.name} due to changes:`);
+                    for (const d of diffs) {
+                        this.log(`      └─ ${d.field}: ${d.live} -> ${d.declared}`);
+                    }
+                }
+                if (playbookRunRequired) {
+                    this.log(`[PLAN] Run ${playbooksToRun.length} playbook changes on existing server:`);
+                    for (const p of playbooksToRun) {
+                        this.log(`      └─ Playbook: ${p.path}`);
+                    }
+                }
+            }
+            else {
+                this.log(`Server is up to date.`);
+            }
+            for (const sidecar of this.sidecars)
+                await sidecar.deploy();
+            return this.config;
+        }
+        this.log(`Finalizing server...`);
+        if (!existing || hasChanges) {
+            if (existing && hasChanges) {
+                this.log(`Server has drifted or changed critical fields. Re-creating...`);
+                await api.delete(`/servers/${existing.id}`);
+                await this.waitFor('server deletion to complete', async () => {
+                    try {
+                        const res = await api.get(`/servers?name=${encodeURIComponent(this.name)}`);
+                        return !res.servers.some(s => s.name === this.name);
+                    }
+                    catch {
+                        return true;
+                    }
+                });
+            }
+            // Resolve SSH Keys
+            const sshKeys = [];
+            for (const k of this._sshKeys) {
+                if (k instanceof SSHKeyBuilder) {
+                    sshKeys.push(await k.out.id.get());
+                }
+                else {
+                    sshKeys.push(k);
+                }
+            }
+            // Resolve Networks
+            const networks = [];
+            for (const n of this._networks) {
+                if (n instanceof NetworkBuilder) {
+                    networks.push(await n.out.id.get());
+                }
+                else {
+                    networks.push(n);
+                }
+            }
+            // Create labels for initial playbooks
+            const initialLabels = {};
+            for (const p of declaredPlaybooksWithHashes) {
+                initialLabels[`puls-h-${p.slug}`] = p.hash;
+            }
+            const payload = {
+                name: this.name,
+                server_type: this.config.server_type,
+                image: this.config.image,
+                location: this.config.location,
+                labels: initialLabels,
+            };
+            if (sshKeys.length > 0)
+                payload.ssh_keys = sshKeys;
+            if (networks.length > 0)
+                payload.networks = networks;
+            if (this._userData)
+                payload.user_data = this._userData;
+            const res = await api.post('/servers', payload);
+            this.serverId = res.server.id;
+            this.out.id.resolve(res.server.id);
+            this.log(`Created server with ID ${this.serverId}. Waiting for action ${res.action.id}...`);
+            await api.waitForAction(res.action.id);
+            // Fetch server details to get IP
+            const s = await api.get(`/servers/${this.serverId}`);
+            this.resolvedIp = s.server.public_net?.ipv4?.ip;
+            if (this.resolvedIp) {
+                this.out.ip.resolve(this.resolvedIp);
+                this.log(`Server IP is ${this.resolvedIp}`);
+            }
+            if (this._provision.length > 0 && this.resolvedIp) {
+                await this.waitFor(`SSH on ${this.resolvedIp} to be ready`, () => checkPort(this.resolvedIp, 22), { intervalMs: 10_000, timeoutMs: 300_000 });
+                for (const playbook of this._provision) {
+                    const keyPath = this.sshKeyPath ? this.sshKeyPath : undefined;
+                    await runProvisioner(this.resolvedIp, this.resolveUser(), keyPath, playbook);
+                }
+            }
+        }
+        else {
+            // Existing server, no critical changes, check for playbook runs
+            if (playbookRunRequired) {
+                this.log(`Running ${playbooksToRun.length} playbook changes...`);
+                if (!this.resolvedIp) {
+                    throw new Error(`IP not resolved for existing server "${this.name}"`);
+                }
+                await this.waitFor(`SSH on ${this.resolvedIp} to be ready`, () => checkPort(this.resolvedIp, 22), { intervalMs: 10_000, timeoutMs: 300_000 });
+                const currentLabels = { ...existing.labels };
+                for (const p of playbooksToRun) {
+                    const keyPath = this.sshKeyPath ? this.sshKeyPath : undefined;
+                    await runProvisioner(this.resolvedIp, this.resolveUser(), keyPath, p.path);
+                    currentLabels[`puls-h-${p.slug}`] = p.hash;
+                    // Update labels on Hetzner Cloud Server
+                    await api.put(`/servers/${this.serverId}`, { labels: currentLabels });
+                }
+                this.log(`Playbooks applied successfully and metadata updated.`);
+            }
+            else {
+                this.log(`Server is up to date.`);
+            }
+        }
+        // Register host in context for downstream playbooks
+        const context = resourceContextStorage.getStore();
+        if (context && context.hosts) {
+            const activeIp = this.resolvedIp ?? "0.0.0.0";
+            if (!context.hosts.some(h => h.name === this.name)) {
+                context.hosts.push({
+                    name: this.name,
+                    ip: activeIp,
+                    user: this.resolveUser(),
+                    sshKey: this.sshKeyPath,
+                    provider: "hcloud"
+                });
+            }
+        }
+        for (const sidecar of this.sidecars)
+            await sidecar.deploy();
+        return this.config;
+    }
+    async destroy() {
+        const dryRun = this.isDryRunActive();
+        await this.discoveryPromise;
+        if (!this.serverId) {
+            this.log(`Server not found, skipping destroy.`);
+            return { destroyed: null };
+        }
+        this.log(`Destroying server (id=${this.serverId})...`);
+        if (dryRun) {
+            this.log(`[PLAN] Would delete server id=${this.serverId}`);
+        }
+        else {
+            const api = getHCloudApi();
+            await api.delete(`/servers/${this.serverId}`);
+            this.log(`Deleted server.`);
+        }
+        await this.destroySidecars();
+        return { destroyed: this.name };
+    }
+}

package/dist/server.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server.test.js

@@ -0,0 +1,263 @@
+import { test, describe, beforeEach, afterEach, mock } from 'node:test';
+import assert from 'node:assert';
+import fs from 'node:fs';
+import { ServerBuilder } from './server.js';
+import { Config } from '@puls-dev/core';
+import { OS_IMAGE, LOCATION, SERVER_TYPE } from './types/hcloud.js';
+describe('ServerBuilder Unit Tests', () => {
+    let originalFetch;
+    let fetchCalls = [];
+    let mockResponses = {};
+    beforeEach(() => {
+        Config.set({
+            dryRun: false,
+            providers: {
+                hcloud: { token: 'fake-hcloud-token', defaultLocation: 'nbg1' }
+            }
+        });
+        originalFetch = globalThis.fetch;
+        fetchCalls = [];
+        mockResponses = {};
+        // Default mock response so discovery doesn't fail by default
+        mockResponses['GET /servers'] = {
+            status: 200,
+            body: { servers: [] }
+        };
+        globalThis.fetch = async (input, init) => {
+            const url = String(input);
+            const method = init?.method ?? 'GET';
+            const body = init?.body ? JSON.parse(init.body) : undefined;
+            const headers = init?.headers;
+            fetchCalls.push({ url, method, body, headers });
+            const matchKey = Object.keys(mockResponses)
+                .filter(key => {
+                const [mMethod, mPath] = key.split(' ');
+                return method === mMethod && url.includes(mPath);
+            })
+                .sort((a, b) => b.split(' ')[1].length - a.split(' ')[1].length)[0];
+            if (matchKey) {
+                const resp = mockResponses[matchKey];
+                return {
+                    ok: resp.status >= 200 && resp.status < 300,
+                    status: resp.status,
+                    json: async () => resp.body,
+                    text: async () => JSON.stringify(resp.body),
+                };
+            }
+            return {
+                ok: false,
+                status: 404,
+                json: async () => ({ error: { message: 'Not found' } }),
+                text: async () => 'Not found',
+            };
+        };
+        // Mock readFileSync so tests don't hit the real filesystem for SSH keys
+        mock.method(fs, 'readFileSync', () => {
+            return 'ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIL... test@example.com';
+        });
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+        mock.restoreAll();
+    });
+    test('gracefully handles discovery when server does not exist', async () => {
+        const builder = new ServerBuilder('my-server');
+        const discoveryResult = await builder.discoveryPromise;
+        assert.strictEqual(discoveryResult, null);
+        assert.strictEqual(fetchCalls.length, 1);
+        assert.strictEqual(fetchCalls[0].method, 'GET');
+        assert.ok(fetchCalls[0].url.includes('/servers?name=my-server'));
+    });
+    test('discovers server successfully when it exists', async () => {
+        mockResponses['GET /servers'] = {
+            status: 200,
+            body: {
+                servers: [
+                    {
+                        id: 123,
+                        name: 'my-server',
+                        public_net: {
+                            ipv4: { ip: '1.2.3.4' }
+                        },
+                        server_type: { name: 'cx22' },
+                        image: { name: 'ubuntu-24.04' },
+                        datacenter: { location: { name: 'nbg1' } }
+                    }
+                ]
+            }
+        };
+        const builder = new ServerBuilder('my-server');
+        const discoveryResult = await builder.discoveryPromise;
+        assert.ok(discoveryResult);
+        assert.strictEqual(discoveryResult.id, 123);
+        assert.strictEqual(await builder.out.ip.get(), '1.2.3.4');
+        assert.strictEqual(await builder.out.id.get(), 123);
+    });
+    test('calculates correct monthly cost', async () => {
+        const builder = new ServerBuilder('my-server');
+        await builder.discoveryPromise;
+        builder.serverType(SERVER_TYPE.CX22);
+        assert.strictEqual(builder.getMonthlyCost(), 3.60);
+        builder.serverType(SERVER_TYPE.CPX31);
+        assert.strictEqual(builder.getMonthlyCost(), 14.80);
+    });
+    test('creates a server when it does not exist', async () => {
+        mockResponses['POST /servers'] = {
+            status: 201,
+            body: {
+                server: {
+                    id: 456,
+                    name: 'new-server',
+                    public_net: { ipv4: { ip: '5.6.7.8' } }
+                },
+                action: { id: 7890 }
+            }
+        };
+        mockResponses['GET /actions/7890'] = {
+            status: 200,
+            body: { action: { status: 'success' } }
+        };
+        mockResponses['GET /servers/456'] = {
+            status: 200,
+            body: {
+                server: {
+                    id: 456,
+                    name: 'new-server',
+                    public_net: { ipv4: { ip: '5.6.7.8' } }
+                }
+            }
+        };
+        const builder = new ServerBuilder('new-server')
+            .serverType(SERVER_TYPE.CX22)
+            .image(OS_IMAGE.UBUNTU_24_04)
+            .location(LOCATION.NBG1);
+        await builder.deploy();
+        assert.strictEqual(await builder.out.id.get(), 456);
+        assert.strictEqual(await builder.out.ip.get(), '5.6.7.8');
+        const postCall = fetchCalls.find(c => c.method === 'POST' && c.url.includes('/servers'));
+        assert.ok(postCall);
+        assert.strictEqual(postCall.body.name, 'new-server');
+        assert.strictEqual(postCall.body.server_type, 'cx22');
+        assert.strictEqual(postCall.body.image, 'ubuntu-24.04');
+        assert.strictEqual(postCall.body.location, 'nbg1');
+    });
+    test('detects drift and recreates server', async () => {
+        let serverExists = true;
+        globalThis.fetch = async (input, init) => {
+            const url = String(input);
+            const method = init?.method ?? 'GET';
+            const body = init?.body ? JSON.parse(init.body) : undefined;
+            fetchCalls.push({ url, method, body });
+            if (method === 'DELETE' && url.includes('/servers/123')) {
+                serverExists = false;
+                return {
+                    ok: true,
+                    status: 200,
+                    json: async () => ({})
+                };
+            }
+            if (method === 'GET' && url.includes('/servers')) {
+                if (url.includes('/servers/456')) {
+                    return {
+                        ok: true,
+                        status: 200,
+                        json: async () => ({
+                            server: {
+                                id: 456,
+                                name: 'my-server',
+                                public_net: { ipv4: { ip: '5.6.7.8' } }
+                            }
+                        })
+                    };
+                }
+                if (serverExists) {
+                    return {
+                        ok: true,
+                        status: 200,
+                        json: async () => ({
+                            servers: [
+                                {
+                                    id: 123,
+                                    name: 'my-server',
+                                    public_net: { ipv4: { ip: '1.2.3.4' } },
+                                    server_type: { name: 'cpx11' },
+                                    image: { name: 'ubuntu-22.04' },
+                                    datacenter: { location: { name: 'nbg1' } }
+                                }
+                            ]
+                        })
+                    };
+                }
+                else {
+                    return {
+                        ok: true,
+                        status: 200,
+                        json: async () => ({ servers: [] })
+                    };
+                }
+            }
+            if (method === 'POST' && url.includes('/servers')) {
+                return {
+                    ok: true,
+                    status: 201,
+                    json: async () => ({
+                        server: {
+                            id: 456,
+                            name: 'my-server',
+                            public_net: { ipv4: { ip: '5.6.7.8' } }
+                        },
+                        action: { id: 7890 }
+                    })
+                };
+            }
+            if (method === 'GET' && url.includes('/actions/7890')) {
+                return {
+                    ok: true,
+                    status: 200,
+                    json: async () => ({ action: { status: 'success' } })
+                };
+            }
+            return {
+                ok: false,
+                status: 404,
+                json: async () => ({ error: { message: 'Not found' } }),
+            };
+        };
+        const builder = new ServerBuilder('my-server')
+            .serverType(SERVER_TYPE.CX22)
+            .image(OS_IMAGE.UBUNTU_24_04)
+            .location(LOCATION.NBG1);
+        await builder.deploy();
+        const deleteCall = fetchCalls.find(c => c.method === 'DELETE' && c.url.includes('/servers/123'));
+        assert.ok(deleteCall);
+        const postCall = fetchCalls.find(c => c.method === 'POST' && c.url.includes('/servers'));
+        assert.ok(postCall);
+        assert.strictEqual(postCall.body.server_type, 'cx22');
+        assert.strictEqual(postCall.body.image, 'ubuntu-24.04');
+    });
+    test('destroys a server when it exists', async () => {
+        mockResponses['GET /servers'] = {
+            status: 200,
+            body: {
+                servers: [
+                    {
+                        id: 123,
+                        name: 'my-server',
+                        public_net: { ipv4: { ip: '1.2.3.4' } },
+                        server_type: { name: 'cx22' },
+                        image: { name: 'ubuntu-24.04' },
+                        datacenter: { location: { name: 'nbg1' } }
+                    }
+                ]
+            }
+        };
+        mockResponses['DELETE /servers/123'] = {
+            status: 200,
+            body: {}
+        };
+        const builder = new ServerBuilder('my-server');
+        await builder.destroy();
+        const deleteCall = fetchCalls.find(c => c.method === 'DELETE' && c.url.includes('/servers/123'));
+        assert.ok(deleteCall);
+    });
+});

package/dist/ssh_key.d.ts

@@ -0,0 +1,21 @@
+import { BaseBuilder } from '@puls-dev/core';
+import { Output } from '@puls-dev/core';
+export declare class SSHKeyBuilder extends BaseBuilder {
+    readonly out: {
+        id: Output<number>;
+        fingerprint: Output<string>;
+    };
+    private _publicKey?;
+    private keyId?;
+    private log;
+    constructor(name: string);
+    private discoverKey;
+    publicKey(key: string): this;
+    getDiff(existing: any): {
+        field: string;
+        declared: string;
+        live: any;
+    }[];
+    deploy(): Promise<void>;
+    destroy(): Promise<void>;
+}