hetzner-cli 2.0.0

package/dist/cloud/commands/certificate.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerCertificateCommands(parent: Command): void;

package/dist/cloud/commands/certificate.js

@@ -0,0 +1,77 @@
+import { readFileSync } from 'node:fs';
+import { cloudAction, cloudOutput, cloudConfirm } from '../helpers.js';
+import * as fmt from '../../shared/formatter.js';
+import * as cloudFmt from '../formatter.js';
+export function registerCertificateCommands(parent) {
+    const cert = parent.command('certificate').description('Certificate management');
+    cert.command('list').alias('ls').description('List all certificates')
+        .option('-l, --label-selector <selector>', 'Label selector')
+        .option('-s, --sort <field>', 'Sort by field')
+        .option('--type <type>', 'Filter by type (uploaded, managed)')
+        .action(cloudAction(async (client, options) => {
+        const certs = await client.listCertificates({ label_selector: options.labelSelector, sort: options.sort, type: options.type });
+        cloudOutput(certs, cloudFmt.formatCertificateList, options);
+    }));
+    cert.command('describe <id>').description('Show certificate details')
+        .action(cloudAction(async (client, id, options) => {
+        const certificate = await client.getCertificate(parseInt(id));
+        cloudOutput(certificate, cloudFmt.formatCertificateDetails, options);
+    }));
+    cert.command('create').description('Create a certificate')
+        .requiredOption('--name <name>', 'Certificate name')
+        .option('--type <type>', 'Certificate type (uploaded, managed)', 'uploaded')
+        .option('--cert-file <path>', 'Path to certificate PEM file (for uploaded)')
+        .option('--key-file <path>', 'Path to private key PEM file (for uploaded)')
+        .option('--domain <domains...>', 'Domain names (for managed)')
+        .action(cloudAction(async (client, options) => {
+        const createOpts = {
+            name: options.name,
+            type: options.type,
+        };
+        if (options.type === 'managed') {
+            if (!options.domain || options.domain.length === 0) {
+                console.error(fmt.error('Managed certificates require --domain'));
+                process.exit(1);
+            }
+            createOpts.domain_names = options.domain;
+        }
+        else {
+            if (!options.certFile || !options.keyFile) {
+                console.error(fmt.error('Uploaded certificates require --cert-file and --key-file'));
+                process.exit(1);
+            }
+            createOpts.certificate = readFileSync(options.certFile, 'utf-8');
+            createOpts.private_key = readFileSync(options.keyFile, 'utf-8');
+        }
+        const { certificate: created } = await client.createCertificate(createOpts);
+        console.log(fmt.success(`Certificate '${created.name}' created (ID: ${created.id})`));
+    }));
+    cert.command('delete <id>').description('Delete a certificate')
+        .option('-y, --yes', 'Skip confirmation')
+        .action(cloudAction(async (client, id, options) => {
+        if (!await cloudConfirm(`Delete certificate ${id}?`, options))
+            return;
+        await client.deleteCertificate(parseInt(id));
+        console.log(fmt.success(`Certificate ${id} deleted.`));
+    }));
+    cert.command('update <id>').description('Update certificate')
+        .option('--name <name>', 'New name')
+        .action(cloudAction(async (client, id, options) => {
+        await client.updateCertificate(parseInt(id), { name: options.name });
+        console.log(fmt.success(`Certificate ${id} updated.`));
+    }));
+    cert.command('add-label <id> <label>').description('Add a label (key=value)')
+        .action(cloudAction(async (client, id, label) => {
+        const certificate = await client.getCertificate(parseInt(id));
+        const [key, value] = label.split('=');
+        await client.updateCertificate(parseInt(id), { labels: { ...certificate.labels, [key]: value || '' } });
+        console.log(fmt.success(`Label '${key}' added.`));
+    }));
+    cert.command('remove-label <id> <key>').description('Remove a label')
+        .action(cloudAction(async (client, id, key) => {
+        const certificate = await client.getCertificate(parseInt(id));
+        const labels = Object.fromEntries(Object.entries(certificate.labels).filter(([k]) => k !== key));
+        await client.updateCertificate(parseInt(id), { labels });
+        console.log(fmt.success(`Label '${key}' removed.`));
+    }));
+}

