@ipcom/asterisk-ari 0.0.77 → 0.0.79

package/dist/cjs/index.cjs

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,6 +30,552 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// node_modules/exponential-backoff/dist/options.js
+var require_options = __commonJS({
+  "node_modules/exponential-backoff/dist/options.js"(exports2) {
+    "use strict";
+    var __assign = exports2 && exports2.__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);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var defaultOptions = {
+      delayFirstAttempt: false,
+      jitter: "none",
+      maxDelay: Infinity,
+      numOfAttempts: 10,
+      retry: function() {
+        return true;
+      },
+      startingDelay: 100,
+      timeMultiple: 2
+    };
+    function getSanitizedOptions(options) {
+      var sanitized = __assign(__assign({}, defaultOptions), options);
+      if (sanitized.numOfAttempts < 1) {
+        sanitized.numOfAttempts = 1;
+      }
+      return sanitized;
+    }
+    exports2.getSanitizedOptions = getSanitizedOptions;
+  }
+});
+
+// node_modules/exponential-backoff/dist/jitter/full/full.jitter.js
+var require_full_jitter = __commonJS({
+  "node_modules/exponential-backoff/dist/jitter/full/full.jitter.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    function fullJitter(delay) {
+      var jitteredDelay = Math.random() * delay;
+      return Math.round(jitteredDelay);
+    }
+    exports2.fullJitter = fullJitter;
+  }
+});
+
+// node_modules/exponential-backoff/dist/jitter/no/no.jitter.js
+var require_no_jitter = __commonJS({
+  "node_modules/exponential-backoff/dist/jitter/no/no.jitter.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    function noJitter(delay) {
+      return delay;
+    }
+    exports2.noJitter = noJitter;
+  }
+});
+
+// node_modules/exponential-backoff/dist/jitter/jitter.factory.js
+var require_jitter_factory = __commonJS({
+  "node_modules/exponential-backoff/dist/jitter/jitter.factory.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var full_jitter_1 = require_full_jitter();
+    var no_jitter_1 = require_no_jitter();
+    function JitterFactory(options) {
+      switch (options.jitter) {
+        case "full":
+          return full_jitter_1.fullJitter;
+        case "none":
+        default:
+          return no_jitter_1.noJitter;
+      }
+    }
+    exports2.JitterFactory = JitterFactory;
+  }
+});
+
+// node_modules/exponential-backoff/dist/delay/delay.base.js
+var require_delay_base = __commonJS({
+  "node_modules/exponential-backoff/dist/delay/delay.base.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var jitter_factory_1 = require_jitter_factory();
+    var Delay = (
+      /** @class */
+      function() {
+        function Delay2(options) {
+          this.options = options;
+          this.attempt = 0;
+        }
+        Delay2.prototype.apply = function() {
+          var _this = this;
+          return new Promise(function(resolve) {
+            return setTimeout(resolve, _this.jitteredDelay);
+          });
+        };
+        Delay2.prototype.setAttemptNumber = function(attempt) {
+          this.attempt = attempt;
+        };
+        Object.defineProperty(Delay2.prototype, "jitteredDelay", {
+          get: function() {
+            var jitter = jitter_factory_1.JitterFactory(this.options);
+            return jitter(this.delay);
+          },
+          enumerable: true,
+          configurable: true
+        });
+        Object.defineProperty(Delay2.prototype, "delay", {
+          get: function() {
+            var constant = this.options.startingDelay;
+            var base = this.options.timeMultiple;
+            var power = this.numOfDelayedAttempts;
+            var delay = constant * Math.pow(base, power);
+            return Math.min(delay, this.options.maxDelay);
+          },
+          enumerable: true,
+          configurable: true
+        });
+        Object.defineProperty(Delay2.prototype, "numOfDelayedAttempts", {
+          get: function() {
+            return this.attempt;
+          },
+          enumerable: true,
+          configurable: true
+        });
+        return Delay2;
+      }()
+    );
+    exports2.Delay = Delay;
+  }
+});
+
+// node_modules/exponential-backoff/dist/delay/skip-first/skip-first.delay.js
+var require_skip_first_delay = __commonJS({
+  "node_modules/exponential-backoff/dist/delay/skip-first/skip-first.delay.js"(exports2) {
+    "use strict";
+    var __extends = exports2 && exports2.__extends || /* @__PURE__ */ function() {
+      var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+          d2.__proto__ = b2;
+        } || function(d2, b2) {
+          for (var p in b2) if (b2.hasOwnProperty(p)) d2[p] = b2[p];
+        };
+        return extendStatics(d, b);
+      };
+      return function(d, b) {
+        extendStatics(d, b);
+        function __() {
+          this.constructor = d;
+        }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+      };
+    }();
+    var __awaiter = exports2 && exports2.__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 = exports2 && exports2.__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;
+      return g = { next: verb(0), "throw": verb(1), "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 (_) 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 };
+      }
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var delay_base_1 = require_delay_base();
+    var SkipFirstDelay = (
+      /** @class */
+      function(_super) {
+        __extends(SkipFirstDelay2, _super);
+        function SkipFirstDelay2() {
+          return _super !== null && _super.apply(this, arguments) || this;
+        }
+        SkipFirstDelay2.prototype.apply = function() {
+          return __awaiter(this, void 0, void 0, function() {
+            return __generator(this, function(_a) {
+              return [2, this.isFirstAttempt ? true : _super.prototype.apply.call(this)];
+            });
+          });
+        };
+        Object.defineProperty(SkipFirstDelay2.prototype, "isFirstAttempt", {
+          get: function() {
+            return this.attempt === 0;
+          },
+          enumerable: true,
+          configurable: true
+        });
+        Object.defineProperty(SkipFirstDelay2.prototype, "numOfDelayedAttempts", {
+          get: function() {
+            return this.attempt - 1;
+          },
+          enumerable: true,
+          configurable: true
+        });
+        return SkipFirstDelay2;
+      }(delay_base_1.Delay)
+    );
+    exports2.SkipFirstDelay = SkipFirstDelay;
+  }
+});
+
+// node_modules/exponential-backoff/dist/delay/always/always.delay.js
+var require_always_delay = __commonJS({
+  "node_modules/exponential-backoff/dist/delay/always/always.delay.js"(exports2) {
+    "use strict";
+    var __extends = exports2 && exports2.__extends || /* @__PURE__ */ function() {
+      var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+          d2.__proto__ = b2;
+        } || function(d2, b2) {
+          for (var p in b2) if (b2.hasOwnProperty(p)) d2[p] = b2[p];
+        };
+        return extendStatics(d, b);
+      };
+      return function(d, b) {
+        extendStatics(d, b);
+        function __() {
+          this.constructor = d;
+        }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+      };
+    }();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var delay_base_1 = require_delay_base();
+    var AlwaysDelay = (
+      /** @class */
+      function(_super) {
+        __extends(AlwaysDelay2, _super);
+        function AlwaysDelay2() {
+          return _super !== null && _super.apply(this, arguments) || this;
+        }
+        return AlwaysDelay2;
+      }(delay_base_1.Delay)
+    );
+    exports2.AlwaysDelay = AlwaysDelay;
+  }
+});
+
+// node_modules/exponential-backoff/dist/delay/delay.factory.js
+var require_delay_factory = __commonJS({
+  "node_modules/exponential-backoff/dist/delay/delay.factory.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var skip_first_delay_1 = require_skip_first_delay();
+    var always_delay_1 = require_always_delay();
+    function DelayFactory(options, attempt) {
+      var delay = initDelayClass(options);
+      delay.setAttemptNumber(attempt);
+      return delay;
+    }
+    exports2.DelayFactory = DelayFactory;
+    function initDelayClass(options) {
+      if (!options.delayFirstAttempt) {
+        return new skip_first_delay_1.SkipFirstDelay(options);
+      }
+      return new always_delay_1.AlwaysDelay(options);
+    }
+  }
+});
+
+// node_modules/exponential-backoff/dist/backoff.js
+var require_backoff = __commonJS({
+  "node_modules/exponential-backoff/dist/backoff.js"(exports2) {
+    "use strict";
+    var __awaiter = exports2 && exports2.__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 = exports2 && exports2.__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;
+      return g = { next: verb(0), "throw": verb(1), "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 (_) 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 };
+      }
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var options_1 = require_options();
+    var delay_factory_1 = require_delay_factory();
+    function backOff3(request, options) {
+      if (options === void 0) {
+        options = {};
+      }
+      return __awaiter(this, void 0, void 0, function() {
+        var sanitizedOptions, backOff4;
+        return __generator(this, function(_a) {
+          switch (_a.label) {
+            case 0:
+              sanitizedOptions = options_1.getSanitizedOptions(options);
+              backOff4 = new BackOff(request, sanitizedOptions);
+              return [4, backOff4.execute()];
+            case 1:
+              return [2, _a.sent()];
+          }
+        });
+      });
+    }
+    exports2.backOff = backOff3;
+    var BackOff = (
+      /** @class */
+      function() {
+        function BackOff2(request, options) {
+          this.request = request;
+          this.options = options;
+          this.attemptNumber = 0;
+        }
+        BackOff2.prototype.execute = function() {
+          return __awaiter(this, void 0, void 0, function() {
+            var e_1, shouldRetry;
+            return __generator(this, function(_a) {
+              switch (_a.label) {
+                case 0:
+                  if (!!this.attemptLimitReached) return [3, 7];
+                  _a.label = 1;
+                case 1:
+                  _a.trys.push([1, 4, , 6]);
+                  return [4, this.applyDelay()];
+                case 2:
+                  _a.sent();
+                  return [4, this.request()];
+                case 3:
+                  return [2, _a.sent()];
+                case 4:
+                  e_1 = _a.sent();
+                  this.attemptNumber++;
+                  return [4, this.options.retry(e_1, this.attemptNumber)];
+                case 5:
+                  shouldRetry = _a.sent();
+                  if (!shouldRetry || this.attemptLimitReached) {
+                    throw e_1;
+                  }
+                  return [3, 6];
+                case 6:
+                  return [3, 0];
+                case 7:
+                  throw new Error("Something went wrong.");
+              }
+            });
+          });
+        };
+        Object.defineProperty(BackOff2.prototype, "attemptLimitReached", {
+          get: function() {
+            return this.attemptNumber >= this.options.numOfAttempts;
+          },
+          enumerable: true,
+          configurable: true
+        });
+        BackOff2.prototype.applyDelay = function() {
+          return __awaiter(this, void 0, void 0, function() {
+            var delay;
+            return __generator(this, function(_a) {
+              switch (_a.label) {
+                case 0:
+                  delay = delay_factory_1.DelayFactory(this.options, this.attemptNumber);
+                  return [4, delay.apply()];
+                case 1:
+                  _a.sent();
+                  return [
+                    2
+                    /*return*/
+                  ];
+              }
+            });
+          });
+        };
+        return BackOff2;
+      }()
+    );
+  }
+});
+
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
@@ -43,6 +592,9 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
+// src/ari-client/ariClient.ts
+var import_exponential_backoff2 = __toESM(require_backoff(), 1);
+
 // src/ari-client/baseClient.ts
 var import_events = require("events");
 var import_axios = __toESM(require("axios"), 1);
