@ebowwa/hetzner 0.1.0 → 0.2.1

package/actions.js

@@ -1,11 +1,83 @@
+"use strict";
 /**
  * Hetzner Cloud API action polling and management
  *
  * Provides a robust polling service for monitoring async Hetzner actions
  * with progress tracking, error handling, and cancellation support.
  */
-import { ActionCommand, } from "./types.js";
-import { HetznerActionError, HetznerTimeoutError, isRetryableError, calculateRetryDelay, } from "./errors.js";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACTION_TIMEOUTS = exports.ActionOperations = void 0;
+exports.getActionTimeout = getActionTimeout;
+exports.pollAction = pollAction;
+exports.pollActions = pollActions;
+exports.pollActionsDetailed = pollActionsDetailed;
+exports.waitForAction = waitForAction;
+exports.waitForMultipleActions = waitForMultipleActions;
+exports.waitForMultipleActionsWithLimit = waitForMultipleActionsWithLimit;
+exports.batchCheckActions = batchCheckActions;
+exports.isActionRunning = isActionRunning;
+exports.isActionSuccess = isActionSuccess;
+exports.isActionError = isActionError;
+exports.formatActionProgress = formatActionProgress;
+exports.getActionDescription = getActionDescription;
+exports.getPollInterval = getPollInterval;
+exports.getAdaptivePollInterval = getAdaptivePollInterval;
+exports.waitForActionAdaptive = waitForActionAdaptive;
+exports.parseRateLimitHeaders = parseRateLimitHeaders;
+exports.isRateLimitLow = isRateLimitLow;
+exports.formatRateLimitStatus = formatRateLimitStatus;
+exports.waitForRateLimitReset = waitForRateLimitReset;
+exports.createProgressLogger = createProgressLogger;
+var types_js_1 = require("./types.js");
+var errors_js_1 = require("./errors.js");
 // ============================================================================
 // Action Operations Class
 // ============================================================================
@@ -16,9 +88,8 @@ import { HetznerActionError, HetznerTimeoutError, isRetryableError, calculateRet
  * polling capabilities including cancellation, progress tracking,
  * and batch operations.
  */
-export class ActionOperations {
-    client;
-    constructor(client) {
+var ActionOperations = /** @class */ (function () {
+    function ActionOperations(client) {
         this.client = client;
     }
     /**
@@ -27,30 +98,51 @@ export class ActionOperations {
      * @param id - Action ID
      * @returns Action details
      */
-    async get(id) {
-        const response = await this.client.request(`/actions/${id}`);
-        return response.action;
-    }
+    ActionOperations.prototype.get = function (id) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.client.request("/actions/".concat(id))];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, response.action];
+                }
+            });
+        });
+    };
     /**
      * List all actions
      *
-     * @param options - Optional filters (status, sort, etc.)
+     * @param options - Optional filters (status, sort, server_id, etc.)
      * @returns Array of actions
      */
-    async list(options) {
-        const params = new URLSearchParams();
-        if (options?.status)
-            params.append("status", options.status);
-        if (options?.sort)
-            params.append("sort", options.sort);
-        if (options?.page)
-            params.append("page", options.page.toString());
-        if (options?.per_page)
-            params.append("per_page", options.per_page.toString());
-        const query = params.toString();
-        const response = await this.client.request(`/actions${query ? `?${query}` : ""}`);
-        return response.actions;
-    }
+    ActionOperations.prototype.list = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var params, query, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        params = new URLSearchParams();
+                        if (options === null || options === void 0 ? void 0 : options.status)
+                            params.append("status", options.status);
+                        if (options === null || options === void 0 ? void 0 : options.sort)
+                            params.append("sort", options.sort);
+                        if (options === null || options === void 0 ? void 0 : options.page)
+                            params.append("page", options.page.toString());
+                        if (options === null || options === void 0 ? void 0 : options.per_page)
+                            params.append("per_page", options.per_page.toString());
+                        if (options === null || options === void 0 ? void 0 : options.server_id)
+                            params.append("server_id", options.server_id.toString());
+                        query = params.toString();
+                        return [4 /*yield*/, this.client.request("/actions".concat(query ? "?".concat(query) : ""))];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, response.actions];
+                }
+            });
+        });
+    };
     /**
      * Poll a single action until completion (enhanced version)
      *
@@ -76,9 +168,14 @@ export class ActionOperations {
      * });
      * ```
      */
-    async poll(actionId, options = {}) {
-        return pollAction(this.client, actionId, options);
-    }
+    ActionOperations.prototype.poll = function (actionId_1) {
+        return __awaiter(this, arguments, void 0, function (actionId, options) {
+            if (options === void 0) { options = {}; }
+            return __generator(this, function (_a) {
+                return [2 /*return*/, pollAction(this.client, actionId, options)];
+            });
+        });
+    };
     /**
      * Poll multiple actions until completion
      *
@@ -98,9 +195,14 @@ export class ActionOperations {
      * });
      * ```
      */
-    async pollMany(actionIds, options = {}) {
-        return pollActions(this.client, actionIds, options);
-    }
+    ActionOperations.prototype.pollMany = function (actionIds_1) {
+        return __awaiter(this, arguments, void 0, function (actionIds, options) {
+            if (options === void 0) { options = {}; }
+            return __generator(this, function (_a) {
+                return [2 /*return*/, pollActions(this.client, actionIds, options)];
+            });
+        });
+    };
     /**
      * Poll multiple actions with detailed result tracking
      *
@@ -122,9 +224,14 @@ export class ActionOperations {
      * }
      * ```
      */
-    async pollManyDetailed(actionIds, options = {}) {
-        return pollActionsDetailed(this.client, actionIds, options);
-    }
+    ActionOperations.prototype.pollManyDetailed = function (actionIds_1) {
+        return __awaiter(this, arguments, void 0, function (actionIds, options) {
+            if (options === void 0) { options = {}; }
+            return __generator(this, function (_a) {
+                return [2 /*return*/, pollActionsDetailed(this.client, actionIds, options)];
+            });
+        });
+    };
     /**
      * Wait for an action to complete (backward compatible alias)
      *
@@ -133,9 +240,13 @@ export class ActionOperations {
      * @returns Completed action
      * @deprecated Use poll() instead for new code
      */
-    async waitFor(id, options) {
-        return waitForAction(this.client, id, options);
-    }
+    ActionOperations.prototype.waitFor = function (id, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, waitForAction(this.client, id, options)];
+            });
+        });
+    };
     /**
      * Wait for multiple actions to complete (backward compatible alias)
      *
@@ -144,19 +255,29 @@ export class ActionOperations {
      * @returns Array of completed actions
      * @deprecated Use pollMany() instead for new code
      */
-    async waitForMany(ids, options) {
-        return waitForMultipleActions(this.client, ids, options);
-    }
+    ActionOperations.prototype.waitForMany = function (ids, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, waitForMultipleActions(this.client, ids, options)];
+            });
+        });
+    };
     /**
      * Batch check multiple actions (no polling, single fetch)
      *
      * @param ids - Array of action IDs
      * @returns Map of action ID to action
      */
