@ipcom/asterisk-ari 0.0.136 → 0.0.138

package/dist/esm/index.js

@@ -478,25 +478,25 @@ var require_backoff = __commonJS({
     Object.defineProperty(exports, "__esModule", { value: true });
     var options_1 = require_options();
     var delay_factory_1 = require_delay_factory();
-    function backOff3(request, options) {
+    function backOff2(request, options) {
       if (options === void 0) {
         options = {};
       }
       return __awaiter(this, void 0, void 0, function() {
-        var sanitizedOptions, backOff4;
+        var sanitizedOptions, backOff3;
         return __generator(this, function(_a) {
           switch (_a.label) {
             case 0:
               sanitizedOptions = options_1.getSanitizedOptions(options);
-              backOff4 = new BackOff(request, sanitizedOptions);
-              return [4, backOff4.execute()];
+              backOff3 = new BackOff(request, sanitizedOptions);
+              return [4, backOff3.execute()];
             case 1:
               return [2, _a.sent()];
           }
         });
       });
     }
-    exports.backOff = backOff3;
+    exports.backOff = backOff2;
     var BackOff = (
       /** @class */
       function() {
@@ -570,54 +570,158 @@ var require_backoff = __commonJS({
   }
 });
 
-// src/ari-client/ariClient.ts
-var import_exponential_backoff2 = __toESM(require_backoff(), 1);
-
 // src/ari-client/baseClient.ts
 import axios from "axios";
 var BaseClient = class {
-  client;
-  constructor(baseUrl, username, password) {
+  constructor(baseUrl, username, password, timeout = 5e3) {
+    this.baseUrl = baseUrl;
+    this.username = username;
+    this.password = password;
+    if (!/^https?:\/\/.+/.test(baseUrl)) {
+      throw new Error(
+        "Invalid base URL. It must start with http:// or https://"
+      );
+    }
     this.client = axios.create({
       baseURL: baseUrl,
-      auth: { username, password }
+      auth: { username, password },
+      timeout
     });
+    this.addInterceptors();
+  }
+  client;
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  /**
+   * Retorna as credenciais configuradas.
+   */
+  getCredentials() {
+    return {
+      baseUrl: this.baseUrl,
+      username: this.username,
+      password: this.password
+    };
+  }
+  /**
+   * Adds interceptors to the Axios instance.
+   */
+  addInterceptors() {
+    this.client.interceptors.request.use(
+      (config) => {
+        return config;
+      },
+      (error) => {
+        console.error("[Request Error]", error.message);
+        return Promise.reject(error);
+      }
+    );
+    this.client.interceptors.response.use(
+      (response) => response,
+      (error) => {
+        const status = error.response?.status;
+        const message = error.response?.data?.message || error.message || "Unknown error";
+        const errorDetails = {
+          status,
+          message,
+          url: error.config?.url || "Unknown URL",
+          method: error.config?.method?.toUpperCase() || "Unknown Method"
+        };
+        if (status === 404) {
+          console.warn(`[404] Not Found: ${errorDetails.url}`);
+        } else if (status >= 500) {
+          console.error(`[500] Server Error: ${errorDetails.url}`);
+        } else {
+          console.warn(
+            `[Response Error] ${errorDetails.method} ${errorDetails.url}: ${message}`
+          );
+        }
+        return Promise.reject(
+          new Error(
+            `[Error] ${errorDetails.method} ${errorDetails.url} - ${message} (Status: ${status})`
+          )
+        );
+      }
+    );
   }
   /**
    * Executes a GET request.
    * @param path - The API endpoint path.
+   * @param config - Optional Axios request configuration.
    */
-  async get(path) {
-    const response = await this.client.get(path);
-    return response.data;
+  async get(path, config) {
+    try {
+      const response = await this.client.get(path, config);
+      return response.data;
+    } catch (error) {
+      this.handleRequestError(error);
+    }
   }
   /**
    * Executes a POST request.
    * @param path - The API endpoint path.
    * @param data - Optional payload to send with the request.
+   * @param config - Optional Axios request configuration.
    */
-  async post(path, data) {
-    const response = await this.client.post(path, data);
-    return response.data;
+  async post(path, data, config) {
+    try {
+      const response = await this.client.post(path, data, config);
+      return response.data;
+    } catch (error) {
+      this.handleRequestError(error);
+    }
   }
   /**
    * Executes a PUT request.
    * @param path - The API endpoint path.
    * @param data - Payload to send with the request.
+   * @param config - Optional Axios request configuration.
    */
-  async put(path, data) {
-    const response = await this.client.put(path, data);
-    return response.data;
+  async put(path, data, config) {
+    try {
+      const response = await this.client.put(path, data, config);
+      return response.data;
+    } catch (error) {
+      this.handleRequestError(error);
+    }
   }
   /**
    * Executes a DELETE request.
    * @param path - The API endpoint path.
+   * @param config - Optional Axios request configuration.
+   */
+  async delete(path, config) {
+    try {
+      const response = await this.client.delete(path, config);
+      return response.data;
+    } catch (error) {
+      this.handleRequestError(error);
+    }
+  }
+  /**
+   * Handles errors for HTTP requests.
+   * @param error - The error to handle.
    */
-  async delete(path) {
-    const response = await this.client.delete(path);
-    return response.data;
+  handleRequestError(error) {
+    if (axios.isAxiosError(error)) {
+      console.error(`[HTTP Error] ${error.message}`);
+      throw new Error(error.message || "HTTP Error");
+    } else {
+      console.error(`[Unexpected Error] ${error}`);
+      throw error;
+    }
+  }
+  /**
+   * Sets custom headers for the client instance.
+   * Useful for adding dynamic tokens or specific API headers.
+   * @param headers - Headers to merge with existing configuration.
+   */
+  setHeaders(headers) {
+    this.client.defaults.headers.common = {
+      ...this.client.defaults.headers.common,
+      ...headers
+    };
   }
-  // Gerenciamento de WebSocket clients
 };
 
 // src/ari-client/resources/applications.ts
@@ -680,13 +784,13 @@ var Asterisk = class {
   /**
    * Retrieves information about the Asterisk server.
    */
-  async getInfo() {
+  async get() {
     return this.client.get("/asterisk/info");
   }
   /**
    * Lists all loaded modules in the Asterisk server.
    */
-  async listModules() {
+  async list() {
     return this.client.get("/asterisk/modules");
   }
   /**
@@ -697,7 +801,7 @@ var Asterisk = class {
    * @returns A promise that resolves when the action is completed successfully.
    * @throws {Error} Throws an error if the HTTP method or action is invalid.
    */
-  async manageModule(moduleName, action) {
+  async manage(moduleName, action) {
     const url = `/asterisk/modules/${moduleName}`;
     switch (action) {
       case "load":
@@ -889,118 +993,75 @@ function toQueryParams2(options) {
     Object.entries(options).filter(([, value]) => value !== void 0).map(([key, value]) => [key, value])
   ).toString();
 }
-function isPlaybackEvent(event, playbackId) {
-  const hasPlayback = "playback" in event && event.playback?.id !== void 0;
-  return hasPlayback && (!playbackId || event.playback?.id === playbackId);
-}
-function isChannelEvent(event, channelId) {
-  const hasChannel = "channel" in event && event.channel?.id !== void 0;
-  return hasChannel && (!channelId || event.channel?.id === channelId);
-}
 
 // src/ari-client/resources/channels.ts
-var ChannelInstance = class extends EventEmitter {
+var ChannelInstance = class {
   // ID do canal
-  constructor(client, baseClient, channelId = `channel-${Date.now()}`, app) {
-    super();
+  constructor(client, baseClient, channelId = `channel-${Date.now()}`) {
     this.client = client;
     this.baseClient = baseClient;
     this.channelId = channelId;
-    this.app = app;
     this.id = channelId || `channel-${Date.now()}`;
-    const wsClients = this.client.getWebSocketClients();
-    const wsClient = wsClients.get(this.app);
-    if (!wsClient) {
-      throw new Error(
-        `Nenhum WebSocket conectado dispon\xEDvel para o canal: ${this.id}`
-      );
-    }
-    wsClient.addScopedMessageListener(
-      this.id,
-      this.app,
-      (event) => {
-        if (isChannelEvent(event, this.id)) {
-          const channelEventType = event.type;
-          this.emit(channelEventType, event);
-        }
-      }
-    );
-    this.once("ChannelDestroyed", () => {
-      console.log(
-        `Canal '${this.id}' destru\xEDdo. Removendo listeners associados.`
-      );
-      const wsClient2 = this.client.getWebSocketClients().get(this.app);
-      if (wsClient2) {
-        wsClient2.removeScopedChannelListeners(this.id, this.app);
-      } else {
-        console.warn(
-          `WebSocketClient n\xE3o encontrado para o app '${this.app}'.`
-        );
-      }
-    });
   }
+  eventEmitter = new EventEmitter();
   channelData = null;
   id;
   /**
-   * Adiciona um listener para eventos de canal.
+   * Registra um listener para eventos específicos deste canal.
    */
-  on(event, callback) {
-    const wsClient = this.client.getWebSocketClients().get(this.app);
-    if (!wsClient) {
-      throw new Error(
-        `Nenhum WebSocket conectado dispon\xEDvel para '${this.app}'.`
-      );
-    }
-    const scopedEvent = `${this.app}:Channel:${this.id}:${event}`;
-    console.log({ metheod: "on", event, scopedEvent });
-    const existingListeners = wsClient.listeners(scopedEvent);
-    if (existingListeners.includes(callback)) {
-      console.warn(`Listener j\xE1 registrado para o evento '${scopedEvent}'.`);
-      return this;
-    }
-    wsClient.on(scopedEvent, callback);
-    return this;
+  on(event, listener) {
+    const wrappedListener = (data) => {
+      if ("channel" in data && data.channel?.id === this.id) {
+        listener(data);
+      }
+    };
+    this.eventEmitter.on(event, wrappedListener);
   }
   /**
-   * Adiciona um listener para ser chamado apenas uma vez.
+   * Registra um listener único para eventos específicos deste canal.
    */
-  once(event, callback) {
-    const wsClient = this.client.getWebSocketClients().get(this.app);
-    if (!wsClient) {
-      throw new Error(
-        `Nenhum WebSocket conectado dispon\xEDvel para '${this.app}'.`
-      );
-    }
-    wsClient.removeWildcardListeners(this.id, event, "Channel");
-    const scopedEvent = `${this.app}:Channel:${this.id}:${event}`;
-    console.log({ metheod: "once", event, scopedEvent });
-    const existingListeners = wsClient.listeners(scopedEvent);
-    if (existingListeners.some((listener2) => listener2 === callback)) {
-      console.warn(`Listener j\xE1 registrado para o evento '${scopedEvent}'.`);
-      return this;
-    }
-    const listener = (data) => {
-      callback(data);
-      wsClient.off(scopedEvent, listener);
-      wsClient.removeWildcardListeners(this.id, event, "Channel");
+  once(event, listener) {
+    const wrappedListener = (data) => {
+      if ("channel" in data && data.channel?.id === this.id) {
+        listener(data);
+      }
     };
-    wsClient.on(scopedEvent, listener);
-    return this;
+    this.eventEmitter.once(event, wrappedListener);
   }
   /**
-   * Remove um listener específico.
+   * Remove um listener para eventos específicos deste canal.
    */
-  off(event, callback) {
-    const wsClient = this.client.getWebSocketClients().get(this.app);
-    if (!wsClient) {
-      throw new Error(
-        `Nenhum WebSocket conectado dispon\xEDvel para '${this.app}'.`
-      );
+  off(event, listener) {
+    if (listener) {
+      this.eventEmitter.off(event, listener);
+    } else {
+      const listeners = this.eventEmitter.listeners(event);
+      listeners.forEach((fn) => {
+        this.eventEmitter.off(event, fn);
+      });
     }
-    const scopedEvent = `${this.app}:Channel:${this.id}:${event}`;
-    wsClient.off(scopedEvent, callback);
-    wsClient.removeScopedChannelListeners(this.id, this.app);
-    return this;
+  }
+  /**
+   * Obtém a quantidade de listeners registrados para o evento especificado.
+   */
+  getListenerCount(event) {
+    return this.eventEmitter.listenerCount(event);
+  }
+  /**
+   * Emite eventos internamente para o canal.
+   * Verifica o ID do canal antes de emitir.
+   */
+  emitEvent(event) {
+    if ("channel" in event && event.channel?.id === this.id) {
+      this.eventEmitter.emit(event.type, event);
+    }
+  }
+  /**
+   * Remove todos os listeners para este canal.
+   */
+  removeAllListeners() {
+    console.log(`Removendo todos os listeners para o canal ${this.id}`);
+    this.eventEmitter.removeAllListeners();
   }
   async answer() {
     await this.baseClient.post(`/channels/${this.id}/answer`);
@@ -1059,7 +1120,7 @@ var ChannelInstance = class extends EventEmitter {
       console.log("Canal n\xE3o inicializado, buscando detalhes...");
       this.channelData = await this.getDetails();
     }
-    const playback = this.client.Playback(playbackId || v4_default(), this.app);
+    const playback = this.client.Playback(playbackId || v4_default());
     if (!this.channelData?.id) {
       throw new Error("N\xE3o foi poss\xEDvel inicializar o canal. ID inv\xE1lido.");
     }
@@ -1067,25 +1128,6 @@ var ChannelInstance = class extends EventEmitter {
       `/channels/${this.channelData.id}/play/${playback.id}`,
       options
     );
-    const wsClient = this.client.getWebSocketClients().get(this.app);
-    if (!wsClient) {
-      throw new Error("WebSocketClient n\xE3o encontrado para o app.");
-    }
-    playback.once("PlaybackFinished", () => {
-      console.log(`PlaybackFinished '${playback.id}' no canal '${this.id}'.`);
-      wsClient.removeScopedPlaybackListeners(playback.id, this.app);
-    });
-    playback.once("PlaybackFinished", async () => {
-      console.log(`Playback conclu\xEDdo: ${playback.id}`);
-      this.client.getWebSocketClients().get(this.app)?.removeScopedPlaybackListeners(playback.id, this.app);
-    });
-    this.once("ChannelDestroyed", () => {
-      console.log(
-        `Canal '${this.id}' foi destru\xEDdo. Removendo listeners associados.`
-      );
-      wsClient.removeScopedChannelListeners(this.id, this.app);
-      wsClient.removeScopedPlaybackListeners(playback.id, this.app);
-    });
     return playback;
   }
   /**
@@ -1199,19 +1241,54 @@ var ChannelInstance = class extends EventEmitter {
     await this.baseClient.delete(`/channels/${this.channelData.id}/hold`);
   }
 };
-var Channels = class extends EventEmitter {
+var Channels = class {
   constructor(baseClient, client) {
-    super();
     this.baseClient = baseClient;
     this.client = client;
   }
-  Channel({ id, app }) {
-    if (!app) {
-      throw new Error(
-        "O nome do aplicativo (app) \xE9 obrigat\xF3rio para criar um Channel."
+  channelInstances = /* @__PURE__ */ new Map();
+  Channel({ id }) {
+    if (!id) {
+      const instance = new ChannelInstance(this.client, this.baseClient);
+      this.channelInstances.set(instance.id, instance);
+      return instance;
+    }
+    if (!this.channelInstances.has(id)) {
+      const instance = new ChannelInstance(this.client, this.baseClient, id);
+      this.channelInstances.set(id, instance);
+      return instance;
+    }
+    return this.channelInstances.get(id);
+  }
+  /**
+   * Remove uma instância de canal.
+   */
+  removeChannelInstance(channelId) {
+    if (this.channelInstances.has(channelId)) {
+      const instance = this.channelInstances.get(channelId);
+      instance?.removeAllListeners();
+      this.channelInstances.delete(channelId);
+      console.log(`Inst\xE2ncia do canal ${channelId} removida.`);
+    } else {
+      console.warn(
+        `Tentativa de remover uma inst\xE2ncia inexistente: ${channelId}`
       );
     }
-    return new ChannelInstance(this.client, this.baseClient, id, app);
+  }
+  /**
+   * Propaga eventos do WebSocket para o canal correspondente.
+   */
+  propagateEventToChannel(event) {
+    if ("channel" in event && event.channel?.id) {
+      const instance = this.channelInstances.get(event.channel.id);
+      if (instance) {
+        instance.emitEvent(event);
+      } else {
+        console.warn(
+          `Nenhuma inst\xE2ncia encontrada para o canal ${event.channel.id}`
+        );
+      }
+    }
   }
   /**
    * Origina um canal físico diretamente, sem uma instância de `ChannelInstance`.
@@ -1439,143 +1516,67 @@ var Endpoints = class {
 
 // src/ari-client/resources/playbacks.ts
 import { EventEmitter as EventEmitter2 } from "events";
-var PlaybackInstance = class extends EventEmitter2 {
-  // Garantimos que o ID esteja disponível
-  constructor(client, baseClient, playbackId = `playback-${Date.now()}`, app) {
-    super();
+var PlaybackInstance = class {
+  constructor(client, baseClient, playbackId = `playback-${Date.now()}`) {
     this.client = client;
     this.baseClient = baseClient;
     this.playbackId = playbackId;
-    this.app = app;
-    this.id = playbackId || `playback-${Date.now()}`;
-    const wsClients = this.client.getWebSocketClients();
-    const wsClient = Array.from(wsClients.values()).find(
-      (client2) => client2.isConnected()
-    );
-    if (!wsClient) {
-      throw new Error(
-        `Nenhum WebSocket conectado dispon\xEDvel para o playback: ${this.id}`
-      );
-    }
-    try {
-      wsClient.addScopedMessageListener(
-        this.id,
-        this.app,
-        (event) => {
-          if (isPlaybackEvent(event, this.id)) {
-            const playbackEventType = event.type;
-            this.emit(playbackEventType, event);
-          }
-        }
-      );
-    } catch (error) {
-      console.error(
-        `Erro ao adicionar listener escopado para playback '${this.id}':`,
-        error
-      );
-      throw error;
-    }
-    this.on("removeListener", (eventName) => {
-      if (this.eventNames().length === 0 || this.listenerCount(eventName) === 0) {
-        wsClient.removeScopedMessageListeners(this.id, this.app);
-        console.log(
-          `Listeners escopados removidos para playback '${this.id}'.`
-        );
-      }
-    });
+    this.id = playbackId;
   }
+  eventEmitter = new EventEmitter2();
   playbackData = null;
   id;
   /**
-   * Adiciona um listener para eventos de playback.
-   */
-  /**
-   * Adiciona um listener para eventos de playback.
+   * Registra um listener para eventos específicos deste playback.
    */
+  on(event, listener) {
+    const wrappedListener = (data) => {
+      if ("playback" in data && data.playback?.id === this.id) {
+        listener(data);
+      }
+    };
+    this.eventEmitter.on(event, wrappedListener);
+  }
   /**
-   * Adiciona um listener para eventos de playback.
+   * Registra um listener único para eventos específicos deste playback.
    */
-  on(event, callback) {
-    const wsClient = this.client.getWebSocketClients().get(this.app);
-    if (!wsClient) {
-      throw new Error(
-        `Nenhum WebSocket conectado dispon\xEDvel para '${this.app}'.`
-      );
-    }
-    const scopedEvent = `${this.app}:Playback:${this.id}:${event}`;
-    const existingListeners = wsClient.listeners(scopedEvent);
-    if (existingListeners.some((listener) => listener === callback)) {
-      console.warn(`Listener j\xE1 registrado para o evento '${scopedEvent}'.`);
-      return this;
-    }
-    wsClient.on(scopedEvent, callback);
-    console.log(`Listener registrado para '${scopedEvent}'.`);
-    return this;
+  once(event, listener) {
+    const wrappedListener = (data) => {
+      if ("playback" in data && data.playback?.id === this.id) {
+        listener(data);
+      }
+    };
+    this.eventEmitter.once(event, wrappedListener);
   }
   /**
-   * Adiciona um listener para ser chamado apenas uma vez.
+   * Remove um listener para eventos específicos deste playback.
    */
-  once(event, callback) {
-    const wsClient = this.client.getWebSocketClients().get(this.app);
-    if (!wsClient) {
-      throw new Error(
-        `Nenhum WebSocket conectado dispon\xEDvel para '${this.app}'.`
-      );
-    }
-    const scopedEvent = `${this.app}:Playback:${this.id}:${event}`;
-    const existingListeners = wsClient.listeners(scopedEvent);
-    if (existingListeners.some((listener2) => listener2 === callback)) {
-      console.warn(`Listener j\xE1 registrado para o evento '${scopedEvent}'.`);
-      return this;
+  off(event, listener) {
+    if (listener) {
+      this.eventEmitter.off(event, listener);
+    } else {
+      this.eventEmitter.removeAllListeners(event);
     }
-    const listener = (data) => {
-      callback(data);
-      wsClient.off(scopedEvent, listener);
-      console.log(`Listener removido ap\xF3s execu\xE7\xE3o para '${scopedEvent}'.`);
-    };
-    wsClient.on(scopedEvent, listener);
-    console.log(`Listener registrado para '${scopedEvent}' (apenas uma vez).`);
-    return this;
   }
   /**
-   * Remove um listener específico.
+   * Emite eventos internamente para o playback.
    */
-  off(event, callback) {
-    const wsClient = this.client.getWebSocketClients().get(this.app);
-    if (!wsClient) {
-      throw new Error(
-        `Nenhum WebSocket conectado dispon\xEDvel para '${this.app}'.`
-      );
+  emitEvent(event) {
+    if ("playback" in event && event.playback?.id === this.id) {
+      this.eventEmitter.emit(event.type, event);
     }
-    const scopedEvent = `${this.app}:Playback:${this.id}:${event}`;
-    const existingListeners = wsClient.listeners(scopedEvent);
-    if (!existingListeners.some((listener) => listener === callback)) {
-      console.warn(
-        `Nenhum listener registrado para '${scopedEvent}' que corresponda.`
-      );
-      return this;
-    }
-    wsClient.off(scopedEvent, callback);
-    console.log(`Listener removido para '${scopedEvent}'.`);
-    return this;
   }
   /**
    * Obtém os detalhes do playback.
    */
-  async getDetails() {
-    if (!this.id && !this.playbackData) {
+  async get() {
+    if (!this.id) {
       throw new Error("Nenhum playback associado a esta inst\xE2ncia.");
     }
-    console.log({
-      message: "NPM",
-      id: `/playbacks/${this.id}`,
-      data: this.playbackData
-    });
-    const details = await this.baseClient.get(
+    this.playbackData = await this.baseClient.get(
       `/playbacks/${this.id}`
     );
-    this.playbackData = details;
-    return details;
+    return this.playbackData;
   }
   /**
    * Controla o playback.
@@ -1588,133 +1589,84 @@ var PlaybackInstance = class extends EventEmitter2 {
       `/playbacks/${this.id}/control?operation=${operation}`
     );
   }
+  /**
+   * Encerra o playback.
+   */
   async stop() {
     if (!this.id) {
       throw new Error("Nenhum playback associado para encerrar.");
     }
-    try {
-      await this.baseClient.delete(`/playbacks/${this.id}`);
-      console.log(`Playback '${this.id}' parado com sucesso.`);
-    } catch (error) {
-      if (error.response?.status === 404) {
-        console.warn(
-          `Playback '${this.id}' n\xE3o encontrado para encerrar (404).`
-        );
-        return;
-      }
-      console.error(
-        `Erro ao encerrar o playback '${this.id}':`,
-        error.message || error
-      );
-      throw error;
-    }
+    await this.baseClient.delete(`/playbacks/${this.id}`);
+  }
+  /**
+   * Remove todos os listeners para este playback.
+   */
+  removeAllListeners() {
+    this.eventEmitter.removeAllListeners();
   }
 };
-var Playbacks = class extends EventEmitter2 {
+var Playbacks = class {
   constructor(baseClient, client) {
-    super();
     this.baseClient = baseClient;
     this.client = client;
   }
+  playbackInstances = /* @__PURE__ */ new Map();
   /**
-   * Inicializa uma nova instância de `PlaybackInstance`.
+   * Gerencia instâncias de playback.
    */
-  Playback({ id, app }) {
-    if (!app) {
-      throw new Error(
-        "O nome do aplicativo (app) \xE9 obrigat\xF3rio para criar um Channel."
-      );
+  Playback({ id }) {
+    if (!id) {
+      const instance = new PlaybackInstance(this.client, this.baseClient);
+      this.playbackInstances.set(instance.id, instance);
+      return instance;
     }
-    const playbackId = id || `playback-${Date.now()}`;
-    return new PlaybackInstance(this.client, this.baseClient, playbackId, app);
-  }
-  /**
-   * Obtém os clientes WebSocket disponíveis.
-   */
-  getWebSocketClients() {
-    return this.client.getWebSocketClients();
-  }
-  /**
-   * Retrieves details of a specific playback.
-   *
-   * @param playbackId - The unique identifier of the playback.
-   * @returns A promise that resolves to a Playback object containing the details of the specified playback.
-   */
-  async getDetails(playbackId) {
-    return this.baseClient.get(`/playbacks/${playbackId}`);
+    if (!this.playbackInstances.has(id)) {
+      const instance = new PlaybackInstance(this.client, this.baseClient, id);
+      this.playbackInstances.set(id, instance);
+      return instance;
+    }
+    return this.playbackInstances.get(id);
   }
   /**
-   * Controls a specific playback by performing various operations such as pause, resume, restart, reverse, forward, or stop.
-   *
-   * @param playbackId - The unique identifier of the playback to control.
-   * @param operation - The operation to perform on the playback. Possible values are:
-   *                    - "pause": Pauses the playback.
-   *                    - "unpause": Resumes a paused playback.
-   *                    - "restart": Restarts the playback from the beginning.
-   *                    - "reverse": Reverses the playback direction.
-   *                    - "forward": Moves the playback forward.
-   *                    - "stop": Stops the playback.
-   * @returns A promise that resolves when the control operation is successfully executed.
+   * Remove uma instância de playback.
    */
-  async control(playbackId, operation) {
-    await this.baseClient.post(
-      `/playbacks/${playbackId}/control?operation=${operation}`
-    );
+  removePlaybackInstance(playbackId) {
+    if (this.playbackInstances.has(playbackId)) {
+      const instance = this.playbackInstances.get(playbackId);
+      instance?.removeAllListeners();
+      this.playbackInstances.delete(playbackId);
+    }
   }
   /**
-   * Stops a specific playback.
-   *
-   * @param playbackId - The unique identifier of the playback to stop.
-   * @returns A promise that resolves when the playback is successfully stopped.
+   * Propaga eventos do WebSocket para o playback correspondente.
    */
-  async stop(playbackId) {
-    try {
-      await this.baseClient.delete(`/playbacks/${playbackId}`);
-      console.log(`Playback '${playbackId}' parado com sucesso.`);
-    } catch (error) {
-      if (error.response?.status === 404) {
-        console.warn(
-          `Playback '${playbackId}' n\xE3o encontrado para encerrar (404).`
-        );
-        return;
+  propagateEventToPlayback(event) {
+    if ("playback" in event && event.playback?.id) {
+      const instance = this.playbackInstances.get(event.playback.id);
+      if (instance) {
+        instance.emitEvent(event);
       }
-      console.error(
-        `Erro ao encerrar o playback '${playbackId}':`,
-        error.message || error
-      );
-      throw error;
     }
   }
   /**
-   * Registers a listener for playback events.
-   * The listener is triggered for events such as "PlaybackFinished".
-   *
-   * @param eventType - The type of event to listen for.
-   * @param playbackId - The ID of the playback to associate with this listener.
-   * @param callback - The callback function to execute when the event occurs.
+   * Obtém detalhes de um playback específico.
    */
-  registerListener(eventType, playbackId, callback) {
-    this.on(`${eventType}:${playbackId}`, callback);
+  async getDetails(playbackId) {
+    return this.baseClient.get(`/playbacks/${playbackId}`);
   }
   /**
-   * Unregisters a listener for playback events.
-   *
-   * @param eventType - The type of event to stop listening for.
-   * @param playbackId - The ID of the playback associated with the listener.
-   * @param callback - The callback function to remove.
+   * Controla um playback específico.
    */
-  unregisterListener(eventType, playbackId, callback) {
-    this.off(`${eventType}:${playbackId}`, callback);
+  async control(playbackId, operation) {
+    const playback = this.Playback({ id: playbackId });
+    await playback.control(operation);
   }
   /**
-   * Checks if a listener is already registered for a specific event and playback.
-   *
-   * @param eventType - The type of event to check.
-   * @param playbackId - The playback ID associated with the listener.
-   * @returns True if a listener is already registered, false otherwise.
+   * Encerra um playback específico.
    */
-  isListenerRegistered(eventType, playbackId) {
-    return this.listenerCount(`${eventType}:${playbackId}`) > 0;
+  async stop(playbackId) {
+    const playback = this.Playback({ id: playbackId });
+    await playback.stop();
   }
 };
 
@@ -1754,356 +1706,136 @@ var import_exponential_backoff = __toESM(require_backoff(), 1);
 import { EventEmitter as EventEmitter3 } from "events";
 import WebSocket from "ws";
 var WebSocketClient = class extends EventEmitter3 {
-  /**
-   * Creates a new WebSocketClient instance.
-   * @param url - The WebSocket server URL to connect to.
-   */
-  constructor(url) {
+  constructor(baseClient, apps, subscribedEvents, ariClient) {
     super();
-    this.url = url;
+    this.baseClient = baseClient;
+    this.apps = apps;
+    this.subscribedEvents = subscribedEvents;
+    this.ariClient = ariClient;
   }
-  ws = null;
-  isClosedManually = false;
+  ws;
   isReconnecting = false;
-  messageListeners = [];
-  maxReconnectAttempts = 30;
-  reconnectAttempts = 0;
-  // Para gerenciar tentativas de reconexão
-  scopedListeners = /* @__PURE__ */ new Map();
-  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
+  maxReconnectAttempts = 10;
+  backOffOptions = {
+    numOfAttempts: 10,
+    // Máximo de tentativas de reconexão
+    startingDelay: 500,
+    // Início com 500ms de atraso
+    maxDelay: 1e4,
+    // Limite máximo de atraso de 10s
+    timeMultiple: 2,
+    // Atraso aumenta exponencialmente
+    jitter: "full",
+    // Randomização para evitar colisões
+    delayFirstAttempt: false,
+    // Não atrase a primeira tentativa
+    retry: (error, attemptNumber) => {
+      console.warn(
+        `Tentativa #${attemptNumber} falhou:`,
+        error.message || error
       );
-      this.isReconnecting = false;
+      return true;
     }
-  }
+  };
   /**
-   * Establishes a connection to the WebSocket server.
-   * @returns A Promise that resolves when the connection is established, or rejects if an error occurs.
-   * @throws Will throw an error if the connection fails.
+   * Conecta ao WebSocket.
    */
   async connect() {
-    if (this.isReconnecting) return;
-    return new Promise((resolve, reject) => {
-      this.removeAllListeners();
-      this.ws = new WebSocket(this.url);
-      this.ws.on("open", () => {
-        console.log("WebSocket conectado.");
-        this.isClosedManually = false;
-        this.isReconnecting = false;
-        this.reconnectAttempts = 0;
-        console.log(
-          `Listeners ativos para 'message': ${this.listenerCount("message")}`
-        );
-        resolve();
-      });
-      this.ws.on("error", (err) => {
-        console.error("Erro na conex\xE3o WebSocket:", err);
-        reject(err);
-      });
-      this.ws.on("close", (code, reason) => {
-        console.warn(`WebSocket desconectado: ${code} - ${reason}`);
-        this.emit("close", { code, reason });
-        if (!this.isClosedManually) {
-          this.reconnect();
-        }
-      });
-      this.ws.on("message", (rawData) => {
-        this.handleMessage(rawData);
-      });
-    });
-  }
-  /**
-   * Checks if the WebSocket connection is currently open.
-   * @returns True if the connection is open, false otherwise.
-   */
-  isConnected() {
-    return this.ws?.readyState === WebSocket.OPEN;
-  }
-  onMessage(callback) {
-    if (!this.messageListeners.includes(callback)) {
-      this.messageListeners.push(callback);
-      this.on("message", callback);
-      console.log("Listener registrado para 'message'.");
+    const { baseUrl, username, password } = this.baseClient.getCredentials();
+    const protocol = baseUrl.startsWith("https") ? "wss" : "ws";
+    const normalizedHost = baseUrl.replace(/^https?:\/\//, "").replace(/\/ari$/, "");
+    const queryParams = new URLSearchParams();
+    queryParams.append("app", this.apps.join(","));
+    if (this.subscribedEvents && this.subscribedEvents.length > 0) {
+      this.subscribedEvents.forEach(
+        (event) => queryParams.append("event", event)
+      );
     } else {
-      console.warn("Tentativa de registrar listener duplicado para 'message'.");
+      queryParams.append("subscribeAll", "true");
     }
+    const wsUrl = `${protocol}://${encodeURIComponent(username)}:${encodeURIComponent(password)}@${normalizedHost}/ari/events?${queryParams.toString()}`;
+    console.log("Conectando ao WebSocket em:", wsUrl);
+    return this.initializeWebSocket(wsUrl);
   }
   /**
-   * Adds a listener for WebSocket events.
-   * @param event - The event type to listen for.
-   * @param callback - The function to call when the event occurs.
-   * @returns The WebSocketClient instance for chaining.
+   * Inicializa a conexão WebSocket com lógica de reconexão.
    */
-  on(event, callback) {
-    if (event === "message") {
-      const existingListeners = this.listeners(event);
-      if (existingListeners.includes(callback)) {
-        console.warn(
-          `Listener j\xE1 registrado para o evento '${event}'. Ignorando duplicata.`
-        );
-        return this;
-      }
-      console.log(
-        `Registrando listener para o evento 'message'. Antes: ${this.listenerCount(
-          "message"
-        )} listener(s).`
-      );
-    }
-    super.on(event, callback);
-    if (event === "message") {
-      console.log(
-        `Listener registrado para 'message'. Depois: ${this.listenerCount(
-          "message"
-        )} listener(s).`
-      );
-      this.listListeners("message");
-    }
-    return this;
-  }
-  listListeners(event) {
-    const listeners = this.listeners(event);
-    console.log(`=== Listagem de Listeners para '${event}' ===`);
-    listeners.forEach((listener, index) => {
-      const scopedKey = Array.from(this.scopedListeners.entries()).find(
-        ([, value]) => value === listener
-      )?.[0];
-      console.log(`Listener #${index + 1}:`, listener.toString());
-      if (scopedKey) {
-        console.log(`  Associado ao escopo: ${scopedKey}`);
-      }
-    });
-    console.log(`Total de listeners para '${event}': ${listeners.length}`);
+  async initializeWebSocket(wsUrl) {
+    return (0, import_exponential_backoff.backOff)(async () => {
+      return new Promise((resolve, reject) => {
+        this.ws = new WebSocket(wsUrl);
+        this.ws.on("open", () => {
+          console.log("WebSocket conectado com sucesso.");
+          this.isReconnecting = false;
+          this.emit("connected");
+          resolve();
+        });
+        this.ws.on("message", (data) => this.handleMessage(data.toString()));
+        this.ws.on("close", (code) => {
+          console.warn(
+            `WebSocket desconectado com c\xF3digo ${code}. Tentando reconectar...`
+          );
+          if (!this.isReconnecting) {
+            this.reconnect(wsUrl);
+          }
+        });
+        this.ws.on("error", (err) => {
+          console.error("Erro no WebSocket:", err.message);
+          if (!this.isReconnecting) {
+            this.reconnect(wsUrl);
+          }
+          reject(err);
+        });
+      });
+    }, this.backOffOptions);
   }
   /**
-   * Removes a specific listener from a WebSocket event.
-   * @param event - The event type to remove the listener from.
-   * @param callback - The function to remove from the event listeners.
-   * @returns The WebSocketClient instance for chaining.
+   * Processa as mensagens recebidas do WebSocket.
    */
-  /**
-   * Removes a specific listener from a WebSocket event.
-   * @param event - The event type to remove the listener from.
-   * @param callback - The function to remove from the event listeners.
-   * @returns The WebSocketClient instance for chaining.
-   */
-  off(event, callback) {
-    if (event === "message") {
-      console.log(
-        `Removendo listener para o evento 'message'. Total antes: ${this.listenerCount(
-          "message"
-        )}`
-      );
-    }
-    super.off(event, callback);
-    if (event === "message") {
-      console.log(
-        `Listener para o evento 'message' removido. Total agora: ${this.listenerCount(
-          "message"
-        )}`
-      );
-    }
-    return this;
-  }
-  removeWildcardListeners(id, event, type) {
-    console.log(
-      `Removendo listeners para '${type}:${id}:${event}' com wildcard no app`
-    );
-    for (const eventName of this.eventNames()) {
-      if (typeof eventName === "string") {
-        const eventString = String(eventName);
-        if (eventString.includes(`:${type}:${id}:${event}`)) {
-          console.log(`Removendo listener para o evento: ${eventString}`);
-          this.removeAllListeners(eventName);
-        }
+  handleMessage(rawMessage) {
+    try {
+      const event = JSON.parse(rawMessage);
+      if (this.subscribedEvents && !this.subscribedEvents.includes(event.type)) {
+        return;
       }
-    }
-  }
-  /**
-   * Removes all listeners for a specific event, or all events if no event is specified.
-   * @param event - Optional. The event to remove all listeners from.
-   * @returns The WebSocketClient instance for chaining.
-   */
-  removeAllListeners(event) {
-    super.removeAllListeners(event);
-    return this;
-  }
-  /**
-   * Adiciona um listener escopado ao evento "message".
-   * @param instanceId - Identificador único da instância que está registrando o listener.
-   * @param app
-   * @param callback - Função de callback para o evento.
-   */
-  addScopedMessageListener(instanceId, app, callback) {
-    const key = `${app}:${instanceId}`;
-    if (this.scopedListeners.has(key)) {
-      console.warn(
-        `Listener escopado j\xE1 existe para '${key}'. Removendo antigo antes de adicionar um novo.`
-      );
-      this.removeScopedMessageListeners(instanceId, app);
-    }
-    const scopedListener = (data) => {
-      if (data.application === app && (data.type.startsWith("Channel") && "channel" in data && data.channel?.id === instanceId || data.type.startsWith("Playback") && "playbackId" in data && data.playbackId === instanceId)) {
-        callback(data);
+      if ("channel" in event && event.channel?.id && this.ariClient) {
+        const instanceChannel = this.ariClient.Channel(event.channel.id);
+        instanceChannel.emitEvent(event);
+        event.instanceChannel = instanceChannel;
       }
-    };
-    this.scopedListeners.set(key, scopedListener);
-    this.on("message", scopedListener);
-    console.log(
-      `Listener escopado adicionado para '${key}'. Total de listeners: ${this.listenerCount(
-        "message"
-      )}`
-    );
-  }
-  /**
-   * Remove todos os listeners associados a uma instância específica.
-   * @param instanceId - Identificador da instância cujos listeners serão removidos.
-   * @param app
-   */
-  removeScopedMessageListeners(instanceId, app) {
-    const key = `${app}:${instanceId}`;
-    const scopedListener = this.scopedListeners.get(key);
-    if (scopedListener) {
-      console.log(`Removendo listener escopado para '${key}'.`);
-      this.off("message", scopedListener);
-      this.scopedListeners.delete(key);
-    } else {
-      console.warn(`Nenhum listener encontrado para '${key}'.`);
-    }
-  }
-  removeAllScopedListeners() {
-    this.scopedListeners.forEach((_listener, key) => {
-      console.log(`Removendo listener escopado para '${key}' durante cleanup.`);
-      this.removeScopedMessageListeners(key.split(":")[1], key.split(":")[0]);
-    });
-    console.log("Todos os listeners escopados foram removidos.");
-  }
-  removeScopedChannelListeners(instanceId, app) {
-    const key = `${app}:${instanceId}`;
-    const scopedListener = this.scopedListeners.get(key);
-    if (scopedListener) {
-      console.log(`Removendo listener escopado para o canal '${key}'.`);
-      this.off("message", scopedListener);
-      this.scopedListeners.delete(key);
-      console.log(`Listener de canal removido para '${key}'.`);
-    } else {
-      console.warn(`Nenhum listener encontrado para o canal '${key}'.`);
-    }
-  }
-  removeScopedPlaybackListeners(playbackId, app) {
-    const key = `${app}:${playbackId}`;
-    const scopedListener = this.scopedListeners.get(key);
-    if (scopedListener) {
-      console.log(`Removendo listener escopado para o playback '${key}'.`);
-      this.off("message", scopedListener);
-      this.scopedListeners.delete(key);
-      console.log(`Listener de playback removido para '${key}'.`);
-    } else {
-      console.warn(`Nenhum listener encontrado para o playback '${key}'.`);
-    }
-  }
-  /**
-   * Handles incoming WebSocket messages.
-   * @param rawData - The raw data received from the WebSocket.
-   */
-  handleMessage(rawData) {
-    try {
-      const decodedData = JSON.parse(rawData.toString());
-      if (decodedData?.type && decodedData?.application) {
-        const scopedEvent = `${decodedData.application}:${decodedData.type}`;
-        if ("channel" in decodedData && decodedData.channel?.id) {
-          const channelScopedEvent = `${decodedData.application}:Channel:${decodedData.channel.id}:${decodedData.type}`;
-          this.emit(channelScopedEvent, decodedData);
-          if (decodedData.type === "ChannelDestroyed") {
-            console.log(`Canal destru\xEDdo detectado: ${decodedData.channel.id}`);
-            this.removeScopedChannelListeners(
-              decodedData.channel.id,
-              decodedData.application
-            );
-          }
-        } else if ("playback" in decodedData && decodedData.playback?.id) {
-          const playbackScopedEvent = `${decodedData.application}:Playback:${decodedData.playback.id}:${decodedData.type}`;
-          this.emit(playbackScopedEvent, decodedData);
-          if (decodedData.type === "PlaybackFinished") {
-            console.log(`Playback conclu\xEDdo: ${decodedData.playback.id}`);
-            this.removeScopedPlaybackListeners(
-              decodedData.playback.id,
-              decodedData.application
-            );
-          }
-        }
-        this.emit(scopedEvent, decodedData);
-      } else {
-        console.warn(
-          "Mensagem recebida sem tipo ou aplica\xE7\xE3o v\xE1lida:",
-          decodedData
-        );
+      if ("playback" in event && event.playback?.id && this.ariClient) {
+        const instancePlayback = this.ariClient.Playback(event.playback.id);
+        instancePlayback.emitEvent(event);
+        event.instancePlayback = instancePlayback;
       }
+      this.emit(event.type, event);
     } catch (err) {
-      console.error("Erro ao decodificar mensagem do WebSocket:", err);
+      console.error("Erro ao processar mensagem WebSocket:", err);
+      this.emit("error", new Error("Falha ao decodificar mensagem WebSocket."));
     }
   }
   /**
-   * Sends data through the WebSocket connection.
-   * @param data - The data to send.
-   * @throws Will throw an error if the WebSocket is not connected.
+   * Tenta reconectar ao WebSocket.
    */
-  send(data) {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-      throw new Error("WebSocket n\xE3o est\xE1 conectado.");
-    }
-    this.ws.send(data, (err) => {
-      if (err) {
-        console.error("Erro ao enviar dados pelo WebSocket:", err);
+  reconnect(wsUrl) {
+    this.isReconnecting = true;
+    console.log("Iniciando tentativa de reconex\xE3o...");
+    this.removeAllListeners();
+    (0, import_exponential_backoff.backOff)(() => this.initializeWebSocket(wsUrl), this.backOffOptions).catch(
+      (err) => {
+        console.error(
+          "Falha ao reconectar ap\xF3s v\xE1rias tentativas:",
+          err.message || err
+        );
       }
-    });
+    );
   }
   /**
-   * Closes the WebSocket connection manually.
+   * Fecha o WebSocket manualmente.
    */
   close() {
-    if (this.ws) {
-      this.isClosedManually = true;
-      this.ws.close();
-      this.ws = null;
-      console.log(this.scopedListeners);
-      this.scopedListeners.forEach((_listener, key) => {
-        console.log(`Removendo listener escopado para '${key}' ao fechar.`);
-        this.removeScopedMessageListeners(key.split(":")[1], key.split(":")[0]);
-      });
-      this.scopedListeners.clear();
-      this.removeAllListeners("message");
-      console.log("WebSocket fechado manualmente e todos os listeners limpos.");
-    }
+    this.ws?.close();
+    this.ws = void 0;
   }
 };
 
@@ -2123,35 +1855,8 @@ var AriClient = class {
     this.asterisk = new Asterisk(this.baseClient);
     this.bridges = new Bridges(this.baseClient);
   }
-  eventListeners = /* @__PURE__ */ new Map();
-  wsClients = /* @__PURE__ */ new Map();
-  // Map para armazenar conexões por app
   baseClient;
-  isReconnecting = /* @__PURE__ */ new Map();
-  // Estado de reconexão por app
-  webSocketReady = /* @__PURE__ */ new Map();
-  // Rastreamento do estado de cada conexão
-  channelInstances = /* @__PURE__ */ new Map();
-  pendingListeners = [];
-  processPendingListeners() {
-    for (const [app, wsClient] of this.wsClients.entries()) {
-      if (!wsClient.isConnected()) {
-        console.warn(`WebSocket para o app '${app}' ainda n\xE3o est\xE1 conectado.`);
-        continue;
-      }
-      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);
-      }
-    }
-  }
+  webSocketClient;
   channels;
   endpoints;
   applications;
@@ -2159,370 +1864,58 @@ var AriClient = class {
   sounds;
   asterisk;
   bridges;
-  // Getter para wsClients
-  getWebSocketClients() {
-    return this.wsClients;
-  }
-  /**
-   * Registra listeners globais para eventos de WebSocket.
-   */
-  on(eventType, callback, app) {
-    if (!app) {
-      throw new Error(
-        "O nome do app \xE9 obrigat\xF3rio para registrar um listener de evento."
-      );
-    }
-    console.log(
-      `Registrando listener para evento '${eventType}' no app '${app}'.`
-    );
-    const callbackKey = `${app}:${eventType}`;
-    if (this.eventListeners.has(callbackKey)) {
-      console.log(
-        `Listener para evento '${eventType}' j\xE1 est\xE1 registrado no app '${app}'. Ignorando duplicata.`
-      );
-      return;
-    }
-    const wrappedCallback = (event) => {
-      if (isChannelEvent(event)) {
-        const channelId = event.channel.id;
-        if (channelId) {
-          if (!this.channelInstances.has(channelId)) {
-            const channelInstance = this.createChannelInstance(channelId, app);
-            this.channelInstances.set(channelId, channelInstance);
-          }
-          event.instanceChannel = this.channelInstances.get(channelId);
-          event.instanceChannel?.emit(event.type, event);
-        }
-      }
-      callback(event);
-    };
-    const wsClient = this.wsClients.get(app);
-    if (wsClient) {
-      const scopedEvent = `${app}:${eventType}`;
-      wsClient.on(scopedEvent, wrappedCallback);
-      this.eventListeners.set(callbackKey, wrappedCallback);
-      console.log(
-        `Listener para evento '${eventType}' registrado com sucesso no app '${app}'.`
-      );
-    } else {
-      console.warn(`WebSocket para o app '${app}' n\xE3o est\xE1 conectado.`);
-    }
-  }
-  removeListener(eventType, app) {
-    if (app) {
-      const callbackKey = `${eventType}-${app}`;
-      const callback = this.eventListeners.get(callbackKey);
-      if (callback) {
-        const wsClient = this.wsClients.get(app);
-        if (wsClient) {
-          wsClient.off(eventType, callback);
-          console.log(
-            `Listener para evento '${eventType}' removido do app '${app}'`
-          );
-        }
-        this.eventListeners.delete(callbackKey);
-      }
-    } else {
-      for (const [_app, wsClient] of this.wsClients.entries()) {
-        const callbackKey = `${eventType}-${_app}`;
-        const callback = this.eventListeners.get(callbackKey);
-        if (callback) {
-          wsClient.off(eventType, callback);
-          console.log(
-            `Listener global para evento '${eventType}' removido do app '${_app}'`
-          );
-          this.eventListeners.delete(callbackKey);
-        }
-      }
-    }
-  }
-  /**
-   * Type guard to check if the given data object contains a valid channel property.
-   * This function is used to narrow down the type of the data object and ensure it has a channel with an id.
-   *
-   * @param data - The object to be checked for the presence of a channel property.
-   * @returns A type predicate indicating whether the data object contains a valid channel.
-   *          Returns true if the data object has a channel property with an id, false otherwise.
-   */
-  hasChannel(data) {
-    return data?.channel?.id !== void 0;
-  }
-  // Método para criar uma instância de ChannelInstance
-  createChannelInstance(channelId, app) {
-    return this.channels.Channel({
-      id: channelId,
-      app
-    });
-  }
-  handleWebSocketEvent(event, app) {
-    console.log("Evento recebido no WebSocket:", event.type, event);
-    const { type, ...data } = event;
-    if (this.hasChannel(data)) {
-      const channelId = data.channel.id;
-      if (channelId) {
-        if (!this.channelInstances.has(channelId)) {
-          const channelInstance2 = this.createChannelInstance(channelId, app);
-          this.channelInstances.set(channelId, channelInstance2);
-        }
-        const channelInstance = this.channelInstances.get(channelId);
-        if (channelInstance) {
-          data.channel = { ...data.channel, ...channelInstance };
-        }
-      }
-    }
-    const listener = this.eventListeners.get(type);
-    if (listener) {
-      listener(data);
-    }
-  }
-  /**
-   * Connects to the ARI WebSocket for a specific application.
-   * This function establishes a WebSocket connection to the Asterisk ARI, sets up event listeners,
-   * and ensures the application is registered. It uses an exponential backoff strategy for connection attempts.
-   *
-   * @param app - The name of the application to connect to. This is required and used to identify the application in ARI.
-   * @param subscribedEvents - Optional array of WebSocketEventType to subscribe to specific events.
-   *                           If not provided or empty, it subscribes to all events.
-   * @returns A Promise that resolves when the WebSocket connection is successfully established and the application is registered.
-   * @throws Error if the 'app' parameter is not provided, or if connection attempts fail after multiple retries.
-   */
   /**
-   * Connects to the ARI WebSocket for one or more applications.
-   * Establishes a WebSocket connection for each app and subscribes to events.
-   *
-   * @param apps - Array of application names to connect to.
-   * @param subscribedEvents - Optional array of events to subscribe to.
-   *                           If not provided or empty, subscribes to all events.
-   * @returns A Promise that resolves when all connections are established.
+   * Inicializa uma conexão WebSocket.
    */
   async connectWebSocket(apps, subscribedEvents) {
-    if (!Array.isArray(apps) || apps.length === 0) {
-      throw new Error("\xC9 necess\xE1rio fornecer pelo menos um aplicativo.");
+    if (this.webSocketClient) {
+      console.warn("WebSocket j\xE1 est\xE1 conectado.");
+      return;
     }
-    const uniqueApps = [...new Set(apps)];
-    return Promise.all(
-      uniqueApps.map(async (app) => {
-        if (this.wsClients.has(app)) {
-          console.log(`Conex\xE3o WebSocket para '${app}' j\xE1 existe. Ignorando.`);
-          return;
-        }
-        await this.connectSingleWebSocket(app, subscribedEvents);
-      })
+    this.webSocketClient = new WebSocketClient(
+      this.baseClient,
+      apps,
+      subscribedEvents,
+      this
     );
+    await this.webSocketClient.connect();
   }
   /**
-   * Establishes a single WebSocket connection for a given app.
+   * Adiciona um listener para eventos do WebSocket.
    */
-  async connectSingleWebSocket(app, subscribedEvents) {
-    if (!app) {
-      throw new Error("O nome do aplicativo \xE9 obrigat\xF3rio.");
-    }
-    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 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);
-        wsClient.setMaxListeners(30);
-        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;
+  on(event, listener) {
+    this.webSocketClient?.on(event, listener);
   }
   /**
-   * Integrates WebSocket events with playback listeners.
+   * Adiciona um listener único para eventos do WebSocket.
    */
-  integrateWebSocketEvents(app, wsClient) {
-    if (!wsClient) {
-      throw new Error(
-        `WebSocket client para o app '${app}' n\xE3o est\xE1 conectado.`
-      );
-    }
-    console.log(
-      "**************** INTEGRANDO EVENTOS DE PLAYBACK **************"
-    );
-    console.log(wsClient.eventNames());
-    console.log(
-      "**************** INTEGRANDO EVENTOS DE PLAYBACK **************"
-    );
-    if (wsClient.listenerCount("PlaybackStarted") > 0) {
-      return;
-    }
-    const eventHandlers = {
-      PlaybackStarted: (data) => {
-        if ("playbackId" in data) {
-        }
-      },
-      PlaybackFinished: (data) => {
-        if ("playbackId" in data) {
-        }
-      },
-      ChannelDtmfReceived: (data) => {
-        if (data.type === "ChannelDtmfReceived" && "digit" in data) {
-        } else {
-          console.warn(
-            `[${app}] Evento inesperado em ChannelDtmfReceived`,
-            data
-          );
-        }
-      },
-      ChannelStateChange: (data) => {
-        if ("channel" in data) {
-        }
-      }
-    };
-    for (const [eventType, handler] of Object.entries(eventHandlers)) {
-      if (handler) {
-        wsClient.on(eventType, handler);
-      }
-    }
-    console.log(`[${app}] Todos os eventos do WebSocket foram registrados.`);
+  once(event, listener) {
+    this.webSocketClient?.once(event, listener);
   }
   /**
-   * Ensures the ARI application is registered.
-   *
-   * @param app - The application name to ensure is registered.
-   * @returns {Promise<void>}
+   * Remove um listener para eventos do WebSocket.
    */
-  async ensureAppRegistered(app) {
-    try {
-      const apps = await this.baseClient.get("/applications");
-      const appExists = apps.some((a) => a.name === app);
-      if (!appExists) {
-        console.log(`Registrando o aplicativo ARI: ${app}`);
-        await this.baseClient.post("/applications", { app });
-        console.log(`Aplicativo ${app} registrado com sucesso.`);
-      } else {
-        console.log(`Aplicativo ${app} j\xE1 est\xE1 registrado.`);
-      }
-    } catch (error) {
-      console.error(`Erro ao garantir o registro do aplicativo ${app}:`, error);
-      throw error;
-    }
-  }
-  logListeners() {
-    this.wsClients.forEach((wsClient, app) => {
-      console.log(`Listeners registrados para '${app}':`);
-      wsClient.eventNames().forEach((event) => {
-        const eventName = String(event);
-        const count = wsClient.listenerCount(event);
-        console.log(`  Evento '${eventName}': ${count} listener(s)`);
-      });
-    });
+  off(event, listener) {
+    this.webSocketClient?.off(event, listener);
   }
   /**
-   * Checks if the WebSocket connection is active.
-   *
-   * @returns {boolean} True if connected, false otherwise.
+   * Fecha a conexão WebSocket.
    */
-  anyWebSocketConnected() {
-    return Array.from(this.wsClients.values()).every(
-      (wsClient) => wsClient.isConnected()
-    );
-  }
-  isWebSocketConnected(app) {
-    const wsClient = this.wsClients.get(app);
-    return wsClient ? wsClient.isConnected() : false;
-  }
-  /**
-   * Closes the WebSocket connection and removes all associated listeners.
-   *
-   * This function terminates the active WebSocket connection if one exists,
-   * and cleans up by removing all event listeners attached to it. After calling
-   * this function, the WebSocket client will be set to null, effectively
-   * ending the connection and preparing for potential future connections.
-   *
-   * @returns {void} This function doesn't return a value.
-   */
-  closeWebSocket(app) {
-    const wsClient = this.wsClients.get(app);
-    if (wsClient) {
-      wsClient.close();
-      this.wsClients.delete(app);
-      console.log(`WebSocket para o app '${app}' foi fechado.`);
-    } else {
-      console.warn(`WebSocket para o app '${app}' n\xE3o encontrado.`);
-    }
-  }
-  closeAllWebSockets() {
-    this.wsClients.forEach((wsClient, app) => {
-      wsClient.close();
-      console.log(`WebSocket para o app '${app}' foi fechado.`);
-    });
-    this.wsClients.clear();
-    console.log("Todos os WebSockets foram fechados.");
+  closeWebSocket() {
+    this.webSocketClient?.close();
+    this.webSocketClient = void 0;
   }
   /**
    * Inicializa uma nova instância de `ChannelInstance` para manipular canais localmente.
-   *
-   * @param channelId - O ID do canal, se disponível. Caso contrário, a instância será para um canal ainda não criado.
-   * @param app
-   * @returns Uma instância de `ChannelInstance` vinculada ao cliente atual.
    */
-  Channel(channelId, app) {
-    if (!app) {
-      throw new Error(
-        "O nome do aplicativo (app) \xE9 obrigat\xF3rio para criar um Channel."
-      );
-    }
-    return this.channels.Channel({ id: channelId, app });
+  Channel(channelId) {
+    return this.channels.Channel({ id: channelId });
   }
   /**
    * Inicializa uma nova instância de `PlaybackInstance` para manipular playbacks.
-   *
-   * @param playbackId - O ID do playback, se disponível. Caso contrário, a instância será para um playback ainda não inicializado.
-   * @param app
-   * @returns Uma instância de `PlaybackInstance` vinculada ao cliente atual.
    */
-  Playback(playbackId, app) {
-    if (!app) {
-      throw new Error(
-        "O nome do aplicativo (app) \xE9 obrigat\xF3rio para criar um Channel."
-      );
-    }
-    return this.playbacks.Playback({ id: playbackId, app });
+  Playback(playbackId, _app) {
+    return this.playbacks.Playback({ id: playbackId });
   }
 };
 export {