package/dist/cloud/commands/context.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerContextCommands(parent: Command): void;

package/dist/cloud/commands/context.js

@@ -0,0 +1,78 @@
+import { password as passwordPrompt } from '@inquirer/prompts';
+import * as fmt from '../../shared/formatter.js';
+import { createContext, useContext, deleteContext, listContexts, getActiveContext, } from '../context.js';
+import { formatContextList } from '../formatter.js';
+export function registerContextCommands(parent) {
+    const context = parent.command('context').description('Cloud context (token) management');
+    context
+        .command('create <name>')
+        .description('Create a new cloud context')
+        .option('-t, --token <token>', 'API token (will prompt if not provided)')
+        .action(async (name, options) => {
+        try {
+            let token = options.token;
+            if (!token) {
+                token = await passwordPrompt({
+                    message: `Enter Hetzner Cloud API token for '${name}':`,
+                    validate: (v) => v.length > 0 || 'Token is required',
+                });
+            }
+            await createContext(name, token);
+            console.log(fmt.success(`Context '${name}' created and activated.`));
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'ExitPromptError') {
+                process.exit(0);
+            }
+            console.error(fmt.error(error instanceof Error ? error.message : 'Unknown error'));
+            process.exit(1);
+        }
+    });
+    context
+        .command('use <name>')
+        .description('Switch to a different cloud context')
+        .action((name) => {
+        try {
+            useContext(name);
+            console.log(fmt.success(`Switched to context '${name}'.`));
+        }
+        catch (error) {
+            console.error(fmt.error(error instanceof Error ? error.message : 'Unknown error'));
+            process.exit(1);
+        }
+    });
+    context
+        .command('delete <name>')
+        .alias('rm')
+        .description('Delete a cloud context')
+        .action(async (name) => {
+        try {
+            await deleteContext(name);
+            console.log(fmt.success(`Context '${name}' deleted.`));
+        }
+        catch (error) {
+            console.error(fmt.error(error instanceof Error ? error.message : 'Unknown error'));
+            process.exit(1);
+        }
+    });
+    context
+        .command('list')
+        .alias('ls')
+        .description('List all cloud contexts')
+        .action(() => {
+        const contexts = listContexts();
+        console.log(formatContextList(contexts));
+    });
+    context
+        .command('active')
+        .description('Show the active cloud context')
+        .action(() => {
+        const active = getActiveContext();
+        if (active) {
+            console.log(fmt.success(`Active context: ${active}`));
+        }
+        else {
+            console.log(fmt.warning('No active context. Run: hetzner cloud context create'));
+        }
+    });
+}

package/dist/cloud/commands/datacenter.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerDatacenterCommands(parent: Command): void;

package/dist/cloud/commands/datacenter.js

@@ -0,0 +1,20 @@
+import { cloudAction, cloudOutput } from '../helpers.js';
+import * as cloudFmt from '../formatter.js';
+export function registerDatacenterCommands(parent) {
+    const datacenter = parent.command('datacenter').description('Datacenter information');
+    datacenter
+        .command('list')
+        .alias('ls')
+        .description('List all datacenters')
+        .action(cloudAction(async (client, options) => {
+        const datacenters = await client.listDatacenters();
+        cloudOutput(datacenters, cloudFmt.formatDatacenterList, options);
+    }));
+    datacenter
+        .command('describe <id>')
+        .description('Show datacenter details')
+        .action(cloudAction(async (client, id, options) => {
+        const datacenter = await client.getDatacenter(parseInt(id));
+        cloudOutput(datacenter, cloudFmt.formatDatacenterDetails, options);
+    }));
+}

package/dist/cloud/commands/firewall.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerCloudFirewallCommands(parent: Command): void;

package/dist/cloud/commands/firewall.js