-    async batchCheck(ids) {
-        return batchCheckActions(this.client, ids);
-    }
-}
+    ActionOperations.prototype.batchCheck = function (ids) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, batchCheckActions(this.client, ids)];
+            });
+        });
+    };
+    return ActionOperations;
+}());
+exports.ActionOperations = ActionOperations;
 // ============================================================================
 // Action Timeouts
 // ============================================================================
@@ -164,81 +285,81 @@ export class ActionOperations {
  * Default timeouts for different action types (in milliseconds)
  * Adjusted based on typical operation durations
  */
-export const ACTION_TIMEOUTS = {
+exports.ACTION_TIMEOUTS = (_a = {},
     // Quick operations (under 1 minute)
-    [ActionCommand.StartServer]: 60000,
-    [ActionCommand.StopServer]: 60000,
-    [ActionCommand.RebootServer]: 120000,
-    [ActionCommand.Poweroff]: 60000,
-    [ActionCommand.ShutdownServer]: 60000,
-    [ActionCommand.ResetServer]: 60000,
+    _a[types_js_1.ActionCommand.StartServer] = 60000,
+    _a[types_js_1.ActionCommand.StopServer] = 60000,
+    _a[types_js_1.ActionCommand.RebootServer] = 120000,
+    _a[types_js_1.ActionCommand.Poweroff] = 60000,
+    _a[types_js_1.ActionCommand.ShutdownServer] = 60000,
+    _a[types_js_1.ActionCommand.ResetServer] = 60000,
     // Medium operations (1-5 minutes)
-    [ActionCommand.CreateServer]: 300000,
-    [ActionCommand.DeleteServer]: 180000,
-    [ActionCommand.ChangeServerType]: 600000,
-    [ActionCommand.ChangeDnsPtr]: 30000,
+    _a[types_js_1.ActionCommand.CreateServer] = 300000,
+    _a[types_js_1.ActionCommand.DeleteServer] = 180000,
+    _a[types_js_1.ActionCommand.ChangeServerType] = 600000,
+    _a[types_js_1.ActionCommand.ChangeDnsPtr] = 30000,
     // Long operations (5-30 minutes)
-    [ActionCommand.RebuildServer]: 900000,
-    [ActionCommand.CreateImage]: 1800000,
-    [ActionCommand.EnableRescue]: 120000,
-    [ActionCommand.DisableRescue]: 60000,
+    _a[types_js_1.ActionCommand.RebuildServer] = 900000,
+    _a[types_js_1.ActionCommand.CreateImage] = 1800000,
+    _a[types_js_1.ActionCommand.EnableRescue] = 120000,
+    _a[types_js_1.ActionCommand.DisableRescue] = 60000,
     // Volume operations
-    [ActionCommand.CreateVolume]: 300000,
-    [ActionCommand.DeleteVolume]: 180000,
-    [ActionCommand.AttachVolume]: 120000,
-    [ActionCommand.DetachVolume]: 60000,
-    [ActionCommand.ResizeVolume]: 600000,
+    _a[types_js_1.ActionCommand.CreateVolume] = 300000,
+    _a[types_js_1.ActionCommand.DeleteVolume] = 180000,
+    _a[types_js_1.ActionCommand.AttachVolume] = 120000,
+    _a[types_js_1.ActionCommand.DetachVolume] = 60000,
+    _a[types_js_1.ActionCommand.ResizeVolume] = 600000,
     // Network operations
-    [ActionCommand.AddSubnet]: 60000,
-    [ActionCommand.DeleteSubnet]: 60000,
-    [ActionCommand.AddRoute]: 60000,
-    [ActionCommand.DeleteRoute]: 60000,
-    [ActionCommand.ChangeIpRange]: 120000,
-    [ActionCommand.AttachToNetwork]: 60000,
-    [ActionCommand.DetachFromNetwork]: 60000,
+    _a[types_js_1.ActionCommand.AddSubnet] = 60000,
+    _a[types_js_1.ActionCommand.DeleteSubnet] = 60000,
+    _a[types_js_1.ActionCommand.AddRoute] = 60000,
+    _a[types_js_1.ActionCommand.DeleteRoute] = 60000,
+    _a[types_js_1.ActionCommand.ChangeIpRange] = 120000,
+    _a[types_js_1.ActionCommand.AttachToNetwork] = 60000,
+    _a[types_js_1.ActionCommand.DetachFromNetwork] = 60000,
     // Floating IP operations
-    [ActionCommand.AssignFloatingIp]: 60000,
-    [ActionCommand.UnassignFloatingIp]: 60000,
+    _a[types_js_1.ActionCommand.AssignFloatingIp] = 60000,
+    _a[types_js_1.ActionCommand.UnassignFloatingIp] = 60000,
     // Load Balancer operations
-    [ActionCommand.CreateLoadBalancer]: 300000,
-    [ActionCommand.DeleteLoadBalancer]: 180000,
-    [ActionCommand.AddTarget]: 60000,
-    [ActionCommand.RemoveTarget]: 60000,
-    [ActionCommand.AddService]: 60000,
-    [ActionCommand.UpdateService]: 60000,
-    [ActionCommand.DeleteService]: 60000,
-    [ActionCommand.LoadBalancerAttachToNetwork]: 60000,
-    [ActionCommand.LoadBalancerDetachFromNetwork]: 60000,
-    [ActionCommand.ChangeAlgorithm]: 60000,
-    [ActionCommand.ChangeType]: 60000,
+    _a[types_js_1.ActionCommand.CreateLoadBalancer] = 300000,
+    _a[types_js_1.ActionCommand.DeleteLoadBalancer] = 180000,
+    _a[types_js_1.ActionCommand.AddTarget] = 60000,
+    _a[types_js_1.ActionCommand.RemoveTarget] = 60000,
+    _a[types_js_1.ActionCommand.AddService] = 60000,
+    _a[types_js_1.ActionCommand.UpdateService] = 60000,
+    _a[types_js_1.ActionCommand.DeleteService] = 60000,
+    _a[types_js_1.ActionCommand.LoadBalancerAttachToNetwork] = 60000,
+    _a[types_js_1.ActionCommand.LoadBalancerDetachFromNetwork] = 60000,
+    _a[types_js_1.ActionCommand.ChangeAlgorithm] = 60000,
+    _a[types_js_1.ActionCommand.ChangeType] = 60000,
     // Certificate operations
-    [ActionCommand.IssueCertificate]: 600000, // Can take up to 10 minutes
-    [ActionCommand.RetryCertificate]: 600000,
+    _a[types_js_1.ActionCommand.IssueCertificate] = 600000, // Can take up to 10 minutes
+    _a[types_js_1.ActionCommand.RetryCertificate] = 600000,
     // Firewall operations
-    [ActionCommand.SetFirewallRules]: 60000,
-    [ActionCommand.ApplyFirewall]: 120000,
-    [ActionCommand.RemoveFirewall]: 60000,
+    _a[types_js_1.ActionCommand.SetFirewallRules] = 60000,
+    _a[types_js_1.ActionCommand.ApplyFirewall] = 120000,
+    _a[types_js_1.ActionCommand.RemoveFirewall] = 60000,
     // Floating IP DNS
-    [ActionCommand.FloatingIpChangeDnsPtr]: 30000,
+    _a[types_js_1.ActionCommand.FloatingIpChangeDnsPtr] = 30000,
     // Backup operations
-    [ActionCommand.EnableBackup]: 60000,
-    [ActionCommand.DisableBackup]: 60000,
+    _a[types_js_1.ActionCommand.EnableBackup] = 60000,
+    _a[types_js_1.ActionCommand.DisableBackup] = 60000,
     // Protection operations
-    [ActionCommand.ChangeProtection]: 30000,
-    [ActionCommand.VolumeChangeProtection]: 30000,
-    [ActionCommand.NetworkChangeProtection]: 30000,
-    [ActionCommand.FloatingIpChangeProtection]: 30000,
-    [ActionCommand.LoadBalancerChangeProtection]: 30000,
-    [ActionCommand.FirewallChangeProtection]: 30000,
-    [ActionCommand.ImageChangeProtection]: 30000,
+    _a[types_js_1.ActionCommand.ChangeProtection] = 30000,
+    _a[types_js_1.ActionCommand.VolumeChangeProtection] = 30000,
+    _a[types_js_1.ActionCommand.NetworkChangeProtection] = 30000,
+    _a[types_js_1.ActionCommand.FloatingIpChangeProtection] = 30000,
+    _a[types_js_1.ActionCommand.LoadBalancerChangeProtection] = 30000,
+    _a[types_js_1.ActionCommand.FirewallChangeProtection] = 30000,
+    _a[types_js_1.ActionCommand.ImageChangeProtection] = 30000,
     // Other operations
-    [ActionCommand.ChangeAliasIps]: 60000,
-};
+    _a[types_js_1.ActionCommand.ChangeAliasIps] = 60000,
+    _a);
 /**
  * Get default timeout for an action command
  */
-export function getActionTimeout(command) {
-    return ACTION_TIMEOUTS[command] || 300000; // Default 5 minutes
+function getActionTimeout(command) {
+    return exports.ACTION_TIMEOUTS[command] || 300000; // Default 5 minutes
 }
 // ============================================================================
 // Enhanced Action Polling Service
@@ -246,14 +367,14 @@ export function getActionTimeout(command) {
 /**
  * Default polling options
  */
-const DEFAULT_POLLING_OPTIONS = {
+var DEFAULT_POLLING_OPTIONS = {
     pollInterval: 2000,
     maxRetries: 60,
     timeout: 300000,
-    onProgress: () => { },
-    onComplete: () => { },
-    onError: () => { },
-    onRetry: () => { },
+    onProgress: function () { },
+    onComplete: function () { },
+    onError: function () { },
+    onRetry: function () { },
     signal: undefined,
     adaptive: false,
     concurrency: 5,
@@ -286,76 +407,95 @@ const DEFAULT_POLLING_OPTIONS = {
  * });
  * ```
  */
-export async function pollAction(client, actionId, options = {}) {
-    const opts = { ...DEFAULT_POLLING_OPTIONS, ...options };
-    const startTime = Date.now();
-    let lastProgress = 0;
-    let lastError = null;
-    let attempt = 0;
-    // Check if already aborted
-    if (opts.signal?.aborted) {
-        throw new Error("Polling aborted before start");
-    }
-    // Set up abort listener
-    const abortListener = () => {
-        throw new Error("Polling aborted");
-    };
-    opts.signal?.addEventListener("abort", abortListener);
-    try {
-        while (attempt < opts.maxRetries) {
-            // Check timeout
-            const elapsed = Date.now() - startTime;
-            if (elapsed > opts.timeout) {
-                throw new HetznerTimeoutError(actionId, opts.timeout, lastProgress);
-            }
-            try {
-                const response = await client.request(`/actions/${actionId}`);
-                const action = response.action;
-                attempt++;
-                // Notify progress callback on any change
-                if (action.progress !== lastProgress) {
-                    lastProgress = action.progress;
-                    opts.onProgress(action);
-                }
-                // Check if action completed successfully
-                if (action.status === "success") {
-                    opts.onComplete(action);
-                    return action;
-                }
-                // Check if action failed
-                if (action.status === "error") {
-                    const error = new HetznerActionError(action.error, actionId);
-                    opts.onError(error, action);
-                    throw error;
-                }
-                // Still running - calculate wait time
-                let waitTime = opts.pollInterval;
-                if (opts.adaptive) {
-                    waitTime = getAdaptivePollInterval(action.progress);
-                }
-                await sleep(waitTime);
-            }
-            catch (error) {
-                // Check if this is a retryable error
-                if (isRetryableError(error)) {
-                    const delay = calculateRetryDelay(attempt);
+function pollAction(client_1, actionId_1) {
+    return __awaiter(this, arguments, void 0, function (client, actionId, options) {
+        var opts, startTime, lastProgress, lastError, attempt, abortListener, elapsed, response, action, error, waitTime, error_1, delay;
+        var _a, _b, _c, _d;
+        if (options === void 0) { options = {}; }
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    opts = __assign(__assign({}, DEFAULT_POLLING_OPTIONS), options);
+                    startTime = Date.now();
+                    lastProgress = 0;
+                    lastError = null;
+                    attempt = 0;
+                    // Check if already aborted
+                    if ((_a = opts.signal) === null || _a === void 0 ? void 0 : _a.aborted) {
+                        throw new Error("Polling aborted before start");
+                    }
+                    abortListener = function () {
+                        throw new Error("Polling aborted");
+                    };
+                    (_b = opts.signal) === null || _b === void 0 ? void 0 : _b.addEventListener("abort", abortListener);
+                    _e.label = 1;
+                case 1:
+                    _e.trys.push([1, , 11, 12]);
+                    _e.label = 2;
+                case 2:
+                    if (!(attempt < opts.maxRetries)) return [3 /*break*/, 10];
+                    elapsed = Date.now() - startTime;
+                    if (elapsed > opts.timeout) {
+                        throw new errors_js_1.HetznerTimeoutError(actionId, opts.timeout, lastProgress);
+                    }
+                    _e.label = 3;
+                case 3:
+                    _e.trys.push([3, 6, , 9]);
+                    return [4 /*yield*/, client.request("/actions/".concat(actionId))];
+                case 4:
+                    response = _e.sent();
+                    action = response.action;
+                    attempt++;
+                    // Notify progress callback on any change
+                    if (action.progress !== lastProgress) {
+                        lastProgress = action.progress;
+                        opts.onProgress(action);
+                    }
+                    // Check if action completed successfully
+                    if (action.status === "success") {
+                        opts.onComplete(action);
+                        return [2 /*return*/, action];
+                    }
+                    // Check if action failed
+                    if (action.status === "error") {
+                        error = new errors_js_1.HetznerActionError(action.error, actionId);
+                        opts.onError(error, action);
+                        throw error;
+                    }
+                    waitTime = opts.pollInterval;
+                    if (opts.adaptive) {
+                        waitTime = getAdaptivePollInterval(action.progress);
+                    }
+                    return [4 /*yield*/, sleep(waitTime)];
+                case 5:
+                    _e.sent();
+                    return [3 /*break*/, 9];
+                case 6:
+                    error_1 = _e.sent();
+                    if (!(0, errors_js_1.isRetryableError)(error_1)) return [3 /*break*/, 8];
+                    delay = (0, errors_js_1.calculateRetryDelay)(attempt);
                     opts.onRetry(attempt, delay);
-                    if (opts.signal?.aborted) {
+                    if ((_c = opts.signal) === null || _c === void 0 ? void 0 : _c.aborted) {
                         throw new Error("Polling aborted during retry");
                     }
-                    await sleep(delay);
-                    continue;
-                }
+                    return [4 /*yield*/, sleep(delay)];
+                case 7:
+                    _e.sent();
+                    return [3 /*break*/, 2];
+                case 8: 
                 // Non-retryable error - throw immediately
-                throw error;
+                throw error_1;
+                case 9: return [3 /*break*/, 2];
+                case 10: 
+                // Max retries exceeded
+                throw new errors_js_1.HetznerTimeoutError(actionId, opts.timeout, lastProgress);
+                case 11:
+                    (_d = opts.signal) === null || _d === void 0 ? void 0 : _d.removeEventListener("abort", abortListener);
+                    return [7 /*endfinally*/];
+                case 12: return [2 /*return*/];
             }
-        }
-        // Max retries exceeded
-        throw new HetznerTimeoutError(actionId, opts.timeout, lastProgress);
-    }
-    finally {
-        opts.signal?.removeEventListener("abort", abortListener);
-    }
+        });
+    });
 }
 /**
  * Poll multiple actions concurrently
@@ -377,32 +517,70 @@ export async function pollAction(client, actionId, options = {}) {
  * });
  * ```
  */
-export async function pollActions(client, actionIds, options = {}) {
-    const concurrency = options.concurrency ?? DEFAULT_POLLING_OPTIONS.concurrency;
-    // If concurrency is high enough, poll all at once
-    if (concurrency >= actionIds.length) {
-        const promises = actionIds.map((id) => pollAction(client, id, options));
-        return Promise.all(promises);
-    }
-    // Otherwise, process in batches with concurrency limit
-    const results = new Array(actionIds.length);
-    let currentIndex = 0;
-    const processBatch = async () => {
-        while (currentIndex < actionIds.length) {
-            const batchStart = currentIndex;
-            const batchEnd = Math.min(currentIndex + concurrency, actionIds.length);
-            const batchIds = actionIds.slice(batchStart, batchEnd);
-            currentIndex = batchEnd;
-            const batchResults = await Promise.all(batchIds.map((id, i) => pollAction(client, id, options)));
-            // Store results in correct positions
-            batchResults.forEach((result, i) => {
-                results[batchStart + i] = result;
-            });
-        }
-    };
-    // Process batches sequentially but actions within each batch concurrently
-    await processBatch();
-    return results;
+function pollActions(client_1, actionIds_1) {
+    return __awaiter(this, arguments, void 0, function (client, actionIds, options) {
+        var concurrency, promises, results, currentIndex, processBatch;
+        var _this = this;
+        var _a;
+        if (options === void 0) { options = {}; }
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    concurrency = (_a = options.concurrency) !== null && _a !== void 0 ? _a : DEFAULT_POLLING_OPTIONS.concurrency;
+                    // If concurrency is high enough, poll all at once
+                    if (concurrency >= actionIds.length) {
+                        promises = actionIds.map(function (id) {
+                            return pollAction(client, id, options);
+                        });
+                        return [2 /*return*/, Promise.all(promises)];
+                    }
+                    results = new Array(actionIds.length);
+                    currentIndex = 0;
+                    processBatch = function () { return __awaiter(_this, void 0, void 0, function () {
+                        var _loop_1;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    _loop_1 = function () {
+                                        var batchStart, batchEnd, batchIds, batchResults;
+                                        return __generator(this, function (_b) {
+                                            switch (_b.label) {
+                                                case 0:
+                                                    batchStart = currentIndex;
+                                                    batchEnd = Math.min(currentIndex + concurrency, actionIds.length);
+                                                    batchIds = actionIds.slice(batchStart, batchEnd);
+                                                    currentIndex = batchEnd;
+                                                    return [4 /*yield*/, Promise.all(batchIds.map(function (id, i) { return pollAction(client, id, options); }))];
+                                                case 1:
+                                                    batchResults = _b.sent();
+                                                    // Store results in correct positions
+                                                    batchResults.forEach(function (result, i) {
+                                                        results[batchStart + i] = result;
+                                                    });
+                                                    return [2 /*return*/];
+                                            }
+                                        });
+                                    };
+                                    _a.label = 1;
+                                case 1:
+                                    if (!(currentIndex < actionIds.length)) return [3 /*break*/, 3];
+                                    return [5 /*yield**/, _loop_1()];
+                                case 2:
+                                    _a.sent();
+                                    return [3 /*break*/, 1];
+                                case 3: return [2 /*return*/];
+                            }
+                        });
+                    }); };
+                    // Process batches sequentially but actions within each batch concurrently
+                    return [4 /*yield*/, processBatch()];
+                case 1:
+                    // Process batches sequentially but actions within each batch concurrently
+                    _b.sent();
+                    return [2 /*return*/, results];
+            }
+        });
+    });
 }
 /**
  * Poll multiple actions with detailed result tracking
@@ -430,50 +608,62 @@ export async function pollActions(client, actionIds, options = {}) {
  * }
  * ```
  */