@@ -368,16 +920,12 @@ function toQueryParams2(options) {
     Object.entries(options).filter(([, value]) => value !== void 0).map(([key, value]) => [key, value])
   ).toString();
 }
+function isPlaybackEvent(event, playbackId) {
+  return event.type.startsWith("Playback") && "playbackId" in event && event.playbackId !== void 0 && (!playbackId || event.playbackId === playbackId);
+}
 function isChannelEvent(event, channelId) {
   const hasChannel = "channel" in event && event.channel?.id !== void 0;
-  const matchesChannelId = hasChannel && (!channelId || event.channel?.id === channelId);
-  if (!hasChannel || channelId && !matchesChannelId) {
-    console.log(
-      `Evento ignorado no isChannelEvent: tipo=${event.type}, canal esperado=${channelId}, evento recebido=`,
-      event
-    );
-  }
-  return matchesChannelId;
+  return hasChannel && (!channelId || event.channel?.id === channelId);
 }
 
 // src/ari-client/resources/channels.ts
@@ -614,7 +1162,7 @@ var Channels = class extends import_events2.EventEmitter {
     this.baseClient = baseClient;
     this.client = client;
   }
-  createChannelInstance(channelId) {
+  Channel(channelId) {
     return new ChannelInstance(this.client, this.baseClient, channelId);
   }
   /**
@@ -845,14 +1393,15 @@ var Endpoints = class {
 var import_events3 = require("events");
 var PlaybackInstance = class extends import_events3.EventEmitter {
   // Garantimos que o ID esteja disponível
-  constructor(baseClient, playbackId) {
+  constructor(client, baseClient, playbackId) {
     super();
+    this.client = client;
     this.baseClient = baseClient;
     this.playbackId = playbackId;
     this.id = playbackId || `playback-${Date.now()}`;
-    const wsClients = this.baseClient.getWebSocketClients();
+    const wsClients = this.client.getWebSocketClients();
     const wsClient = Array.from(wsClients.values()).find(
-      (client) => client.isConnected()
+      (client2) => client2.isConnected()
     );
     if (!wsClient) {
       throw new Error(
@@ -860,31 +1409,14 @@ var PlaybackInstance = class extends import_events3.EventEmitter {
       );
     }
     wsClient.on("message", (event) => {
-      if (this.isPlaybackEvent(event)) {
-        console.log(
-          `Evento recebido no PlaybackInstance: ${event.type}`,
-          event
-        );
+      if (isPlaybackEvent(event, this.id)) {
+        console.log(`Evento recebido no ChannelInstance: ${event.type}`, event);
         this.emit(event.type, event);
       }
     });
   }
   playbackData = null;
   id;
-  /**
-   * Verifica se o evento é relacionado a um playback.
-   */
-  isPlaybackEvent(event) {
-    const isPlaybackType = event?.type.startsWith("Playback");
-    const isPlaybackEvent = isPlaybackType && "playbackId" in event && event.playbackId === this.id;
-    if (!isPlaybackEvent) {
-      console.log(
-        `Evento ignorado no isPlaybackEvent: tipo=${event.type}, playback esperado=${this.id}, evento recebido=`,
-        event
-      );
-    }
-    return isPlaybackEvent;
-  }
   /**
    * Obtém os detalhes do playback.
    */
@@ -939,38 +1471,23 @@ var PlaybackInstance = class extends import_events3.EventEmitter {
   }
 };
 var Playbacks = class extends import_events3.EventEmitter {
-  constructor(client) {
+  constructor(baseClient, client) {
     super();
+    this.baseClient = baseClient;
     this.client = client;
-    this.client.onWebSocketEvent((event) => {
-      if (this.isPlaybackEvent(event)) {
-        const playbackId = event.playbackId;
-        if (playbackId) {
-          this.emit(`${event.type}:${playbackId}`, event);
-        }
-        this.emit(event.type, event);
-      }
-    });
-  }
-  /**
-   * Obtém os clientes WebSocket disponíveis.
-   */
-  getWebSocketClients() {
-    return this.client.getWebSocketClients();
-  }
-  /**
-   * Verifica se o evento é relacionado a um playback.
-   */
-  isPlaybackEvent(event) {
-    console.log({ eventAri: event });
-    return event && typeof event === "object" && "playbackId" in event;
   }
   /**
    * Inicializa uma nova instância de `PlaybackInstance`.
    */
   Playback(playbackId) {
     const id = playbackId || `playback-${Date.now()}`;
-    return new PlaybackInstance(this.client, id);
+    return new PlaybackInstance(this.client, this.baseClient, id);
+  }
+  /**
+   * Obtém os clientes WebSocket disponíveis.
+   */
+  getWebSocketClients() {
+    return this.client.getWebSocketClients();
   }
   /**
    * Emite eventos de playback.
@@ -992,7 +1509,7 @@ var Playbacks = class extends import_events3.EventEmitter {
    * @returns A promise that resolves to a Playback object containing the details of the specified playback.
    */
   async getDetails(playbackId) {
-    return this.client.get(`/playbacks/${playbackId}`);
+    return this.baseClient.get(`/playbacks/${playbackId}`);
   }
   /**
    * Controls a specific playback by performing various operations such as pause, resume, restart, reverse, forward, or stop.
@@ -1008,7 +1525,7 @@ var Playbacks = class extends import_events3.EventEmitter {
    * @returns A promise that resolves when the control operation is successfully executed.
    */
   async control(playbackId, operation) {
-    await this.client.post(
+    await this.baseClient.post(
       `/playbacks/${playbackId}/control?operation=${operation}`
     );
   }
@@ -1019,7 +1536,7 @@ var Playbacks = class extends import_events3.EventEmitter {
    * @returns A promise that resolves when the playback is successfully stopped.
    */
   async stop(playbackId) {
-    await this.client.delete(`/playbacks/${playbackId}`);
+    await this.baseClient.delete(`/playbacks/${playbackId}`);
   }
   /**
    * Registers a listener for playback events.
@@ -1087,8 +1604,10 @@ var Sounds = class {
 
 // src/ari-client/websocketClient.ts
 var import_events4 = require("events");
+var import_exponential_backoff = __toESM(require_backoff(), 1);
 var import_ws = __toESM(require("ws"), 1);
 var WebSocketClient = class extends import_events4.EventEmitter {
+  // Para gerenciar tentativas de reconexão
   /**
    * Creates a new WebSocketClient instance.
    * @param url - The WebSocket server URL to connect to.
@@ -1101,6 +1620,44 @@ var WebSocketClient = class extends import_events4.EventEmitter {
   isClosedManually = false;
   isReconnecting = false;
   messageListeners = [];
+  maxReconnectAttempts = 30;
+  reconnectAttempts = 0;
+  async reconnect() {
+    console.log("Iniciando processo de reconex\xE3o...");
+    const backoffOptions = {
+      delayFirstAttempt: false,
+      startingDelay: 1e3,
+      // 1 segundo inicial
+      timeMultiple: 2,
+      // Multiplicador exponencial
+      maxDelay: 3e4,
+      // 30 segundos de atraso máximo
+      numOfAttempts: this.maxReconnectAttempts,
+      // Limite de tentativas
+      jitter: "full",
+      retry: (error, attemptNumber) => {
+        console.warn(
+          `Tentativa ${attemptNumber} de reconex\xE3o falhou: ${error.message}`
+        );
+        return !this.isClosedManually;
+      }
+    };
+    try {
+      await (0, import_exponential_backoff.backOff)(async () => {
+        console.log(`Tentando reconectar (#${this.reconnectAttempts + 1})...`);
+        await this.connect();
+        console.log("Reconex\xE3o bem-sucedida.");
+      }, backoffOptions);
+      this.reconnectAttempts = 0;
+      this.isReconnecting = false;
+    } catch (error) {
+      console.error(
+        `Reconex\xE3o falhou ap\xF3s ${this.maxReconnectAttempts} tentativas.`,
+        error
+      );
+      this.isReconnecting = false;
+    }
+  }
   /**
    * Establishes a connection to the WebSocket server.
    * @returns A Promise that resolves when the connection is established, or rejects if an error occurs.
@@ -1114,6 +1671,7 @@ var WebSocketClient = class extends import_events4.EventEmitter {
         console.log("WebSocket conectado.");
         this.isClosedManually = false;
         this.isReconnecting = false;
+        this.reconnectAttempts = 0;
         resolve();
       });
       this.ws.on("error", (err) => {
@@ -1122,8 +1680,10 @@ var WebSocketClient = class extends import_events4.EventEmitter {
       });
       this.ws.on("close", (code, reason) => {
         console.warn(`WebSocket desconectado: ${code} - ${reason}`);
-        this.isReconnecting = false;
         this.emit("close", { code, reason });
+        if (!this.isClosedManually) {
+          this.reconnect();
+        }
       });
       this.ws.on("message", (rawData) => {
         this.handleMessage(rawData);
@@ -1223,9 +1783,9 @@ var AriClient = class {
     const baseUrl = `${httpProtocol}://${normalizedHost}:${config.port}/ari`;
     this.baseClient = new BaseClient(baseUrl, config.username, config.password);
     this.channels = new Channels(this.baseClient, this);
+    this.playbacks = new Playbacks(this.baseClient, this);
     this.endpoints = new Endpoints(this.baseClient);
     this.applications = new Applications(this.baseClient);
-    this.playbacks = new Playbacks(this.baseClient);
     this.sounds = new Sounds(this.baseClient);
     this.asterisk = new Asterisk(this.baseClient);
     this.bridges = new Bridges(this.baseClient);
@@ -1248,11 +1808,27 @@ var AriClient = class {
       }
       while (this.pendingListeners.length > 0) {
         const { event, callback } = this.pendingListeners.shift();
+        if (wsClient.listenerCount(event) > 0) {
+          console.log(
+            `Listener j\xE1 registrado para o evento '${event}' no app '${app}'. Ignorando duplicata.`
+          );
+          continue;
+        }
         console.log(`Registrando listener para '${app}' no evento: ${event}`);
         wsClient.on(event, callback);
       }
     }
   }
+  async reconnectWebSocket(app) {
+    console.log(`Tentando reconectar o WebSocket para o app '${app}'...`);
+    try {
+      await this.connectSingleWebSocket(app);
+      this.processPendingListeners();
+      console.log(`Reconex\xE3o bem-sucedida para o app '${app}'.`);
+    } catch (error) {
+      console.error(`Erro ao reconectar o WebSocket para '${app}':`, error);
+    }
+  }
   channels;
   endpoints;
   applications;
@@ -1264,24 +1840,6 @@ var AriClient = class {
   getWebSocketClients() {
     return this.wsClients;
   }
-  /**
-   * Registra um listener para eventos de WebSocket relacionados a canais.
-   * @param eventType Tipo de evento.
-   * @param callback Callback a ser executado quando o evento for recebido.
-   */
-  onChannelEvent(eventType, callback) {
-    if (this.wsClients.size === 0) {
-      console.warn(
-        "Nenhuma conex\xE3o WebSocket est\xE1 ativa. O listener ser\xE1 pendente."
-      );
-      this.pendingListeners.push({ event: eventType, callback });
-      return;
-    }
-    for (const [app, wsClient] of this.wsClients.entries()) {
-      console.log(`Registrando evento '${eventType}' no app '${app}'`);
-      wsClient.on(eventType, callback);
-    }
-  }
   /**
    * Registra listeners globais para eventos de WebSocket.
    */
@@ -1319,7 +1877,7 @@ var AriClient = class {
   }
   // Método para criar uma instância de ChannelInstance
   createChannelInstance(channelId) {
-    return this.channels.createChannelInstance(channelId);
+    return this.channels.Channel(channelId);
   }
   handleWebSocketEvent(event) {
     console.log("Evento recebido no WebSocket:", event.type, event);
@@ -1383,26 +1941,58 @@ var AriClient = class {
     if (!app) {
       throw new Error("O nome do aplicativo \xE9 obrigat\xF3rio.");
     }
-    if (this.wsClients.has(app)) {
-      console.log(`Conex\xE3o WebSocket para '${app}' j\xE1 existe. Reutilizando...`);
-      return;
+    if (this.webSocketReady.get(app)) {
+      console.log(`Conex\xE3o WebSocket para '${app}' j\xE1 est\xE1 ativa.`);
+      return this.webSocketReady.get(app);
     }
     const protocol = this.config.secure ? "wss" : "ws";
     const eventsParam = subscribedEvents && subscribedEvents.length > 0 ? `&event=${subscribedEvents.join(",")}` : "&subscribeAll=true";
     const wsUrl = `${protocol}://${encodeURIComponent(
       this.config.username
     )}:${encodeURIComponent(this.config.password)}@${this.config.host}:${this.config.port}/ari/events?app=${app}${eventsParam}`;
-    const wsClient = new WebSocketClient(wsUrl);
-    try {
-      await wsClient.connect();
-      console.log(`WebSocket conectado para o app: ${app}`);
-      this.integrateWebSocketEvents(app, wsClient);
-      await this.ensureAppRegistered(app);
-      this.wsClients.set(app, wsClient);
-    } catch (error) {
-      console.error(`Erro ao conectar WebSocket para '${app}':`, error);
-      throw error;
-    }
+    const backoffOptions = {
+      delayFirstAttempt: false,
+      startingDelay: 1e3,
+      timeMultiple: 2,
+      maxDelay: 3e4,
+      numOfAttempts: 10,
+      jitter: "full",
+      retry: (error, attemptNumber) => {
+        console.warn(
+          `Tentativa ${attemptNumber} falhou para '${app}': ${error.message}`
+        );
+        return !this.wsClients.has(app) || !this.wsClients.get(app)?.isConnected();
+      }
+    };
+    const webSocketPromise = new Promise(async (resolve, reject) => {
+      try {
+        if (this.isReconnecting.get(app)) {
+          console.warn(`J\xE1 est\xE1 tentando reconectar para o app '${app}'.`);
+          return;
+        }
+        this.isReconnecting.set(app, true);
+        const wsClient = new WebSocketClient(wsUrl);
+        await (0, import_exponential_backoff2.backOff)(async () => {
+          if (!wsClient) {
+            throw new Error("WebSocketClient instance is null.");
+          }
+          await wsClient.connect();
+          console.log(`WebSocket conectado para o app: ${app}`);
+          this.integrateWebSocketEvents(app, wsClient);
+          await this.ensureAppRegistered(app);
+          this.wsClients.set(app, wsClient);
+          this.processPendingListeners();
+        }, backoffOptions);
+        resolve();
+      } catch (error) {
+        console.error(`Erro ao conectar WebSocket para '${app}':`, error);
+        reject(error);
+      } finally {
+        this.isReconnecting.delete(app);
+      }
+    });
+    this.webSocketReady.set(app, webSocketPromise);
+    return webSocketPromise;
   }
   /**
    * Integrates WebSocket events with playback listeners.
@@ -1515,465 +2105,6 @@ var AriClient = class {
     this.wsClients.clear();
     console.log("Todos os WebSockets foram fechados.");
   }
-  /**
-   * Retrieves a list of active channels from the Asterisk ARI.
-   *
-   * @returns {Promise<Channel[]>} A promise resolving to the list of active channels.
-   */
-  /**
-   * Lists all active channels.
-   */
-  async listChannels() {
-    return this.channels.list();
-  }
-  async hangupChannel(channelId) {
-    return this.channels.hangup(channelId);
-  }
-  /**
-   * Creates a new channel.
-   */
-  async originateChannel(data) {
-    return this.channels.originate(data);
-  }
-  /**
-   * Continues the dialplan for a specific channel.
-   */
-  async continueChannelDialplan(channelId, context, extension, priority, label) {
-    return this.channels.continueDialplan(
-      channelId,
-      context,
-      extension,
-      priority,
-      label
-    );
-  }
-  /**
-   * Moves a channel to another Stasis application.
-   */
-  async moveChannelToApplication(channelId, app, appArgs) {
-    return this.channels.moveToApplication(channelId, app, appArgs);
-  }
-  /**
-   * Sets a channel variable.
-   */
-  async setChannelVariable(channelId, variable, value) {
-    return this.channels.setChannelVariable(channelId, variable, value);
-  }
-  /**
-   * Gets a channel variable.
-   */
-  async getChannelVariable(channelId, variable) {
-    return this.channels.getChannelVariable(channelId, variable);
-  }
-  /**
-   * Starts music on hold for a channel.
-   */
-  async startChannelMusicOnHold(channelId) {
-    return this.channels.startMusicOnHold(channelId);
-  }
-  /**
-   * Stops music on hold for a channel.
-   */
-  async stopChannelMusicOnHold(channelId) {
-    return this.channels.stopMusicOnHold(channelId);
-  }
-  /**
-   * Records audio from a channel.
-   */
-  async recordAudio(channelId, options) {
-    return this.channels.record(channelId, options);
-  }
-  /**
-   * Starts snooping on a channel.
-   */
-  async snoopChannel(channelId, options) {
-    return this.channels.snoopChannel(channelId, options);
-  }
-  /**
-   * Starts snooping on a channel with a specific snoop ID.
-   */
-  async snoopChannelWithId(channelId, snoopId, options) {
-    return this.channels.snoopChannelWithId(channelId, snoopId, options);
-  }
-  /**
-   * Initiates a dial operation on a previously created channel.
-   * This function attempts to connect the specified channel to its configured destination.
-   *
-   * @param channelId - The unique identifier of the channel to dial.
-   * @param caller - Optional. The caller ID to use for the outgoing call. If not provided, the default caller ID for the channel will be used.
-   * @param timeout - Optional. The maximum time in seconds to wait for the dial operation to complete. If not specified, the system's default timeout will be used.
-   * @returns A Promise that resolves when the dial operation has been initiated successfully. Note that this does not guarantee that the call was answered, only that dialing has begun.
-   * @throws Will throw an error if the dial operation fails, e.g., if the channel doesn't exist or is in an invalid state.
-   */
-  async dialChannel(channelId, caller, timeout) {
-    return this.channels.dial(channelId, caller, timeout);
-  }
-  /**
-   * Retrieves RTP statistics for a channel.
-   */
-  async getRTPStatistics(channelId) {
-    return this.channels.getRTPStatistics(channelId);
-  }
-  /**
-   * Creates a channel to an external media source/sink.
-   */
-  async createExternalMedia(options) {
-    return this.channels.createExternalMedia(options);
-  }
-  /**
-   * Redirects a channel to a different location.
-   */
-  async redirectChannel(channelId, endpoint) {
-    return this.channels.redirectChannel(channelId, endpoint);
-  }
-  /**
-   * Sends a ringing indication to a channel.
-   */
-  async ringChannel(channelId) {
-    return this.channels.ringChannel(channelId);
-  }
-  /**
-   * Stops the ringing indication on a specified channel in the Asterisk system.
-   *
-   * This function sends a request to the Asterisk server to cease the ringing
-   * indication on a particular channel. This is typically used when you want to
-   * stop the ringing sound on a channel without answering or hanging up the call.
-   *
-   * @param channelId - The unique identifier of the channel on which to stop the ringing.
-   *                    This should be a string that uniquely identifies the channel in the Asterisk system.
-   *
-   * @returns A Promise that resolves when the ringing has been successfully stopped on the specified channel.
-   *          The promise resolves to void, indicating no specific return value.
-   *          If an error occurs during the operation, the promise will be rejected with an error object.
-   */
-  async stopRingChannel(channelId) {
-    return this.channels.stopRingChannel(channelId);
-  }
-  /**
-   * Sends DTMF (Dual-Tone Multi-Frequency) tones to a specified channel.
-   *
-   * This function allows sending DTMF tones to a channel, which can be used for various purposes
-   * such as interacting with IVR systems or sending signals during a call.
-   *
-   * @param channelId - The unique identifier of the channel to send DTMF tones to.
-   * @param dtmf - A string representing the DTMF tones to send (e.g., "123#").
-   * @param options - Optional parameters to control the timing of DTMF tones.
-   * @param options.before - The time (in milliseconds) to wait before sending DTMF.
-   * @param options.between - The time (in milliseconds) to wait between each DTMF tone.
-   * @param options.duration - The duration (in milliseconds) of each DTMF tone.
-   * @param options.after - The time (in milliseconds) to wait after sending all DTMF tones.
-   * @returns A Promise that resolves when the DTMF tones have been successfully sent.
-   */
-  async sendDTMF(channelId, dtmf, options) {
-    return this.channels.sendDTMF(channelId, dtmf, options);
-  }
-  /**
-   * Mutes a channel in the Asterisk system.
-   *
-   * This function initiates a mute operation on the specified channel, preventing
-   * audio transmission in the specified direction(s).
-   *
-   * @param channelId - The unique identifier of the channel to be muted.
-   *                    This should be a string that uniquely identifies the channel in the Asterisk system.
-   * @param direction - The direction of audio to mute. Can be one of:
-   *                    - "both": Mute both incoming and outgoing audio (default)
-   *                    - "in": Mute only incoming audio
-   *                    - "out": Mute only outgoing audio
-   *
-   * @returns A Promise that resolves when the mute operation has been successfully completed.
-   *          The promise resolves to void, indicating no specific return value.
-   *          If an error occurs during the operation, the promise will be rejected with an error object.
-   */
-  async muteChannel(channelId, direction = "both") {
-    return this.channels.muteChannel(channelId, direction);
-  }
-  /**
-   * Unmutes a channel in the Asterisk system.
-   *
-   * This function removes the mute status from a specified channel, allowing audio
-   * transmission to resume in the specified direction(s).
-   *
-   * @param channelId - The unique identifier of the channel to be unmuted.
-   *                    This should be a string that uniquely identifies the channel in the Asterisk system.
-   * @param direction - The direction of audio to unmute. Can be one of:
-   *                    - "both": Unmute both incoming and outgoing audio (default)
-   *                    - "in": Unmute only incoming audio
-   *                    - "out": Unmute only outgoing audio
-   *
-   * @returns A Promise that resolves when the unmute operation has been successfully completed.
-   *          The promise resolves to void, indicating no specific return value.
-   *          If an error occurs during the operation, the promise will be rejected with an error object.
-   */
-  async unmuteChannel(channelId, direction = "both") {
-    return this.channels.unmuteChannel(channelId, direction);
-  }
-  /**
-   * Puts a specified channel on hold.
-   *
-   * This function initiates a hold operation on the specified channel in the Asterisk system.
-   * When a channel is put on hold, typically the audio is muted or replaced with hold music,
-   * depending on the system configuration.
-   *
-   * @param channelId - The unique identifier of the channel to be put on hold.
-   *                    This should be a string that uniquely identifies the channel in the Asterisk system.
-   *
-   * @returns A Promise that resolves when the hold operation has been successfully initiated.
-   *          The promise resolves to void, indicating no specific return value.
-   *          If an error occurs during the operation, the promise will be rejected with an error object.
-   */
-  async holdChannel(channelId) {
-    return this.channels.holdChannel(channelId);
-  }
-  /**
-   * Removes a specified channel from hold.
-   *
-   * This function initiates an unhold operation on the specified channel in the Asterisk system.
-   * When a channel is taken off hold, it typically resumes normal audio transmission,
-   * allowing the parties to continue their conversation.
-   *
-   * @param channelId - The unique identifier of the channel to be taken off hold.
-   *                    This should be a string that uniquely identifies the channel in the Asterisk system.
-   *
-   * @returns A Promise that resolves when the unhold operation has been successfully initiated.
-   *          The promise resolves to void, indicating no specific return value.
-   *          If an error occurs during the operation, the promise will be rejected with an error object.
-   */
-  async unholdChannel(channelId) {
-    return this.channels.unholdChannel(channelId);
-  }
-  /**
-   * Creates a new channel in the Asterisk system using the provided originate request data.
-   * This function initiates a new communication channel based on the specified parameters.
-   *
-   * @param data - An object containing the originate request data for channel creation.
-   *               This includes details such as the endpoint to call, the context to use,
-   *               and any variables to set on the new channel.
-   * @param data.endpoint - The endpoint to call (e.g., "SIP/1234").
-   * @param data.extension - The extension to dial after the channel is created.
-   * @param data.context - The dialplan context to use for the new channel.
-   * @param data.priority - The priority to start at in the dialplan.
-   * @param data.app - The application to execute on the channel (alternative to extension/context/priority).
-   * @param data.appArgs - The arguments to pass to the application, if 'app' is specified.
-   * @param data.callerId - The caller ID to set on the new channel.
-   * @param data.timeout - The timeout (in seconds) to wait for the channel to be answered.
-   * @param data.variables - An object containing key-value pairs of channel variables to set.
-   * @param data.channelId - An optional ID to assign to the new channel.
-   * @param data.otherChannelId - The ID of another channel to bridge with after creation.
-   *
-   * @returns A Promise that resolves to the created Channel object.
-   *          The Channel object contains details about the newly created channel,
-   *          such as its unique identifier, state, and other relevant information.
-   *
-   * @throws Will throw an error if the channel creation fails for any reason,
-   *         such as invalid parameters or system issues.
-   */
-  async createChannel(data) {
-    return this.channels.createChannel(data);
-  }
-  /**
-   * Originates a new channel with a specified ID using the provided originate request data.
-   *
-   * @param channelId - The desired unique identifier for the new channel.
-   * @param data - The originate request data containing channel creation parameters.
-   * @returns A promise that resolves to the created Channel object.
-   */
-  async originateWithId(channelId, data) {
-    return this.channels.originateWithId(channelId, data);
-  }
-  // Métodos relacionados a endpoints:
-  /**
-   * Lists all endpoints.
-   *
-   * @returns {Promise<Endpoint[]>} A promise resolving to the list of endpoints.
-   */
-  async listEndpoints() {
-    return this.endpoints.list();
-  }
-  /**
-   * Retrieves details of a specific endpoint.
-   *
-   * @param technology - The technology of the endpoint.
-   * @param resource - The resource name of the endpoint.
-   * @returns {Promise<EndpointDetails>} A promise resolving to the details of the endpoint.
-   */
-  async getEndpointDetails(technology, resource) {
-    return this.endpoints.getDetails(technology, resource);
-  }
-  /**
-   * Sends a message to an endpoint.
-   *
-   * @param technology - The technology of the endpoint.
-   * @param resource - The resource name of the endpoint.
-   * @param body - The message body to send.
-   * @returns {Promise<void>} A promise resolving when the message is sent.
-   */
-  async sendMessageToEndpoint(technology, resource, body) {
-    return this.endpoints.sendMessage(technology, resource, body);
-  }
-  // Métodos relacionados a applications
-  /**
-   * Lists all applications.
-   *
-   * @returns {Promise<Application[]>} A promise resolving to the list of applications.
-   */
-  async listApplications() {
-    return this.applications.list();
-  }
-  /**
-   * Retrieves details of a specific application.
-   *
-   * @param appName - The name of the application.
-   * @returns {Promise<ApplicationDetails>} A promise resolving to the application details.
-   */
-  async getApplicationDetails(appName) {
-    return this.applications.getDetails(appName);
-  }
-  /**
-   * Sends a message to a specific application.
-   *
-   * @param appName - The name of the application.
-   * @param body - The message body to send.
-   * @returns {Promise<void>} A promise resolving when the message is sent successfully.
-   */
-  async sendMessageToApplication(appName, body) {
-    return this.applications.sendMessage(appName, body);
-  }
-  // Métodos relacionados a playbacks
-  /**
-   * Retrieves details of a specific playback.
-   *
-   * @param playbackId - The unique identifier of the playback.
-   * @returns {Promise<Playback>} A promise resolving to the playback details.
-   */
-  async getPlaybackDetails(playbackId) {
-    return this.playbacks.getDetails(playbackId);
-  }
-  /**
-   * Controls a specific playback in the Asterisk server.
-   * This function allows manipulation of an ongoing playback, such as pausing, resuming, or skipping.
-   *
-   * @param playbackId - The unique identifier of the playback to control.
-   *                     This should be a string that uniquely identifies the playback in the Asterisk system.
-   * @param controlRequest - An object containing the control operation details.
-   *                         This object should conform to the PlaybackControlRequest interface,
-   *                         which includes an 'operation' property specifying the control action to perform.
-   * @returns A Promise that resolves when the control operation is successfully executed.
-   *          The promise resolves to void, indicating no specific return value.
-   *          If an error occurs during the operation, the promise will be rejected with an error object.
-   * @throws Will throw an error if the playback control operation fails, e.g., if the playback doesn't exist
-   *         or the requested operation is invalid.
-   */
-  async controlPlayback(playbackId, controlRequest) {
-    const { operation } = controlRequest;
-    return this.playbacks.control(playbackId, operation);
-  }
-  /**
-   * Stops a specific playback in the Asterisk server.
-   *
-   * @param playbackId - The unique identifier of the playback to stop.
-   * @returns A Promise that resolves when the playback is successfully stopped.
-   */
-  async stopPlayback(playbackId) {
-    return this.playbacks.stop(playbackId);
-  }
-  /**
-   * Retrieves a list of all available sounds in the Asterisk server.
-   *
-   * @param params - Optional parameters to filter the list of sounds.
-   * @returns A Promise that resolves to an array of Sound objects representing the available sounds.
-   */
-  async listSounds(params) {
-    return this.sounds.list(params);
-  }
-  /**
-   * Retrieves detailed information about a specific sound in the Asterisk server.
-   *
-   * @param soundId - The unique identifier of the sound to retrieve details for.
-   * @returns A Promise that resolves to a Sound object containing the details of the specified sound.
-   */
-  async getSoundDetails(soundId) {
-    return this.sounds.getDetails(soundId);
-  }
-  /**
-   * Retrieves general information about the Asterisk server.
-   *
-   * @returns A Promise that resolves to an AsteriskInfo object containing server information.
-   */
-  async getAsteriskInfo() {
-    return this.asterisk.getInfo();
-  }
-  /**
-   * Retrieves a list of all loaded modules in the Asterisk server.
-   *
-   * @returns A Promise that resolves to an array of Module objects representing the loaded modules.
-   */
-  async listModules() {
-    return this.asterisk.listModules();
-  }
-  /**
-   * Manages a specific module in the Asterisk server by loading, unloading, or reloading it.
-   *
-   * @param moduleName - The name of the module to manage.
-   * @param action - The action to perform on the module: "load", "unload", or "reload".
-   * @returns A Promise that resolves when the module management action is completed successfully.
-   */
-  async manageModule(moduleName, action) {
-    return this.asterisk.manageModule(moduleName, action);
-  }
-  /**
-   * Retrieves a list of all configured logging channels in the Asterisk server.
-   *
-   * @returns A Promise that resolves to an array of Logging objects representing the configured logging channels.
-   */
-  async listLoggingChannels() {
-    return this.asterisk.listLoggingChannels();
-  }
-  /**
-   * Adds or removes a log channel in the Asterisk server.
-   *
-   * @param logChannelName - The name of the log channel to manage.
-   * @param action - The action to perform: "add" to create a new log channel or "remove" to delete an existing one.
-   * @param configuration - Optional configuration object for adding a log channel. Ignored when removing a channel.
-   * @param configuration.type - The type of the log channel.
-   * @param configuration.configuration - Additional configuration details for the log channel.
-   * @returns A Promise that resolves when the log channel management action is completed successfully.
-   */
-  async manageLogChannel(logChannelName, action, configuration) {
-    return this.asterisk.manageLogChannel(
-      logChannelName,
-      action,
-      configuration
-    );
-  }
-  /**
-   * Retrieves the value of a global variable from the Asterisk server.
-   *
-   * @param variableName - The name of the global variable to retrieve.
-   * @returns A Promise that resolves to a Variable object containing the name and value of the global variable.
-   */
-  async getGlobalVariable(variableName) {
-    return this.asterisk.getGlobalVariable(variableName);
-  }
-  /**
-   * Sets a global variable in the Asterisk server.
-   *
-   * This function allows you to set or update the value of a global variable
-   * in the Asterisk server. Global variables are accessible throughout the
-   * entire Asterisk system and can be used for various purposes such as
-   * configuration settings or sharing data between different parts of the system.
-   *
-   * @param variableName - The name of the global variable to set or update.
-   *                       This should be a string identifying the variable uniquely.
-   * @param value - The value to assign to the global variable. This can be any
-   *                string value, including empty strings.
-   * @returns A Promise that resolves when the global variable has been successfully
-   *          set. The promise resolves to void, indicating no specific return value.
-   *          If an error occurs during the operation, the promise will be rejected
-   *          with an error object.
-   */
-  async setGlobalVariable(variableName, value) {
-    return this.asterisk.setGlobalVariable(variableName, value);
-  }
   /**
    * Inicializa uma nova instância de `ChannelInstance` para manipular canais localmente.
    *
@@ -1981,7 +2112,7 @@ var AriClient = class {
    * @returns Uma instância de `ChannelInstance` vinculada ao cliente atual.
    */
   Channel(channelId) {
-    return this.channels.createChannelInstance(channelId);
+    return this.channels.Channel(channelId);
   }
   /**
    * Inicializa uma nova instância de `PlaybackInstance` para manipular playbacks.