import type { Certificate, CloudAction, CloudFirewall, CloudFirewallRule, CloudServer, CloudSshKey, Datacenter, FloatingIp, Image, ISO, Labels, LoadBalancer, LoadBalancerType, Location, Network, NetworkRoute, NetworkSubnet, PlacementGroup, PrimaryIp, ServerType, Volume } from "./types.js";
export declare class HetznerCloudClient {
    private readonly token;
    constructor(token: string);
    private request;
    private buildQuery;
    /**
     * Fetch all pages of a paginated endpoint.
     */
    listAll<T>(endpoint: string, key: string, params?: Record<string, string | number | boolean | undefined>): Promise<T[]>;
    /**
     * Poll an action until it completes.
     */
    waitForAction(actionId: number, timeoutMs?: number): Promise<CloudAction>;
    listDatacenters(params?: {
        name?: string;
    }): Promise<Datacenter[]>;
    getDatacenter(id: number): Promise<Datacenter>;
    listLocations(params?: {
        name?: string;
    }): Promise<Location[]>;
    getLocation(id: number): Promise<Location>;
    listServerTypes(params?: {
        name?: string;
    }): Promise<ServerType[]>;
    getServerType(id: number): Promise<ServerType>;
    listLoadBalancerTypes(params?: {
        name?: string;
    }): Promise<LoadBalancerType[]>;
    getLoadBalancerType(id: number): Promise<LoadBalancerType>;
    listIsos(params?: {
        name?: string;
        architecture?: string;
    }): Promise<ISO[]>;
    getIso(id: number): Promise<ISO>;
    listServers(params?: {
        label_selector?: string;
        name?: string;
        sort?: string;
        status?: string;
    }): Promise<CloudServer[]>;
    getServer(id: number): Promise<CloudServer>;
    createServer(opts: {
        name: string;
        server_type: string;
        image: string;
        location?: string;
        datacenter?: string;
        ssh_keys?: (string | number)[];
        user_data?: string;
        labels?: Labels;
        automount?: boolean;
        volumes?: number[];
        networks?: number[];
        firewalls?: {
            firewall: number;
        }[];
        placement_group?: number;
        public_net?: {
            enable_ipv4?: boolean;
            enable_ipv6?: boolean;
            ipv4?: number;
            ipv6?: number;
        };
        start_after_create?: boolean;
    }): Promise<{
        server: CloudServer;
        action: CloudAction;
        root_password: string | null;
    }>;
    deleteServer(id: number): Promise<{
        action: CloudAction;
    }>;
    updateServer(id: number, opts: {
        name?: string;
        labels?: Labels;
    }): Promise<{
        server: CloudServer;
    }>;
    powerOnServer(id: number): Promise<{
        action: CloudAction;
    }>;
    powerOffServer(id: number): Promise<{
        action: CloudAction;
    }>;
    rebootServer(id: number): Promise<{
        action: CloudAction;
    }>;
    resetServer(id: number): Promise<{
        action: CloudAction;
    }>;
    shutdownServer(id: number): Promise<{
        action: CloudAction;
    }>;
    rebuildServer(id: number, image: string): Promise<{
        action: CloudAction;
        root_password: string | null;
    }>;
    changeServerType(id: number, serverType: string, upgradeDisk: boolean): Promise<{
        action: CloudAction;
    }>;
    enableServerRescue(id: number, type?: string, sshKeys?: number[]): Promise<{
        action: CloudAction;
        root_password: string;
    }>;
    disableServerRescue(id: number): Promise<{
        action: CloudAction;
    }>;
    enableServerBackup(id: number): Promise<{
        action: CloudAction;
    }>;
    disableServerBackup(id: number): Promise<{
        action: CloudAction;
    }>;
    createServerImage(id: number, opts: {
        description?: string;
        type?: "snapshot" | "backup";
        labels?: Labels;
    }): Promise<{
        image: Image;
        action: CloudAction;
    }>;
    attachIsoToServer(id: number, iso: string): Promise<{
        action: CloudAction;
    }>;
    detachIsoFromServer(id: number): Promise<{
        action: CloudAction;
    }>;
    resetServerPassword(id: number): Promise<{
        action: CloudAction;
        root_password: string;
    }>;
    setServerRdns(id: number, ip: string, dnsPtr: string): Promise<{
        action: CloudAction;
    }>;
    enableServerProtection(id: number, opts: {
        delete?: boolean;
        rebuild?: boolean;
    }): Promise<{
        action: CloudAction;
    }>;
    requestServerConsole(id: number): Promise<{
        wss_url: string;
        password: string;
        action: CloudAction;
    }>;
    attachServerToNetwork(id: number, network: number, ip?: string, aliasIps?: string[]): Promise<{
        action: CloudAction;
    }>;
    detachServerFromNetwork(id: number, network: number): Promise<{
        action: CloudAction;
    }>;
    addServerToPlacementGroup(id: number, placementGroup: number): Promise<{
        action: CloudAction;
    }>;
    removeServerFromPlacementGroup(id: number): Promise<{
        action: CloudAction;
    }>;
    getServerMetrics(id: number, type: string, start: string, end: string): Promise<unknown>;
    listNetworks(params?: {
        label_selector?: string;
        name?: string;
    }): Promise<Network[]>;
    getNetwork(id: number): Promise<Network>;
    createNetwork(opts: {
        name: string;
        ip_range: string;
        subnets?: Omit<NetworkSubnet, "gateway">[];
        routes?: NetworkRoute[];
        labels?: Labels;
        expose_routes_to_vswitch?: boolean;
    }): Promise<{
        network: Network;
    }>;
    deleteNetwork(id: number): Promise<void>;
    updateNetwork(id: number, opts: {
        name?: string;
        labels?: Labels;
        expose_routes_to_vswitch?: boolean;
    }): Promise<{
        network: Network;
    }>;
    addSubnetToNetwork(id: number, subnet: Omit<NetworkSubnet, "gateway">): Promise<{
        action: CloudAction;
    }>;
    deleteSubnetFromNetwork(id: number, ipRange: string): Promise<{
        action: CloudAction;
    }>;
    addRouteToNetwork(id: number, route: NetworkRoute): Promise<{
        action: CloudAction;
    }>;
    deleteRouteFromNetwork(id: number, route: NetworkRoute): Promise<{
        action: CloudAction;
    }>;
    changeNetworkIpRange(id: number, ipRange: string): Promise<{
        action: CloudAction;
    }>;
    changeNetworkProtection(id: number, deleteProtection: boolean): Promise<{
        action: CloudAction;
    }>;
    listFirewalls(params?: {
        label_selector?: string;
        name?: string;
        sort?: string;
    }): Promise<CloudFirewall[]>;
    getFirewall(id: number): Promise<CloudFirewall>;
    createFirewall(opts: {
        name: string;
        rules?: CloudFirewallRule[];
        labels?: Labels;
        apply_to?: CloudFirewallRule[];
    }): Promise<{
        firewall: CloudFirewall;
        actions: CloudAction[];
    }>;
    deleteFirewall(id: number): Promise<void>;
    updateFirewall(id: number, opts: {
        name?: string;
        labels?: Labels;
    }): Promise<{
        firewall: CloudFirewall;
    }>;
    setFirewallRules(id: number, rules: CloudFirewallRule[]): Promise<{
        actions: CloudAction[];
    }>;
    applyFirewall(id: number, applyTo: {
        type: "server" | "label_selector";
        server?: {
            id: number;
        };
        label_selector?: {
            selector: string;
        };
    }[]): Promise<{
        actions: CloudAction[];
    }>;
    removeFirewallFromResources(id: number, removeFrom: {
        type: "server" | "label_selector";
        server?: {
            id: number;
        };
        label_selector?: {
            selector: string;
        };
    }[]): Promise<{
        actions: CloudAction[];
    }>;
    listFloatingIps(params?: {
        label_selector?: string;
        sort?: string;
        name?: string;
    }): Promise<FloatingIp[]>;
    getFloatingIp(id: number): Promise<FloatingIp>;
    createFloatingIp(opts: {
        type: "ipv4" | "ipv6";
        name?: string;
        description?: string;
        home_location?: string;
        server?: number;
        labels?: Labels;
    }): Promise<{
        floating_ip: FloatingIp;
        action: CloudAction;
    }>;
    deleteFloatingIp(id: number): Promise<void>;
    updateFloatingIp(id: number, opts: {
        name?: string;
        description?: string;
        labels?: Labels;
    }): Promise<{
        floating_ip: FloatingIp;
    }>;
    assignFloatingIp(id: number, serverId: number): Promise<{
        action: CloudAction;
    }>;
    unassignFloatingIp(id: number): Promise<{
        action: CloudAction;
    }>;
    changeFloatingIpProtection(id: number, deleteProtection: boolean): Promise<{
        action: CloudAction;
    }>;
    changeFloatingIpDnsPtr(id: number, ip: string, dnsPtr: string | null): Promise<{
        action: CloudAction;
    }>;
    listPrimaryIps(params?: {
        label_selector?: string;
        sort?: string;
        name?: string;
    }): Promise<PrimaryIp[]>;
    getPrimaryIp(id: number): Promise<PrimaryIp>;
    createPrimaryIp(opts: {
        type: "ipv4" | "ipv6";
        name: string;
        assignee_type: "server";
        assignee_id?: number;
        datacenter?: string;
        auto_delete?: boolean;
        labels?: Labels;
    }): Promise<{
        primary_ip: PrimaryIp;
        action: CloudAction;
    }>;
    deletePrimaryIp(id: number): Promise<void>;
    updatePrimaryIp(id: number, opts: {
        name?: string;
        auto_delete?: boolean;
        labels?: Labels;
    }): Promise<{
        primary_ip: PrimaryIp;
    }>;
    assignPrimaryIp(id: number, assigneeId: number, assigneeType?: string): Promise<{
        action: CloudAction;
    }>;
    unassignPrimaryIp(id: number): Promise<{
        action: CloudAction;
    }>;
    changePrimaryIpProtection(id: number, deleteProtection: boolean): Promise<{
        action: CloudAction;
    }>;
    changePrimaryIpDnsPtr(id: number, ip: string, dnsPtr: string | null): Promise<{
        action: CloudAction;
    }>;
    listVolumes(params?: {
        label_selector?: string;
        sort?: string;
        name?: string;
        status?: string;
    }): Promise<Volume[]>;
    getVolume(id: number): Promise<Volume>;
    createVolume(opts: {
        name: string;
        size: number;
        location?: string;
        server?: number;
        format?: string;
        automount?: boolean;
        labels?: Labels;
    }): Promise<{
        volume: Volume;
        action: CloudAction;
        next_actions: CloudAction[];
    }>;
    deleteVolume(id: number): Promise<void>;
    updateVolume(id: number, opts: {
        name?: string;
        labels?: Labels;
    }): Promise<{
        volume: Volume;
    }>;
    attachVolume(id: number, serverId: number, automount?: boolean): Promise<{
        action: CloudAction;
    }>;
    detachVolume(id: number): Promise<{
        action: CloudAction;
    }>;
    resizeVolume(id: number, size: number): Promise<{
        action: CloudAction;
    }>;
    changeVolumeProtection(id: number, deleteProtection: boolean): Promise<{
        action: CloudAction;
    }>;
    listLoadBalancers(params?: {
        label_selector?: string;
        sort?: string;
        name?: string;
    }): Promise<LoadBalancer[]>;
    getLoadBalancer(id: number): Promise<LoadBalancer>;
    createLoadBalancer(opts: {
        name: string;
        load_balancer_type: string;
        location?: string;
        network_zone?: string;
        algorithm?: {
            type: string;
        };
        services?: unknown[];
        targets?: unknown[];
        labels?: Labels;
        network?: number;
        public_interface?: boolean;
    }): Promise<{
        load_balancer: LoadBalancer;
        action: CloudAction;
    }>;
    deleteLoadBalancer(id: number): Promise<void>;
    updateLoadBalancer(id: number, opts: {
        name?: string;
        labels?: Labels;
    }): Promise<{
        load_balancer: LoadBalancer;
    }>;
    addTargetToLoadBalancer(id: number, target: unknown): Promise<{
        action: CloudAction;
    }>;
    removeTargetFromLoadBalancer(id: number, target: unknown): Promise<{
        action: CloudAction;
    }>;
    addServiceToLoadBalancer(id: number, service: unknown): Promise<{
        action: CloudAction;
    }>;
    updateServiceOnLoadBalancer(id: number, service: unknown): Promise<{
        action: CloudAction;
    }>;
    deleteServiceFromLoadBalancer(id: number, listenPort: number): Promise<{
        action: CloudAction;
    }>;
    changeLoadBalancerAlgorithm(id: number, type: string): Promise<{
        action: CloudAction;
    }>;
    changeLoadBalancerType(id: number, loadBalancerType: string): Promise<{
        action: CloudAction;
    }>;
    attachLoadBalancerToNetwork(id: number, network: number, ip?: string): Promise<{
        action: CloudAction;
    }>;
    detachLoadBalancerFromNetwork(id: number, network: number): Promise<{
        action: CloudAction;
    }>;
    enableLoadBalancerPublicInterface(id: number): Promise<{
        action: CloudAction;
    }>;
    disableLoadBalancerPublicInterface(id: number): Promise<{
        action: CloudAction;
    }>;
    changeLoadBalancerProtection(id: number, deleteProtection: boolean): Promise<{
        action: CloudAction;
    }>;
    listImages(params?: {
        label_selector?: string;
        sort?: string;
        type?: string;
        architecture?: string;
        name?: string;
        status?: string;
    }): Promise<Image[]>;
    getImage(id: number): Promise<Image>;
    updateImage(id: number, opts: {
        description?: string;
        type?: string;
        labels?: Labels;
    }): Promise<{
        image: Image;
    }>;
    deleteImage(id: number): Promise<void>;
    changeImageProtection(id: number, deleteProtection: boolean): Promise<{
        action: CloudAction;
    }>;
    listSshKeys(params?: {
        label_selector?: string;
        sort?: string;
        name?: string;
        fingerprint?: string;
    }): Promise<CloudSshKey[]>;
    getSshKey(id: number): Promise<CloudSshKey>;
    createSshKey(opts: {
        name: string;
        public_key: string;
        labels?: Labels;
    }): Promise<{
        ssh_key: CloudSshKey;
    }>;
    updateSshKey(id: number, opts: {
        name?: string;
        labels?: Labels;
    }): Promise<{
        ssh_key: CloudSshKey;
    }>;
    deleteSshKey(id: number): Promise<void>;
    listCertificates(params?: {
        label_selector?: string;
        sort?: string;
        name?: string;
        type?: string;
    }): Promise<Certificate[]>;
    getCertificate(id: number): Promise<Certificate>;
    createCertificate(opts: {
        name: string;
        type?: "uploaded" | "managed";
        certificate?: string;
        private_key?: string;
        domain_names?: string[];
        labels?: Labels;
    }): Promise<{
        certificate: Certificate;
        action?: CloudAction;
    }>;
    updateCertificate(id: number, opts: {
        name?: string;
        labels?: Labels;
    }): Promise<{
        certificate: Certificate;
    }>;
    deleteCertificate(id: number): Promise<void>;
    listPlacementGroups(params?: {
        label_selector?: string;
        sort?: string;
        name?: string;
        type?: string;
    }): Promise<PlacementGroup[]>;
    getPlacementGroup(id: number): Promise<PlacementGroup>;
    createPlacementGroup(opts: {
        name: string;
        type: "spread";
        labels?: Labels;
    }): Promise<{
        placement_group: PlacementGroup;
    }>;
    updatePlacementGroup(id: number, opts: {
        name?: string;
        labels?: Labels;
    }): Promise<{
        placement_group: PlacementGroup;
    }>;
    deletePlacementGroup(id: number): Promise<void>;
    getAction(id: number): Promise<CloudAction>;
    listActions(params?: {
        sort?: string;
        status?: string;
    }): Promise<CloudAction[]>;
}