-export async function pollActionsDetailed(client, actionIds, options = {}) {
-    const startTime = Date.now();
-    const results = new Map();
-    let successful = 0;
-    let failed = 0;
-    // Wrap callbacks to track results
-    const wrappedOptions = {
-        ...options,
-        onComplete: (action) => {
-            results.set(action.id, {
-                success: true,
-                action,
-                attempts: 0,
-                elapsed: Date.now() - startTime,
-            });
-            successful++;
-            options.onComplete?.(action);
-        },
-        onError: (error, action) => {
-            results.set(action.id, {
-                success: false,
-                action,
-                error,
-                attempts: 0,
-                elapsed: Date.now() - startTime,
-            });
-            failed++;
-            options.onError?.(error, action);
-        },
-    };
-    try {
-        // Poll all actions
-        await pollActions(client, actionIds, wrappedOptions);
-    }
-    catch (error) {
-        // Some actions may have failed, but we still return results
-        console.warn("Some actions failed during batch polling:", error);
-    }
-    return {
-        results,
-        successful,
-        failed,
-        elapsed: Date.now() - startTime,
-    };
+function pollActionsDetailed(client_1, actionIds_1) {
+    return __awaiter(this, arguments, void 0, function (client, actionIds, options) {
+        var startTime, results, successful, failed, wrappedOptions, error_2;
+        if (options === void 0) { options = {}; }
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    startTime = Date.now();
+                    results = new Map();
+                    successful = 0;
+                    failed = 0;
+                    wrappedOptions = __assign(__assign({}, options), { onComplete: function (action) {
+                            var _a;
+                            results.set(action.id, {
+                                success: true,
+                                action: action,
+                                attempts: 0,
+                                elapsed: Date.now() - startTime,
+                            });
+                            successful++;
+                            (_a = options.onComplete) === null || _a === void 0 ? void 0 : _a.call(options, action);
+                        }, onError: function (error, action) {
+                            var _a;
+                            results.set(action.id, {
+                                success: false,
+                                action: action,
+                                error: error,
+                                attempts: 0,
+                                elapsed: Date.now() - startTime,
+                            });
+                            failed++;
+                            (_a = options.onError) === null || _a === void 0 ? void 0 : _a.call(options, error, action);
+                        } });
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    // Poll all actions
+                    return [4 /*yield*/, pollActions(client, actionIds, wrappedOptions)];
+                case 2:
+                    // Poll all actions
+                    _a.sent();
+                    return [3 /*break*/, 4];
+                case 3:
+                    error_2 = _a.sent();
+                    // Some actions may have failed, but we still return results
+                    console.warn("Some actions failed during batch polling:", error_2);
+                    return [3 /*break*/, 4];
+                case 4: return [2 /*return*/, {
+                        results: results,
+                        successful: successful,
+                        failed: failed,
+                        elapsed: Date.now() - startTime,
+                    }];
+            }
+        });
+    });
 }
 // ============================================================================
 // Backward Compatible Polling Functions