@@ -0,0 +1,77 @@
+import { cloudAction, cloudOutput, cloudConfirm } from '../helpers.js';
+import * as fmt from '../../shared/formatter.js';
+import * as cloudFmt from '../formatter.js';
+export function registerCloudFirewallCommands(parent) {
+    const firewall = parent.command('firewall').description('Cloud firewall management');
+    firewall.command('list').alias('ls').description('List all firewalls')
+        .option('-l, --label-selector <selector>', 'Label selector')
+        .action(cloudAction(async (client, options) => {
+        const firewalls = await client.listFirewalls({ label_selector: options.labelSelector });
+        cloudOutput(firewalls, cloudFmt.formatCloudFirewallList, options);
+    }));
+    firewall.command('describe <id>').description('Show firewall details')
+        .action(cloudAction(async (client, id, options) => {
+        const fw = await client.getFirewall(parseInt(id));
+        cloudOutput(fw, cloudFmt.formatCloudFirewallDetails, options);
+    }));
+    firewall.command('create').description('Create a firewall')
+        .requiredOption('--name <name>', 'Firewall name')
+        .action(cloudAction(async (client, options) => {
+        const { firewall: fw } = await client.createFirewall({ name: options.name });
+        console.log(fmt.success(`Firewall '${fw.name}' created (ID: ${fw.id})`));
+    }));
+    firewall.command('delete <id>').description('Delete a firewall')
+        .option('-y, --yes', 'Skip confirmation')
+        .action(cloudAction(async (client, id, options) => {
+        if (!await cloudConfirm(`Delete firewall ${id}?`, options))
+            return;
+        await client.deleteFirewall(parseInt(id));
+        console.log(fmt.success(`Firewall ${id} deleted.`));
+    }));
+    firewall.command('update <id>').description('Update firewall')
+        .option('--name <name>', 'New name')
+        .action(cloudAction(async (client, id, options) => {
+        await client.updateFirewall(parseInt(id), { name: options.name });
+        console.log(fmt.success(`Firewall ${id} updated.`));
+    }));
+    firewall.command('apply-to-resource <id>').description('Apply firewall to resource')
+        .requiredOption('--type <type>', 'Resource type (server, label_selector)')
+        .option('--server <server>', 'Server ID')
+        .option('--label-selector <selector>', 'Label selector')
+        .action(cloudAction(async (client, id, options) => {
+        const applyTo = [{
+                type: options.type,
+                ...(options.server ? { server: { id: parseInt(options.server) } } : {}),
+                ...(options.labelSelector ? { label_selector: { selector: options.labelSelector } } : {}),
+            }];
+        await client.applyFirewall(parseInt(id), applyTo);
+        console.log(fmt.success(`Firewall ${id} applied.`));
+    }));
+    firewall.command('remove-from-resource <id>').description('Remove firewall from resource')
+        .requiredOption('--type <type>', 'Resource type (server, label_selector)')
+        .option('--server <server>', 'Server ID')
+        .option('--label-selector <selector>', 'Label selector')
+        .action(cloudAction(async (client, id, options) => {
+        const removeFrom = [{
+                type: options.type,
+                ...(options.server ? { server: { id: parseInt(options.server) } } : {}),
+                ...(options.labelSelector ? { label_selector: { selector: options.labelSelector } } : {}),
+            }];
+        await client.removeFirewallFromResources(parseInt(id), removeFrom);
+        console.log(fmt.success(`Firewall ${id} removed from resource.`));
+    }));
+    firewall.command('add-label <id> <label>').description('Add a label (key=value)')
+        .action(cloudAction(async (client, id, label) => {
+        const fw = await client.getFirewall(parseInt(id));
+        const [key, value] = label.split('=');
+        await client.updateFirewall(parseInt(id), { labels: { ...fw.labels, [key]: value || '' } });
+        console.log(fmt.success(`Label '${key}' added.`));
+    }));
+    firewall.command('remove-label <id> <key>').description('Remove a label')
+        .action(cloudAction(async (client, id, key) => {
+        const fw = await client.getFirewall(parseInt(id));
+        const labels = Object.fromEntries(Object.entries(fw.labels).filter(([k]) => k !== key));
+        await client.updateFirewall(parseInt(id), { labels });
+        console.log(fmt.success(`Label '${key}' removed.`));
+    }));
+}

package/dist/cloud/commands/floating-ip.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerFloatingIpCommands(parent: Command): void;

package/dist/cloud/commands/floating-ip.js