@@ -483,75 +673,122 @@ export async function pollActionsDetailed(client, actionIds, options = {}) {
  *
  * @deprecated Use pollAction() instead for new code
  */
-export async function waitForAction(client, actionId, options = {}) {
-    const opts = { ...DEFAULT_POLLING_OPTIONS, ...options };
-    const startTime = Date.now();
-    let lastProgress = 0;
-    let lastError = null;
-    for (let attempt = 0; attempt < opts.maxRetries; attempt++) {
-        // Check timeout
-        if (Date.now() - startTime > opts.timeout) {
-            throw new HetznerTimeoutError(actionId, opts.timeout, lastProgress);
-        }
-        try {
-            const action = await client.request(`/actions/${actionId}`);
-            // Notify progress callback
-            if (action.action.progress !== lastProgress) {
-                lastProgress = action.action.progress;
-                opts.onProgress(action.action);
-            }
-            // Check if action is complete
-            if (action.action.status === "success") {
-                return action.action;
-            }
-            if (action.action.status === "error") {
-                throw new HetznerActionError(action.action.error, actionId);
-            }
-            // Still running - wait before next poll
-            await sleep(opts.pollInterval);
-        }
-        catch (error) {
-            // Check if error is retryable
-            if (isRetryableError(error)) {
-                const delay = calculateRetryDelay(attempt);
-                console.warn(`Retrying action ${actionId} after ${delay}ms (attempt ${attempt + 1}/${opts.maxRetries})`);
-                await sleep(delay);
-                continue;
+function waitForAction(client_1, actionId_1) {
+    return __awaiter(this, arguments, void 0, function (client, actionId, options) {
+        var opts, startTime, lastProgress, lastError, attempt, action, error_3, delay;
+        if (options === void 0) { options = {}; }
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    opts = __assign(__assign({}, DEFAULT_POLLING_OPTIONS), options);
+                    startTime = Date.now();
+                    lastProgress = 0;
+                    lastError = null;
+                    attempt = 0;
+                    _a.label = 1;
+                case 1:
+                    if (!(attempt < opts.maxRetries)) return [3 /*break*/, 9];
+                    // Check timeout
+                    if (Date.now() - startTime > opts.timeout) {
+                        throw new errors_js_1.HetznerTimeoutError(actionId, opts.timeout, lastProgress);
+                    }
+                    _a.label = 2;
+                case 2:
+                    _a.trys.push([2, 5, , 8]);
+                    return [4 /*yield*/, client.request("/actions/".concat(actionId))];
+                case 3:
+                    action = _a.sent();
+                    // Notify progress callback
+                    if (action.action.progress !== lastProgress) {
+                        lastProgress = action.action.progress;
+                        opts.onProgress(action.action);
+                    }
+                    // Check if action is complete
+                    if (action.action.status === "success") {
+                        return [2 /*return*/, action.action];
+                    }
+                    if (action.action.status === "error") {
+                        throw new errors_js_1.HetznerActionError(action.action.error, actionId);
+                    }
+                    // Still running - wait before next poll
+                    return [4 /*yield*/, sleep(opts.pollInterval)];
+                case 4:
+                    // Still running - wait before next poll
+                    _a.sent();
+                    return [3 /*break*/, 8];
+                case 5:
+                    error_3 = _a.sent();
+                    if (!(0, errors_js_1.isRetryableError)(error_3)) return [3 /*break*/, 7];
+                    delay = (0, errors_js_1.calculateRetryDelay)(attempt);
+                    console.warn("Retrying action ".concat(actionId, " after ").concat(delay, "ms (attempt ").concat(attempt + 1, "/").concat(opts.maxRetries, ")"));
+                    return [4 /*yield*/, sleep(delay)];
+                case 6:
+                    _a.sent();
+                    return [3 /*break*/, 8];
+                case 7: 
+                // Non-retryable error - throw immediately
+                throw error_3;
+                case 8:
+                    attempt++;
+                    return [3 /*break*/, 1];
+                case 9: 
+                // Max retries exceeded
+                throw new errors_js_1.HetznerTimeoutError(actionId, opts.timeout, lastProgress);
             }
-            // Non-retryable error - throw immediately
-            throw error;
-        }
-    }
-    // Max retries exceeded
-    throw new HetznerTimeoutError(actionId, opts.timeout, lastProgress);
+        });
+    });
 }
 /**
  * Poll for multiple actions concurrently (backward compatible)
  *
  * @deprecated Use pollActions() instead for new code
  */
-export async function waitForMultipleActions(client, actionIds, options = {}) {
-    const promises = actionIds.map((id) => waitForAction(client, id, options));
-    return Promise.all(promises);
+function waitForMultipleActions(client_1, actionIds_1) {
+    return __awaiter(this, arguments, void 0, function (client, actionIds, options) {
+        var promises;
+        if (options === void 0) { options = {}; }
+        return __generator(this, function (_a) {
+            promises = actionIds.map(function (id) { return waitForAction(client, id, options); });
+            return [2 /*return*/, Promise.all(promises)];
+        });
+    });
 }
 /**
  * Poll for multiple actions with concurrency limit (backward compatible)
  *
  * @deprecated Use pollActions() with concurrency option instead
  */
-export async function waitForMultipleActionsWithLimit(client, actionIds, concurrency = 5, options = {}) {
-    const results = [];
-    const chunks = [];
-    // Split action IDs into chunks
-    for (let i = 0; i < actionIds.length; i += concurrency) {
-        chunks.push(actionIds.slice(i, i + concurrency));
-    }
-    // Process each chunk sequentially
-    for (const chunk of chunks) {
-        const chunkResults = await waitForMultipleActions(client, chunk, options);
-        results.push(...chunkResults);
-    }
-    return results;
+function waitForMultipleActionsWithLimit(client_1, actionIds_1) {
+    return __awaiter(this, arguments, void 0, function (client, actionIds, concurrency, options) {
+        var results, chunks, i, _i, chunks_1, chunk, chunkResults;
+        if (concurrency === void 0) { concurrency = 5; }
+        if (options === void 0) { options = {}; }
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    results = [];
+                    chunks = [];
+                    // Split action IDs into chunks
+                    for (i = 0; i < actionIds.length; i += concurrency) {
+                        chunks.push(actionIds.slice(i, i + concurrency));
+                    }
+                    _i = 0, chunks_1 = chunks;
+                    _a.label = 1;
+                case 1:
+                    if (!(_i < chunks_1.length)) return [3 /*break*/, 4];
+                    chunk = chunks_1[_i];
+                    return [4 /*yield*/, waitForMultipleActions(client, chunk, options)];
+                case 2:
+                    chunkResults = _a.sent();
+                    results.push.apply(results, chunkResults);
+                    _a.label = 3;
+                case 3:
+                    _i++;
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/, results];
+            }
+        });
+    });
 }
 /**
  * Batch check multiple actions in a single API call
@@ -562,19 +799,35 @@ export async function waitForMultipleActionsWithLimit(client, actionIds, concurr
  * @param actionIds - Array of action IDs to check
  * @returns Map of action ID to action
  */