@@ -0,0 +1,83 @@
+import { cloudAction, cloudOutput, cloudConfirm } from '../helpers.js';
+import * as fmt from '../../shared/formatter.js';
+import * as cloudFmt from '../formatter.js';
+export function registerFloatingIpCommands(parent) {
+    const fip = parent.command('floating-ip').description('Floating IP management');
+    fip.command('list').alias('ls').description('List all floating IPs')
+        .option('-l, --label-selector <selector>', 'Label selector')
+        .action(cloudAction(async (client, options) => {
+        const ips = await client.listFloatingIps({ label_selector: options.labelSelector });
+        cloudOutput(ips, cloudFmt.formatFloatingIpList, options);
+    }));
+    fip.command('describe <id>').description('Show floating IP details')
+        .action(cloudAction(async (client, id, options) => {
+        const ip = await client.getFloatingIp(parseInt(id));
+        cloudOutput(ip, cloudFmt.formatFloatingIpDetails, options);
+    }));
+    fip.command('create').description('Create a floating IP')
+        .requiredOption('--type <type>', 'IP type (ipv4, ipv6)')
+        .option('--name <name>', 'Name')
+        .option('--description <desc>', 'Description')
+        .option('--home-location <loc>', 'Home location')
+        .option('--server <id>', 'Server to assign to')
+        .action(cloudAction(async (client, options) => {
+        const { floating_ip: ip } = await client.createFloatingIp({ type: options.type, name: options.name, description: options.description, home_location: options.homeLocation, server: options.server ? parseInt(options.server) : undefined });
+        console.log(fmt.success(`Floating IP created (ID: ${ip.id}, IP: ${ip.ip})`));
+    }));
+    fip.command('delete <id>').description('Delete a floating IP')
+        .option('-y, --yes', 'Skip confirmation')
+        .action(cloudAction(async (client, id, options) => {
+        if (!await cloudConfirm(`Delete floating IP ${id}?`, options))
+            return;
+        await client.deleteFloatingIp(parseInt(id));
+        console.log(fmt.success(`Floating IP ${id} deleted.`));
+    }));
+    fip.command('update <id>').description('Update floating IP')
+        .option('--name <name>', 'New name')
+        .option('--description <desc>', 'New description')
+        .action(cloudAction(async (client, id, options) => {
+        await client.updateFloatingIp(parseInt(id), { name: options.name, description: options.description });
+        console.log(fmt.success(`Floating IP ${id} updated.`));
+    }));
+    fip.command('assign <id> <server>').description('Assign floating IP to server')
+        .action(cloudAction(async (client, id, server) => {
+        await client.assignFloatingIp(parseInt(id), parseInt(server));
+        console.log(fmt.success(`Floating IP ${id} assigned to server ${server}.`));
+    }));
+    fip.command('unassign <id>').description('Unassign floating IP')
+        .action(cloudAction(async (client, id) => {
+        await client.unassignFloatingIp(parseInt(id));
+        console.log(fmt.success(`Floating IP ${id} unassigned.`));
+    }));
+    fip.command('enable-protection <id>').description('Enable delete protection')
+        .action(cloudAction(async (client, id) => {
+        await client.changeFloatingIpProtection(parseInt(id), true);
+        console.log(fmt.success(`Protection enabled for floating IP ${id}.`));
+    }));
+    fip.command('disable-protection <id>').description('Disable delete protection')
+        .action(cloudAction(async (client, id) => {
+        await client.changeFloatingIpProtection(parseInt(id), false);
+        console.log(fmt.success(`Protection disabled for floating IP ${id}.`));
+    }));
+    fip.command('set-rdns <id>').description('Set reverse DNS')
+        .requiredOption('--ip <ip>', 'IP address')
+        .requiredOption('--dns-ptr <ptr>', 'DNS pointer (empty to reset)')
+        .action(cloudAction(async (client, id, options) => {
+        await client.changeFloatingIpDnsPtr(parseInt(id), options.ip, options.dnsPtr || null);
+        console.log(fmt.success('rDNS updated.'));
+    }));
+    fip.command('add-label <id> <label>').description('Add a label (key=value)')
+        .action(cloudAction(async (client, id, label) => {
+        const ip = await client.getFloatingIp(parseInt(id));
+        const [key, value] = label.split('=');
+        await client.updateFloatingIp(parseInt(id), { labels: { ...ip.labels, [key]: value || '' } });
+        console.log(fmt.success(`Label '${key}' added.`));
+    }));
+    fip.command('remove-label <id> <key>').description('Remove a label')
+        .action(cloudAction(async (client, id, key) => {
+        const ip = await client.getFloatingIp(parseInt(id));
+        const labels = Object.fromEntries(Object.entries(ip.labels).filter(([k]) => k !== key));
+        await client.updateFloatingIp(parseInt(id), { labels });
+        console.log(fmt.success(`Label '${key}' removed.`));
+    }));
+}