-export async function batchCheckActions(client, actionIds) {
-    const MAX_BATCH_SIZE = 50; // API limit for ID parameter
-    const results = new Map();
-    // Process in batches
-    for (let i = 0; i < actionIds.length; i += MAX_BATCH_SIZE) {
-        const batch = actionIds.slice(i, i + MAX_BATCH_SIZE);
-        const idParams = batch.map((id) => `id=${id}`).join("&");
-        const response = await client.request(`/actions?${idParams}`);
-        for (const action of response.actions) {
-            results.set(action.id, action);
-        }
-    }
-    return results;
+function batchCheckActions(client, actionIds) {
+    return __awaiter(this, void 0, void 0, function () {
+        var MAX_BATCH_SIZE, results, i, batch, idParams, response, _i, _a, action;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    MAX_BATCH_SIZE = 50;
+                    results = new Map();
+                    i = 0;
+                    _b.label = 1;
+                case 1:
+                    if (!(i < actionIds.length)) return [3 /*break*/, 4];
+                    batch = actionIds.slice(i, i + MAX_BATCH_SIZE);
+                    idParams = batch.map(function (id) { return "id=".concat(id); }).join("&");
+                    return [4 /*yield*/, client.request("/actions?".concat(idParams))];
+                case 2:
+                    response = _b.sent();
+                    for (_i = 0, _a = response.actions; _i < _a.length; _i++) {
+                        action = _a[_i];
+                        results.set(action.id, action);
+                    }
+                    _b.label = 3;
+                case 3:
+                    i += MAX_BATCH_SIZE;
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/, results];
+            }
+        });
+    });
 }
 // ============================================================================
 // Action Status Utilities