package/dist/cloud/commands/image.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerImageCommands(parent: Command): void;

package/dist/cloud/commands/image.js

@@ -0,0 +1,60 @@
+import { cloudAction, cloudOutput, cloudConfirm } from '../helpers.js';
+import * as fmt from '../../shared/formatter.js';
+import * as cloudFmt from '../formatter.js';
+export function registerImageCommands(parent) {
+    const image = parent.command('image').description('Image management');
+    image.command('list').alias('ls').description('List all images')
+        .option('-l, --label-selector <selector>', 'Label selector')
+        .option('-s, --sort <field>', 'Sort by field')
+        .option('--type <type>', 'Filter by type (system, snapshot, backup, app)')
+        .option('--architecture <arch>', 'Filter by architecture (x86, arm)')
+        .option('--status <status>', 'Filter by status')
+        .action(cloudAction(async (client, options) => {
+        const images = await client.listImages({ label_selector: options.labelSelector, sort: options.sort, type: options.type, architecture: options.architecture, status: options.status });
+        cloudOutput(images, cloudFmt.formatImageList, options);
+    }));
+    image.command('describe <id>').description('Show image details')
+        .action(cloudAction(async (client, id, options) => {
+        const img = await client.getImage(parseInt(id));
+        cloudOutput(img, cloudFmt.formatImageDetails, options);
+    }));
+    image.command('update <id>').description('Update image')
+        .option('--description <desc>', 'New description')
+        .option('--type <type>', 'New type (snapshot)')
+        .action(cloudAction(async (client, id, options) => {
+        await client.updateImage(parseInt(id), { description: options.description, type: options.type });
+        console.log(fmt.success(`Image ${id} updated.`));
+    }));
+    image.command('delete <id>').description('Delete an image')
+        .option('-y, --yes', 'Skip confirmation')
+        .action(cloudAction(async (client, id, options) => {
+        if (!await cloudConfirm(`Delete image ${id}?`, options))
+            return;
+        await client.deleteImage(parseInt(id));
+        console.log(fmt.success(`Image ${id} deleted.`));
+    }));
+    image.command('enable-protection <id>').description('Enable delete protection')
+        .action(cloudAction(async (client, id) => {
+        await client.changeImageProtection(parseInt(id), true);
+        console.log(fmt.success(`Protection enabled for image ${id}.`));
+    }));
+    image.command('disable-protection <id>').description('Disable delete protection')
+        .action(cloudAction(async (client, id) => {
+        await client.changeImageProtection(parseInt(id), false);
+        console.log(fmt.success(`Protection disabled for image ${id}.`));
+    }));
+    image.command('add-label <id> <label>').description('Add a label (key=value)')
+        .action(cloudAction(async (client, id, label) => {
+        const img = await client.getImage(parseInt(id));
+        const [key, value] = label.split('=');
+        await client.updateImage(parseInt(id), { labels: { ...img.labels, [key]: value || '' } });
+        console.log(fmt.success(`Label '${key}' added.`));
+    }));
+    image.command('remove-label <id> <key>').description('Remove a label')
+        .action(cloudAction(async (client, id, key) => {
+        const img = await client.getImage(parseInt(id));
+        const labels = Object.fromEntries(Object.entries(img.labels).filter(([k]) => k !== key));
+        await client.updateImage(parseInt(id), { labels });
+        console.log(fmt.success(`Label '${key}' removed.`));
+    }));
+}

package/dist/cloud/commands/index.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerCloudCommands(parent: Command): void;

package/dist/cloud/commands/index.js