@@ -582,90 +835,91 @@ export async function batchCheckActions(client, actionIds) {
 /**
  * Check if an action is running
  */
-export function isActionRunning(action) {
+function isActionRunning(action) {
     return action.status === "running";
 }
 /**
  * Check if an action completed successfully
  */
-export function isActionSuccess(action) {
+function isActionSuccess(action) {
     return action.status === "success";
 }
 /**
  * Check if an action failed
  */
-export function isActionError(action) {
+function isActionError(action) {
     return action.status === "error";
 }
 /**
  * Format action progress for display
  */
-export function formatActionProgress(action) {
-    const command = action.command.replace(/_/g, " ");
-    const status = action.status.toUpperCase();
-    return `${status}: ${command} (${action.progress}%)`;
+function formatActionProgress(action) {
+    var command = action.command.replace(/_/g, " ");
+    var status = action.status.toUpperCase();
+    return "".concat(status, ": ").concat(command, " (").concat(action.progress, "%)");
 }
 /**
  * Get human-readable action description
  */
-export function getActionDescription(command) {
-    const descriptions = {
-        [ActionCommand.CreateServer]: "Creating server",
-        [ActionCommand.DeleteServer]: "Deleting server",
-        [ActionCommand.StartServer]: "Starting server",
-        [ActionCommand.StopServer]: "Stopping server",
-        [ActionCommand.RebootServer]: "Rebooting server",
-        [ActionCommand.ResetServer]: "Resetting server",
-        [ActionCommand.ShutdownServer]: "Shutting down server",
-        [ActionCommand.Poweroff]: "Cutting power to server",
-        [ActionCommand.ChangeServerType]: "Changing server type",
-        [ActionCommand.RebuildServer]: "Rebuilding server",
-        [ActionCommand.EnableBackup]: "Enabling backups",
-        [ActionCommand.DisableBackup]: "Disabling backups",
-        [ActionCommand.CreateImage]: "Creating image",
-        [ActionCommand.ChangeDnsPtr]: "Changing reverse DNS",
-        [ActionCommand.AttachToNetwork]: "Attaching to network",
-        [ActionCommand.DetachFromNetwork]: "Detaching from network",
-        [ActionCommand.ChangeAliasIps]: "Changing alias IPs",
-        [ActionCommand.EnableRescue]: "Enabling rescue mode",
-        [ActionCommand.DisableRescue]: "Disabling rescue mode",
-        [ActionCommand.ChangeProtection]: "Changing protection",
-        [ActionCommand.CreateVolume]: "Creating volume",
-        [ActionCommand.DeleteVolume]: "Deleting volume",
-        [ActionCommand.AttachVolume]: "Attaching volume",
-        [ActionCommand.DetachVolume]: "Detaching volume",
-        [ActionCommand.ResizeVolume]: "Resizing volume",
-        [ActionCommand.VolumeChangeProtection]: "Changing volume protection",
-        [ActionCommand.AddSubnet]: "Adding subnet",
-        [ActionCommand.DeleteSubnet]: "Deleting subnet",
-        [ActionCommand.AddRoute]: "Adding route",
-        [ActionCommand.DeleteRoute]: "Deleting route",
-        [ActionCommand.ChangeIpRange]: "Changing IP range",
-        [ActionCommand.NetworkChangeProtection]: "Changing network protection",
-        [ActionCommand.AssignFloatingIp]: "Assigning floating IP",
-        [ActionCommand.UnassignFloatingIp]: "Unassigning floating IP",
-        [ActionCommand.FloatingIpChangeDnsPtr]: "Changing floating IP DNS",
-        [ActionCommand.FloatingIpChangeProtection]: "Changing floating IP protection",
-        [ActionCommand.CreateLoadBalancer]: "Creating load balancer",
-        [ActionCommand.DeleteLoadBalancer]: "Deleting load balancer",
-        [ActionCommand.AddTarget]: "Adding target to load balancer",
-        [ActionCommand.RemoveTarget]: "Removing target from load balancer",
-        [ActionCommand.AddService]: "Adding service to load balancer",
-        [ActionCommand.UpdateService]: "Updating load balancer service",
-        [ActionCommand.DeleteService]: "Deleting load balancer service",
-        [ActionCommand.LoadBalancerAttachToNetwork]: "Attaching load balancer to network",
-        [ActionCommand.LoadBalancerDetachFromNetwork]: "Detaching load balancer from network",
-        [ActionCommand.ChangeAlgorithm]: "Changing load balancer algorithm",
-        [ActionCommand.ChangeType]: "Changing load balancer type",
-        [ActionCommand.LoadBalancerChangeProtection]: "Changing load balancer protection",
-        [ActionCommand.IssueCertificate]: "Issuing certificate",
-        [ActionCommand.RetryCertificate]: "Retrying certificate",
-        [ActionCommand.SetFirewallRules]: "Setting firewall rules",
-        [ActionCommand.ApplyFirewall]: "Applying firewall",
-        [ActionCommand.RemoveFirewall]: "Removing firewall",
-        [ActionCommand.FirewallChangeProtection]: "Changing firewall protection",
-        [ActionCommand.ImageChangeProtection]: "Changing image protection",
-    };
+function getActionDescription(command) {
+    var _a;
+    var descriptions = (_a = {},
+        _a[types_js_1.ActionCommand.CreateServer] = "Creating server",
+        _a[types_js_1.ActionCommand.DeleteServer] = "Deleting server",
+        _a[types_js_1.ActionCommand.StartServer] = "Starting server",
+        _a[types_js_1.ActionCommand.StopServer] = "Stopping server",
+        _a[types_js_1.ActionCommand.RebootServer] = "Rebooting server",
+        _a[types_js_1.ActionCommand.ResetServer] = "Resetting server",
+        _a[types_js_1.ActionCommand.ShutdownServer] = "Shutting down server",
+        _a[types_js_1.ActionCommand.Poweroff] = "Cutting power to server",
+        _a[types_js_1.ActionCommand.ChangeServerType] = "Changing server type",
+        _a[types_js_1.ActionCommand.RebuildServer] = "Rebuilding server",
+        _a[types_js_1.ActionCommand.EnableBackup] = "Enabling backups",
+        _a[types_js_1.ActionCommand.DisableBackup] = "Disabling backups",
+        _a[types_js_1.ActionCommand.CreateImage] = "Creating image",
+        _a[types_js_1.ActionCommand.ChangeDnsPtr] = "Changing reverse DNS",
+        _a[types_js_1.ActionCommand.AttachToNetwork] = "Attaching to network",
+        _a[types_js_1.ActionCommand.DetachFromNetwork] = "Detaching from network",
+        _a[types_js_1.ActionCommand.ChangeAliasIps] = "Changing alias IPs",
+        _a[types_js_1.ActionCommand.EnableRescue] = "Enabling rescue mode",
+        _a[types_js_1.ActionCommand.DisableRescue] = "Disabling rescue mode",
+        _a[types_js_1.ActionCommand.ChangeProtection] = "Changing protection",
+        _a[types_js_1.ActionCommand.CreateVolume] = "Creating volume",
+        _a[types_js_1.ActionCommand.DeleteVolume] = "Deleting volume",
+        _a[types_js_1.ActionCommand.AttachVolume] = "Attaching volume",
+        _a[types_js_1.ActionCommand.DetachVolume] = "Detaching volume",
+        _a[types_js_1.ActionCommand.ResizeVolume] = "Resizing volume",
+        _a[types_js_1.ActionCommand.VolumeChangeProtection] = "Changing volume protection",
+        _a[types_js_1.ActionCommand.AddSubnet] = "Adding subnet",
+        _a[types_js_1.ActionCommand.DeleteSubnet] = "Deleting subnet",
+        _a[types_js_1.ActionCommand.AddRoute] = "Adding route",
+        _a[types_js_1.ActionCommand.DeleteRoute] = "Deleting route",
+        _a[types_js_1.ActionCommand.ChangeIpRange] = "Changing IP range",
+        _a[types_js_1.ActionCommand.NetworkChangeProtection] = "Changing network protection",
+        _a[types_js_1.ActionCommand.AssignFloatingIp] = "Assigning floating IP",
+        _a[types_js_1.ActionCommand.UnassignFloatingIp] = "Unassigning floating IP",
+        _a[types_js_1.ActionCommand.FloatingIpChangeDnsPtr] = "Changing floating IP DNS",
+        _a[types_js_1.ActionCommand.FloatingIpChangeProtection] = "Changing floating IP protection",
+        _a[types_js_1.ActionCommand.CreateLoadBalancer] = "Creating load balancer",
+        _a[types_js_1.ActionCommand.DeleteLoadBalancer] = "Deleting load balancer",
+        _a[types_js_1.ActionCommand.AddTarget] = "Adding target to load balancer",
+        _a[types_js_1.ActionCommand.RemoveTarget] = "Removing target from load balancer",
+        _a[types_js_1.ActionCommand.AddService] = "Adding service to load balancer",
+        _a[types_js_1.ActionCommand.UpdateService] = "Updating load balancer service",
+        _a[types_js_1.ActionCommand.DeleteService] = "Deleting load balancer service",
+        _a[types_js_1.ActionCommand.LoadBalancerAttachToNetwork] = "Attaching load balancer to network",
+        _a[types_js_1.ActionCommand.LoadBalancerDetachFromNetwork] = "Detaching load balancer from network",
+        _a[types_js_1.ActionCommand.ChangeAlgorithm] = "Changing load balancer algorithm",
+        _a[types_js_1.ActionCommand.ChangeType] = "Changing load balancer type",
+        _a[types_js_1.ActionCommand.LoadBalancerChangeProtection] = "Changing load balancer protection",
+        _a[types_js_1.ActionCommand.IssueCertificate] = "Issuing certificate",
+        _a[types_js_1.ActionCommand.RetryCertificate] = "Retrying certificate",
+        _a[types_js_1.ActionCommand.SetFirewallRules] = "Setting firewall rules",
+        _a[types_js_1.ActionCommand.ApplyFirewall] = "Applying firewall",
+        _a[types_js_1.ActionCommand.RemoveFirewall] = "Removing firewall",
+        _a[types_js_1.ActionCommand.FirewallChangeProtection] = "Changing firewall protection",
+        _a[types_js_1.ActionCommand.ImageChangeProtection] = "Changing image protection",
+        _a);
     return descriptions[command] || command.replace(/_/g, " ");
 }
 // ============================================================================
@@ -674,30 +928,31 @@ export function getActionDescription(command) {
 /**
  * Get adaptive polling interval based on operation type
  */
-export function getPollInterval(command) {
-    const intervals = {
+function getPollInterval(command) {
+    var _a;
+    var intervals = (_a = {},
         // Quick operations - poll frequently
-        [ActionCommand.StartServer]: 5000,
-        [ActionCommand.StopServer]: 5000,
-        [ActionCommand.RebootServer]: 10000,
-        [ActionCommand.Poweroff]: 5000,
-        [ActionCommand.ShutdownServer]: 5000,
+        _a[types_js_1.ActionCommand.StartServer] = 5000,
+        _a[types_js_1.ActionCommand.StopServer] = 5000,
+        _a[types_js_1.ActionCommand.RebootServer] = 10000,
+        _a[types_js_1.ActionCommand.Poweroff] = 5000,
+        _a[types_js_1.ActionCommand.ShutdownServer] = 5000,
         // Medium operations
-        [ActionCommand.CreateServer]: 15000,
-        [ActionCommand.CreateVolume]: 10000,
-        [ActionCommand.AttachVolume]: 8000,
-        [ActionCommand.DetachVolume]: 5000,
+        _a[types_js_1.ActionCommand.CreateServer] = 15000,
+        _a[types_js_1.ActionCommand.CreateVolume] = 10000,
+        _a[types_js_1.ActionCommand.AttachVolume] = 8000,
+        _a[types_js_1.ActionCommand.DetachVolume] = 5000,
         // Long operations - poll less frequently
-        [ActionCommand.RebuildServer]: 30000,
-        [ActionCommand.CreateImage]: 60000,
-        [ActionCommand.IssueCertificate]: 30000,
-    };
+        _a[types_js_1.ActionCommand.RebuildServer] = 30000,
+        _a[types_js_1.ActionCommand.CreateImage] = 60000,
+        _a[types_js_1.ActionCommand.IssueCertificate] = 30000,
+        _a);
     return intervals[command] || 10000; // Default 10 seconds
 }
 /**
  * Get adaptive polling interval based on action progress
  */
-export function getAdaptivePollInterval(progress) {
+function getAdaptivePollInterval(progress) {
     if (progress < 10)
         return 2000; // Quick progress at start
     if (progress < 50)
@@ -711,28 +966,43 @@ export function getAdaptivePollInterval(progress) {
  *
  * @deprecated Use pollAction() with adaptive: true option instead
  */
-export async function waitForActionAdaptive(client, actionId, command, options = {}) {
-    const startTime = Date.now();
-    const timeout = options.timeout ?? getActionTimeout(command);
-    let lastProgress = -1;
-    while (Date.now() - startTime < timeout) {
-        const action = await client.request(`/actions/${actionId}`);
-        // Notify progress callback
-        if (action.action.progress !== lastProgress) {
-            lastProgress = action.action.progress;
-            options.onProgress?.(action.action);
-        }
-        if (action.action.status === "success") {
-            return action.action;
-        }
-        if (action.action.status === "error") {
-            throw new HetznerActionError(action.action.error, actionId);
-        }
-        // Adaptive polling based on progress
-        const interval = getAdaptivePollInterval(action.action.progress);
-        await sleep(interval);
-    }
-    throw new HetznerTimeoutError(actionId, timeout, lastProgress);
+function waitForActionAdaptive(client_1, actionId_1, command_1) {
+    return __awaiter(this, arguments, void 0, function (client, actionId, command, options) {
+        var startTime, timeout, lastProgress, action, interval;
+        var _a, _b;
+        if (options === void 0) { options = {}; }
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    startTime = Date.now();
+                    timeout = (_a = options.timeout) !== null && _a !== void 0 ? _a : getActionTimeout(command);
+                    lastProgress = -1;
+                    _c.label = 1;
+                case 1:
+                    if (!(Date.now() - startTime < timeout)) return [3 /*break*/, 4];
+                    return [4 /*yield*/, client.request("/actions/".concat(actionId))];
+                case 2:
+                    action = _c.sent();
+                    // Notify progress callback
+                    if (action.action.progress !== lastProgress) {
+                        lastProgress = action.action.progress;
+                        (_b = options.onProgress) === null || _b === void 0 ? void 0 : _b.call(options, action.action);
+                    }
+                    if (action.action.status === "success") {
+                        return [2 /*return*/, action.action];
+                    }
+                    if (action.action.status === "error") {
+                        throw new errors_js_1.HetznerActionError(action.action.error, actionId);
+                    }
+                    interval = getAdaptivePollInterval(action.action.progress);
+                    return [4 /*yield*/, sleep(interval)];
+                case 3:
+                    _c.sent();
+                    return [3 /*break*/, 1];
+                case 4: throw new errors_js_1.HetznerTimeoutError(actionId, timeout, lastProgress);
+            }
+        });
+    });
 }
 // ============================================================================
 // Rate Limit Handling
@@ -740,10 +1010,10 @@ export async function waitForActionAdaptive(client, actionId, command, options =
 /**
  * Parse rate limit headers from response
  */
-export function parseRateLimitHeaders(headers) {
-    const limit = headers.get("RateLimit-Limit");
-    const remaining = headers.get("RateLimit-Remaining");
-    const reset = headers.get("RateLimit-Reset");
+function parseRateLimitHeaders(headers) {
+    var limit = headers.get("RateLimit-Limit");
+    var remaining = headers.get("RateLimit-Remaining");
+    var reset = headers.get("RateLimit-Reset");
     if (!limit || !remaining || !reset) {
         return null;
     }
@@ -756,31 +1026,43 @@ export function parseRateLimitHeaders(headers) {
 /**
  * Check if rate limit is low (should warn user)
  */
-export function isRateLimitLow(info, threshold = 100) {
+function isRateLimitLow(info, threshold) {
+    if (threshold === void 0) { threshold = 100; }
     return info.remaining < threshold;
 }
 /**
  * Get human-readable rate limit status
  */
-export function formatRateLimitStatus(info) {
-    const resetDate = new Date(info.reset * 1000);
-    const remaining = info.remaining;
-    const limit = info.limit;
-    const percentage = ((remaining / limit) * 100).toFixed(1);
-    return `${remaining}/${limit} (${percentage}%) - resets at ${resetDate.toISOString()}`;
+function formatRateLimitStatus(info) {
+    var resetDate = new Date(info.reset * 1000);
+    var remaining = info.remaining;
+    var limit = info.limit;
+    var percentage = ((remaining / limit) * 100).toFixed(1);
+    return "".concat(remaining, "/").concat(limit, " (").concat(percentage, "%) - resets at ").concat(resetDate.toISOString());
 }
 /**
  * Wait for rate limit to reset
  */
-export async function waitForRateLimitReset(info) {
-    const resetTime = info.reset * 1000;
-    const now = Date.now();
-    const waitTime = Math.max(0, resetTime - now);
-    if (waitTime > 0) {
-        const waitSeconds = Math.ceil(waitTime / 1000);
-        console.log(`Rate limit exhausted. Waiting ${waitSeconds}s for reset...`);
-        await sleep(waitTime);
-    }
+function waitForRateLimitReset(info) {
+    return __awaiter(this, void 0, void 0, function () {
+        var resetTime, now, waitTime, waitSeconds;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    resetTime = info.reset * 1000;
+                    now = Date.now();
+                    waitTime = Math.max(0, resetTime - now);
+                    if (!(waitTime > 0)) return [3 /*break*/, 2];
+                    waitSeconds = Math.ceil(waitTime / 1000);
+                    console.log("Rate limit exhausted. Waiting ".concat(waitSeconds, "s for reset..."));
+                    return [4 /*yield*/, sleep(waitTime)];
+                case 1:
+                    _a.sent();
+                    _a.label = 2;
+                case 2: return [2 /*return*/];
+            }
+        });
+    });
 }
 // ============================================================================
 // Utilities
@@ -789,14 +1071,14 @@ export async function waitForRateLimitReset(info) {
  * Sleep for specified milliseconds
  */
 function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+    return new Promise(function (resolve) { return setTimeout(resolve, ms); });
 }
 /**
  * Create a progress logger for actions
  */
-export function createProgressLogger(prefix = "Action") {
-    return (action) => {
-        console.log(`[${prefix}] ${getActionDescription(action.command)}: ${action.progress}%`);
+function createProgressLogger(prefix) {
+    if (prefix === void 0) { prefix = "Action"; }
+    return function (action) {
+        console.log("[".concat(prefix, "] ").concat(getActionDescription(action.command), ": ").concat(action.progress, "%"));
     };
 }
-//# sourceMappingURL=actions.js.map