@@ -0,0 +1,41 @@
+import { registerContextCommands } from './context.js';
+import { registerDatacenterCommands } from './datacenter.js';
+import { registerLocationCommands } from './location.js';
+import { registerServerTypeCommands } from './server-type.js';
+import { registerLoadBalancerTypeCommands } from './load-balancer-type.js';
+import { registerIsoCommands } from './iso.js';
+import { registerCloudServerCommands } from './server.js';
+import { registerNetworkCommands } from './network.js';
+import { registerCloudFirewallCommands } from './firewall.js';
+import { registerFloatingIpCommands } from './floating-ip.js';
+import { registerPrimaryIpCommands } from './primary-ip.js';
+import { registerVolumeCommands } from './volume.js';
+import { registerLoadBalancerCommands } from './load-balancer.js';
+import { registerImageCommands } from './image.js';
+import { registerCloudSshKeyCommands } from './ssh-key.js';
+import { registerCertificateCommands } from './certificate.js';
+import { registerPlacementGroupCommands } from './placement-group.js';
+export function registerCloudCommands(parent) {
+    const cloud = parent.command('cloud').description('Hetzner Cloud API management');
+    cloud.option('--token <token>', 'Cloud API token (overrides context)');
+    registerContextCommands(cloud);
+    // Read-only resources
+    registerDatacenterCommands(cloud);
+    registerLocationCommands(cloud);
+    registerServerTypeCommands(cloud);
+    registerLoadBalancerTypeCommands(cloud);
+    registerIsoCommands(cloud);
+    // Core resources
+    registerCloudServerCommands(cloud);
+    registerNetworkCommands(cloud);
+    registerCloudFirewallCommands(cloud);
+    registerFloatingIpCommands(cloud);
+    registerPrimaryIpCommands(cloud);
+    registerVolumeCommands(cloud);
+    registerLoadBalancerCommands(cloud);
+    registerImageCommands(cloud);
+    // Ancillary resources
+    registerCloudSshKeyCommands(cloud);
+    registerCertificateCommands(cloud);
+    registerPlacementGroupCommands(cloud);
+}

package/dist/cloud/commands/iso.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerIsoCommands(parent: Command): void;

package/dist/cloud/commands/iso.js

@@ -0,0 +1,22 @@
+import { cloudAction, cloudOutput } from '../helpers.js';
+import * as cloudFmt from '../formatter.js';
+export function registerIsoCommands(parent) {
+    const iso = parent.command('iso').description('ISO image management');
+    iso
+        .command('list')
+        .alias('ls')
+        .description('List all ISOs')
+        .option('-n, --name <name>', 'Filter by name')
+        .option('-a, --architecture <arch>', 'Filter by architecture')
+        .action(cloudAction(async (client, options) => {
+        const isos = await client.listIsos({ name: options.name, architecture: options.architecture });
+        cloudOutput(isos, cloudFmt.formatIsoList, options);
+    }));
+    iso
+        .command('describe <id>')
+        .description('Show ISO details')
+        .action(cloudAction(async (client, id, options) => {
+        const iso = await client.getIso(parseInt(id));
+        cloudOutput(iso, cloudFmt.formatIsoDetails, options);
+    }));
+}

package/dist/cloud/commands/load-balancer-type.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerLoadBalancerTypeCommands(parent: Command): void;

package/dist/cloud/commands/load-balancer-type.js

@@ -0,0 +1,20 @@
+import { cloudAction, cloudOutput } from '../helpers.js';
+import * as cloudFmt from '../formatter.js';
+export function registerLoadBalancerTypeCommands(parent) {
+    const lbType = parent.command('load-balancer-type').description('Load balancer type information');
+    lbType
+        .command('list')
+        .alias('ls')
+        .description('List all load balancer types')
+        .action(cloudAction(async (client, options) => {
+        const types = await client.listLoadBalancerTypes();
+        cloudOutput(types, cloudFmt.formatLoadBalancerTypeList, options);
+    }));
+    lbType
+        .command('describe <id>')
+        .description('Show load balancer type details')
+        .action(cloudAction(async (client, id, options) => {
+        const type = await client.getLoadBalancerType(parseInt(id));
+        cloudOutput(type, cloudFmt.formatLoadBalancerTypeDetails, options);
+    }));
+}

package/dist/cloud/commands/load-balancer.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerLoadBalancerCommands(parent: Command): void;