@ipcom/asterisk-ari 0.0.41 → 0.0.43

package/dist/cjs/index.cjs

@@ -593,7 +593,6 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/ari-client/ariClient.ts
-var import_events4 = require("events");
 var import_exponential_backoff = __toESM(require_backoff(), 1);
 
 // src/ari-client/baseClient.ts
@@ -859,42 +858,15 @@ var Bridges = class {
 
 // src/ari-client/resources/channels.ts
 var import_events = require("events");
+
+// src/ari-client/utils.ts
 function toQueryParams2(options) {
   return new URLSearchParams(
     Object.entries(options).filter(([, value]) => value !== void 0).map(([key, value]) => [key, value])
   ).toString();
 }
-var ChannelEventEmitter = class {
-  eventEmitter = new import_events.EventEmitter();
-  channel;
-  constructor(channel) {
-    this.channel = channel;
-  }
-  /**
-   * Registra um listener para um evento no canal.
-   */
-  on(eventType, callback) {
-    this.eventEmitter.on(eventType, callback);
-  }
-  /**
-   * Emite um evento no canal.
-   */
-  emit(eventType, data) {
-    this.eventEmitter.emit(eventType, data);
-  }
-  /**
-   * Remove um listener de evento do canal.
-   */
-  off(eventType, callback) {
-    this.eventEmitter.off(eventType, callback);
-  }
-  /**
-   * Remove todos os listeners de um evento no canal.
-   */
-  removeAllListeners(eventType) {
-    this.eventEmitter.removeAllListeners(eventType);
-  }
-};
+
+// src/ari-client/resources/channels.ts
 var ChannelInstance = class extends import_events.EventEmitter {
   constructor(client, baseClient, channelId = `channel-${Date.now()}`) {
     super();
@@ -905,7 +877,6 @@ var ChannelInstance = class extends import_events.EventEmitter {
   channelData = null;
   /**
    * Getter para o ID do canal.
-   * Sempre retorna um ID, seja o definido manualmente ou o gerado automaticamente.
    */
   get id() {
     return this.channelId;
@@ -919,7 +890,6 @@ var ChannelInstance = class extends import_events.EventEmitter {
     }
     const channel = await this.baseClient.post("/channels", data);
     this.channelData = channel;
-    this.emit("ChannelCreated", channel, this);
     return channel;
   }
   /**
@@ -942,14 +912,9 @@ var ChannelInstance = class extends import_events.EventEmitter {
       throw new Error("O canal ainda n\xE3o foi criado.");
     }
     await this.baseClient.delete(`/channels/${this.channelData.id}`);
-    this.emit("ChannelHungUp", this.channelData);
   }
   /**
-   * Toca um arquivo de mídia no canal.
-   *
-   * @param options - Opções para o playback, incluindo mídia e idioma.
-   * @param playback - (Opcional) Uma instância de `PlaybackInstance` para gerenciar o playback. Se não fornecido, será criada uma nova.
-   * @returns Uma instância de `PlaybackInstance` associada ao playback.
+   * Reproduz mídia no canal.
    */
   async play(options, playback) {
     if (!playback) {
@@ -957,119 +922,145 @@ var ChannelInstance = class extends import_events.EventEmitter {
     }
     await this.baseClient.post(
       `/channels/${this.channelData?.id}/play/${playback.id}`,
-      // Agora o ID é garantido
       options
     );
     return playback;
   }
   /**
-   * Adiciona um listener para eventos de canal.
+   * Reproduz mídia em um canal.
    */
-  on(event, callback) {
-    super.on(event, callback);
-    return this;
+  async playMedia(media, options) {
+    if (!this.channelData) {
+      throw new Error("O canal ainda n\xE3o foi criado.");
+    }
+    const queryParams = options ? `?${new URLSearchParams(options).toString()}` : "";
+    return this.baseClient.post(
+      `/channels/${this.channelData.id}/play${queryParams}`,
+      { media }
+    );
   }
   /**
-   * Adiciona um listener para ser chamado apenas uma vez.
+   * Para a reprodução de mídia.
    */
-  once(event, callback) {
-    super.once(event, callback);
-    return this;
+  async stopPlayback(playbackId) {
+    if (!this.channelData?.id) {
+      throw new Error("Canal n\xE3o associado a esta inst\xE2ncia.");
+    }
+    await this.baseClient.delete(
+      `/channels/${this.channelData.id}/play/${playbackId}`
+    );
   }
   /**
-   * Remove um listener específico.
+   * Pausa a reprodução de mídia.
    */
-  off(event, callback) {
-    super.off(event, callback);
-    return this;
-  }
-};
-var Channels = class extends import_events.EventEmitter {
-  constructor(baseClient, client, channelId) {
-    super();
-    this.baseClient = baseClient;
-    this.client = client;
-    this.channelId = channelId;
+  async pausePlayback(playbackId) {
+    if (!this.channelData?.id) {
+      throw new Error("Canal n\xE3o associado a esta inst\xE2ncia.");
+    }
+    await this.baseClient.post(
+      `/channels/${this.channelData.id}/play/${playbackId}/pause`
+    );
   }
   /**
-   * Cria uma nova instância de `ChannelInstance` sem originar um canal físico.
+   * Retoma a reprodução de mídia.
    */
-  createChannelInstance(channelId) {
-    return new ChannelInstance(this.client, this.baseClient, channelId);
+  async resumePlayback(playbackId) {
+    if (!this.channelData?.id) {
+      throw new Error("Canal n\xE3o associado a esta inst\xE2ncia.");
+    }
+    await this.baseClient.delete(
+      `/channels/${this.channelData.id}/play/${playbackId}/pause`
+    );
   }
   /**
-   * Origina um canal físico diretamente, sem uma instância de `ChannelInstance`.
+   * Retrocede a reprodução de mídia.
    */
-  async originate(data) {
-    return this.baseClient.post("/channels", data);
+  async rewindPlayback(playbackId, skipMs) {
+    if (!this.channelData?.id) {
+      throw new Error("Canal n\xE3o associado a esta inst\xE2ncia.");
+    }
+    await this.baseClient.post(
+      `/channels/${this.channelData.id}/play/${playbackId}/rewind`,
+      { skipMs }
+    );
   }
   /**
-   * Lida com eventos relacionados ao canal e os emite para listeners registrados.
+   * Avança a reprodução de mídia.
    */
-  emitChannelEvent(eventType, data) {
-    if ("channel" in data) {
-      const channelId = data.channel?.id;
-      if (channelId) {
-        this.emit(`${eventType}:${channelId}`, data);
-      }
+  async fastForwardPlayback(playbackId, skipMs) {
+    if (!this.channelData?.id) {
+      throw new Error("Canal n\xE3o associado a esta inst\xE2ncia.");
     }
-    this.emit(eventType, data);
+    await this.baseClient.post(
+      `/channels/${this.channelData.id}/play/${playbackId}/forward`,
+      { skipMs }
+    );
   }
   /**
-   * Registra um listener para eventos de canal específicos.
+   * Muta o canal.
    */
-  registerChannelListener(eventType, channelId, callback) {
-    this.on(`${eventType}:${channelId}`, callback);
+  async muteChannel(direction = "both") {
+    if (!this.channelData?.id) {
+      throw new Error("Canal n\xE3o associado a esta inst\xE2ncia.");
+    }
+    await this.baseClient.post(
+      `/channels/${this.channelData.id}/mute?direction=${direction}`
+    );
   }
   /**
-   * Remove um listener específico de eventos de canal.
+   * Desmuta o canal.
    */
-  unregisterChannelListener(eventType, channelId, callback) {
-    this.off(`${eventType}:${channelId}`, callback);
+  async unmuteChannel(direction = "both") {
+    if (!this.channelData?.id) {
+      throw new Error("Canal n\xE3o associado a esta inst\xE2ncia.");
+    }
+    await this.baseClient.delete(
+      `/channels/${this.channelData.id}/mute?direction=${direction}`
+    );
   }
   /**
-   * Verifica se um listener já está registrado para um evento de canal.
+   * Coloca o canal em espera.
    */
-  isChannelListenerRegistered(eventType, channelId) {
-    return this.listenerCount(`${eventType}:${channelId}`) > 0;
+  async holdChannel() {
+    if (!this.channelData?.id) {
+      throw new Error("Canal n\xE3o associado a esta inst\xE2ncia.");
+    }
+    await this.baseClient.post(`/channels/${this.channelData.id}/hold`);
   }
   /**
-   * Lista todos os canais ativos.
+   * Remove o canal da espera.
    */
-  async list() {
-    const channels = await this.baseClient.get("/channels");
-    if (!Array.isArray(channels)) {
-      throw new Error("Resposta da API /channels n\xE3o \xE9 um array.");
+  async unholdChannel() {
+    if (!this.channelData?.id) {
+      throw new Error("Canal n\xE3o associado a esta inst\xE2ncia.");
     }
-    return channels;
+    await this.baseClient.delete(`/channels/${this.channelData.id}/hold`);
   }
-  /**
-   * Obtém detalhes de um canal específico.
-   */
-  async getDetails(channelId) {
-    return this.baseClient.get(`/channels/${channelId}`);
+};
+var Channels = class extends import_events.EventEmitter {
+  constructor(baseClient, client) {
+    super();
+    this.baseClient = baseClient;
+    this.client = client;
+  }
+  createChannelInstance(channelId) {
+    return new ChannelInstance(this.client, this.baseClient, channelId);
   }
   /**
-   * Reproduz mídia em um canal.
+   * Origina um canal físico diretamente, sem uma instância de `ChannelInstance`.
    */
-  async playMedia(channelId, media, options) {
-    const queryParams = options ? `?${new URLSearchParams(options).toString()}` : "";
-    return this.baseClient.post(
-      `/channels/${channelId}/play${queryParams}`,
-      { media }
-    );
+  async originate(data) {
+    return this.baseClient.post("/channels", data);
   }
   /**
-   * Encerra um canal específico.
+   * Lista todos os canais ativos.
    */
-  async hangup(channelId, options) {
-    const queryParams = new URLSearchParams({
-      ...options?.reason_code && { reason_code: options.reason_code },
-      ...options?.reason && { reason: options.reason }
-    });
-    return this.baseClient.delete(
-      `/channels/${channelId}?${queryParams.toString()}`
-    );
+  async list() {
+    const channels = await this.baseClient.get("/channels");
+    if (!Array.isArray(channels)) {
+      throw new Error("Resposta da API /channels n\xE3o \xE9 um array.");
+    }
+    return channels;
   }
   /**
    * Inicia a escuta em um canal.
@@ -1092,38 +1083,30 @@ var Channels = class extends import_events.EventEmitter {
     );
   }
   async createExternalMedia(options) {
-    const queryParams = new URLSearchParams(options);
+    const queryParams = toQueryParams2(options);
     return this.baseClient.post(
-      `/channels/externalMedia?${queryParams.toString()}`
+      `/channels/externalMedia?${queryParams}`
     );
   }
   async playWithId(channelId, playbackId, media, options) {
-    const queryParams = options ? `?${new URLSearchParams(options).toString()}` : "";
+    const queryParams = options ? `?${toQueryParams2(options)}` : "";
     return this.baseClient.post(
       `/channels/${channelId}/play/${playbackId}${queryParams}`,
       { media }
     );
   }
   async snoopChannelWithId(channelId, snoopId, options) {
-    const queryParams = new URLSearchParams(options);
+    const queryParams = toQueryParams2(options);
     return this.baseClient.post(
-      `/channels/${channelId}/snoop/${snoopId}?${queryParams.toString()}`
+      `/channels/${channelId}/snoop/${snoopId}?${queryParams}`
     );
   }
   async startMohWithClass(channelId, mohClass) {
     const queryParams = `mohClass=${encodeURIComponent(mohClass)}`;
-    return this.baseClient.post(
+    await this.baseClient.post(
       `/channels/${channelId}/moh?${queryParams}`
     );
   }
-  /**
-   * Gets the value of a channel variable or function.
-   *
-   * @param channelId - The ID of the channel.
-   * @param variable - The name of the channel variable or function to retrieve.
-   * @returns A promise that resolves to the value of the variable.
-   * @throws Will throw an error if the variable is missing or the channel is not found.
-   */
   async getChannelVariable(channelId, variable) {
     if (!variable) {
       throw new Error("The 'variable' parameter is required.");
@@ -1132,15 +1115,6 @@ var Channels = class extends import_events.EventEmitter {
       `/channels/${channelId}/variable?variable=${encodeURIComponent(variable)}`
     );
   }
-  /**
-   * Sets the value of a channel variable or function.
-   *
-   * @param channelId - The ID of the channel.
-   * @param variable - The name of the channel variable or function to set.
-   * @param value - The value to set the variable to.
-   * @returns A promise that resolves when the variable is successfully set.
-   * @throws Will throw an error if the variable is missing or the channel is not found.
-   */
   async setChannelVariable(channelId, variable, value) {
     if (!variable) {
       throw new Error("The 'variable' parameter is required.");
@@ -1150,199 +1124,83 @@ var Channels = class extends import_events.EventEmitter {
       ...value && { value }
     });
     await this.baseClient.post(
-      `/channels/${channelId}/variable?${queryParams.toString()}`
+      `/channels/${channelId}/variable?${queryParams}`
     );
   }
-  /**
-   * Moves the channel to another Stasis application.
-   */
   async moveToApplication(channelId, app, appArgs) {
-    return this.baseClient.post(`/channels/${channelId}/move`, {
+    await this.baseClient.post(`/channels/${channelId}/move`, {
       app,
       appArgs
     });
   }
-  /**
-   * Continues the dialplan for a specific channel.
-   */
   async continueDialplan(channelId, context, extension, priority, label) {
-    return this.baseClient.post(`/channels/${channelId}/continue`, {
+    await this.baseClient.post(`/channels/${channelId}/continue`, {
       context,
       extension,
       priority,
       label
     });
   }
-  /**
-   * Stops music on hold (MOH) for a channel.
-   */
   async stopMusicOnHold(channelId) {
-    return this.baseClient.delete(`/channels/${channelId}/moh`);
+    await this.baseClient.delete(`/channels/${channelId}/moh`);
   }
-  /**
-   * Starts music on hold (MOH) for a channel.
-   */
   async startMusicOnHold(channelId) {
-    return this.baseClient.post(`/channels/${channelId}/moh`);
+    await this.baseClient.post(`/channels/${channelId}/moh`);
   }
-  /**
-   * Starts playback of a media file on a channel.
-   */
-  /**
-   * Starts playback of a media file on a channel.
-   */
-  async startPlayback(channelId, media, options) {
-    const queryParams = options ? `?${new URLSearchParams(options).toString()}` : "";
-    return this.baseClient.post(
-      `/channels/${channelId}/play${queryParams}`,
-      { media }
-    );
-  }
-  /**
-   * Stops playback of a media file on a channel.
-   */
-  async stopPlayback(channelId, playbackId) {
-    return this.baseClient.delete(
-      `/channels/${channelId}/play/${playbackId}`
-    );
-  }
-  /**
-   * Pauses playback of a media file on a channel.
-   */
-  async pausePlayback(channelId, playbackId) {
-    return this.baseClient.post(
-      `/channels/${channelId}/play/${playbackId}/pause`
-    );
-  }
-  /**
-   * Resumes playback of a media file on a channel.
-   */
-  async resumePlayback(channelId, playbackId) {
-    return this.baseClient.delete(
-      `/channels/${channelId}/play/${playbackId}/pause`
-    );
-  }
-  /**
-   * Rewinds playback of a media file on a channel.
-   */
-  async rewindPlayback(channelId, playbackId, skipMs) {
-    return this.baseClient.post(
-      `/channels/${channelId}/play/${playbackId}/rewind`,
-      { skipMs }
-    );
-  }
-  /**
-   * Fast-forwards playback of a media file on a channel.
-   */
-  async fastForwardPlayback(channelId, playbackId, skipMs) {
-    return this.baseClient.post(
-      `/channels/${channelId}/play/${playbackId}/forward`,
-      { skipMs }
-    );
-  }
-  /**
-   * Records audio from a channel.
-   */
   async record(channelId, options) {
-    const queryParams = new URLSearchParams(
-      Object.entries(options).filter(
-        ([, value]) => value !== void 0
-      )
-    );
+    const queryParams = toQueryParams2(options);
     return this.baseClient.post(
-      `/channels/${channelId}/record?${queryParams.toString()}`
+      `/channels/${channelId}/record?${queryParams}`
     );
   }
-  /**
-   * Dials a created channel.
-   */
   async dial(channelId, caller, timeout) {
     const queryParams = new URLSearchParams({
       ...caller && { caller },
       ...timeout && { timeout: timeout.toString() }
     });
-    return this.baseClient.post(
-      `/channels/${channelId}/dial?${queryParams.toString()}`
+    await this.baseClient.post(
+      `/channels/${channelId}/dial?${queryParams}`
     );
   }
-  /**
-   * Redirects the channel to a different location.
-   */
   async redirectChannel(channelId, endpoint) {
-    return this.baseClient.post(
+    await this.baseClient.post(
       `/channels/${channelId}/redirect?endpoint=${encodeURIComponent(endpoint)}`
     );
   }
-  /**
-   * Answers a channel.
-   */
   async answerChannel(channelId) {
-    return this.baseClient.post(`/channels/${channelId}/answer`);
+    await this.baseClient.post(`/channels/${channelId}/answer`);
   }
-  /**
-   * Sends a ringing indication to a channel.
-   */
   async ringChannel(channelId) {
-    return this.baseClient.post(`/channels/${channelId}/ring`);
+    await this.baseClient.post(`/channels/${channelId}/ring`);
   }
-  /**
-   * Stops ringing indication on a channel.
-   */
   async stopRingChannel(channelId) {
-    return this.baseClient.delete(`/channels/${channelId}/ring`);
+    await this.baseClient.delete(`/channels/${channelId}/ring`);
   }
-  /**
-   * Sends DTMF to a channel.
-   */
   async sendDTMF(channelId, dtmf, options) {
-    const queryParams = new URLSearchParams({
-      dtmf,
-      ...options?.before && { before: options.before.toString() },
-      ...options?.between && { between: options.between.toString() },
-      ...options?.duration && { duration: options.duration.toString() },
-      ...options?.after && { after: options.after.toString() }
-    });
-    return this.baseClient.post(
-      `/channels/${channelId}/dtmf?${queryParams.toString()}`
+    const queryParams = toQueryParams2({ dtmf, ...options });
+    await this.baseClient.post(
+      `/channels/${channelId}/dtmf?${queryParams}`
     );
   }
-  /**
-   * Mutes a channel.
-   */
   async muteChannel(channelId, direction = "both") {
-    return this.baseClient.post(
+    await this.baseClient.post(
       `/channels/${channelId}/mute?direction=${direction}`
     );
   }
-  /**
-   * Unmutes a channel.
-   */
   async unmuteChannel(channelId, direction = "both") {
-    return this.baseClient.delete(
+    await this.baseClient.delete(
       `/channels/${channelId}/mute?direction=${direction}`
     );
   }
-  /**
-   * Puts a channel on hold.
-   */
   async holdChannel(channelId) {
-    return this.baseClient.post(`/channels/${channelId}/hold`);
+    await this.baseClient.post(`/channels/${channelId}/hold`);
   }
-  /**
-   * Removes a channel from hold.
-   */
   async unholdChannel(channelId) {
-    return this.baseClient.delete(`/channels/${channelId}/hold`);
+    await this.baseClient.delete(`/channels/${channelId}/hold`);
   }
-  /**
-   * Creates a channel and places it in a Stasis app without dialing it.
-   */
   async createChannel(data) {
     return this.baseClient.post("/channels/create", data);
   }
-  /**
-   * Creates a new channel with a specific ID and originates a call.
-   */
   async originateWithId(channelId, data) {
     return this.baseClient.post(`/channels/${channelId}`, data);
   }
@@ -1601,6 +1459,7 @@ var WebSocketClient = class extends import_events3.EventEmitter {
   ws = null;
   isClosedManually = false;
   isReconnecting = false;
+  messageListeners = [];
   /**
    * Establishes a connection to the WebSocket server.
    * @returns A Promise that resolves when the connection is established, or rejects if an error occurs.
@@ -1637,6 +1496,9 @@ var WebSocketClient = class extends import_events3.EventEmitter {
   isConnected() {
     return this.ws?.readyState === import_ws.default.OPEN;
   }
+  onMessage(callback) {
+    this.messageListeners.push(callback);
+  }
   /**
    * Adds a listener for WebSocket events.
    * @param event - The event type to listen for.
@@ -1704,6 +1566,7 @@ var WebSocketClient = class extends import_events3.EventEmitter {
     if (this.ws) {
       this.isClosedManually = true;
       this.ws.close();
+      this.ws = null;
       console.log("WebSocket fechado manualmente.");
     }
   }
@@ -1725,15 +1588,14 @@ var AriClient = class {
     this.asterisk = new Asterisk(this.baseClient);
     this.bridges = new Bridges(this.baseClient);
   }
+  eventListeners = /* @__PURE__ */ new Map();
   wsClient = null;
-  channelEmitters = /* @__PURE__ */ new Map();
   baseClient;
   isReconnecting = false;
-  eventEmitter = new import_events4.EventEmitter();
-  wsConnections = /* @__PURE__ */ new Map();
   isWebSocketConnectedFlag = false;
   webSocketReady = null;
   // Promise para rastrear o estado do WebSocket
+  channelInstances = /* @__PURE__ */ new Map();
   pendingListeners = [];
   processPendingListeners() {
     if (!this.wsClient || !this.isWebSocketConnectedFlag) {
@@ -1758,6 +1620,41 @@ var AriClient = class {
   sounds;
   asterisk;
   bridges;
+  /**
+   * 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) {
+    return this.channels.createChannelInstance(channelId);
+  }
+  handleWebSocketEvent(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);
+          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,
@@ -1843,18 +1740,6 @@ var AriClient = class {
         `WebSocket client para o app '${app}' n\xE3o est\xE1 conectado.`
       );
     }
-    wsClient.on("ChannelDestroyed", (data) => {
-      if (data.type === "ChannelDestroyed" && "channel" in data) {
-        console.log(`[${app}] Canal destru\xEDdo: ${data.channel.id}`);
-        this.removeChannel(data.channel.id);
-      }
-    });
-    wsClient.on("StasisEnd", (data) => {
-      if (data.type === "StasisEnd" && "channel" in data) {
-        console.log(`[${app}] StasisEnd para o canal: ${data.channel.id}`);
-        this.removeChannel(data.channel.id);
-      }
-    });
     const eventHandlers = {
       PlaybackStarted: (data) => {
         if ("playbackId" in data) {
@@ -1889,99 +1774,6 @@ var AriClient = class {
     }
     console.log(`[${app}] Todos os eventos do WebSocket foram registrados.`);
   }
-  /**
-   * Registra um listener para eventos globais.
-   * @param callback - A função a ser executada quando um evento global for recebido.
-   */
-  onGlobalEvent(callback) {
-    this.eventEmitter.on("globalEvent", callback);
-  }
-  /**
-   * Remove um listener para eventos globais.
-   * @param callback - A função a ser removida dos eventos globais.
-   */
-  offGlobalEvent(callback) {
-    this.eventEmitter.off("globalEvent", callback);
-  }
-  /**
-   * Emite um evento global.
-   * @param data - Os dados do evento a serem emitidos.
-   */
-  emitGlobalEvent(data) {
-    this.eventEmitter.emit("globalEvent", data);
-  }
-  /**
-   * Unregisters a listener for playback events.
-   *
-   * This method removes a specific listener registered for a playback event type,
-   * ensuring that no further notifications are sent to the callback function.
-   *
-   * @param eventType - The type of event to stop listening for.
-   * @param playbackId - The unique ID of the playback associated with the listener.
-   * @param callback - The callback function to remove from the listener.
-   */
-  unregisterPlaybackListener(eventType, playbackId, callback) {
-    this.playbacks.unregisterListener(eventType, playbackId, callback);
-  }
-  registerListener(eventType, condition, callback) {
-    if (!this.isWebSocketConnected()) {
-      throw new Error("WebSocket n\xE3o est\xE1 conectado.");
-    }
-    const handler = (eventData) => {
-      if (eventData.type === eventType && condition(eventData)) {
-        callback(eventData);
-      }
-    };
-    this.wsClient?.on(eventType, handler);
-  }
-  /**
-   * 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.
-   */
-  registerPlaybackListener(eventType, playbackId, callback) {
-    if (!this.isWebSocketConnected()) {
-      throw new Error("WebSocket n\xE3o est\xE1 conectado.");
-    }
-    console.log(
-      `Registrando listener para evento ${eventType} com playbackId ${playbackId}`
-    );
-    const handler = (eventData) => {
-      if ("playbackId" in eventData && eventData.playbackId === playbackId) {
-        callback(eventData);
-      }
-    };
-    this.wsClient?.on(eventType, handler);
-  }
-  registerChannelListener(eventType, channelId, callback) {
-    if (!this.isWebSocketConnected()) {
-      throw new Error("WebSocket n\xE3o est\xE1 conectado.");
-    }
-    console.log(
-      `Registrando listener para evento ${eventType} com channelId ${channelId}`
-    );
-    const handler = (eventData) => {
-      if (eventData.type === eventType && "channel" in eventData && eventData.channel?.id === channelId) {
-        callback(
-          eventData
-        );
-      }
-    };
-    this.wsClient?.on(eventType, handler);
-  }
-  /**
-   * 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.
-   */
-  isPlaybackListenerRegistered(eventType, playbackId) {
-    return this.playbacks.isListenerRegistered(eventType, playbackId);
-  }
   /**
    * Ensures the ARI application is registered.
    *
@@ -2012,69 +1804,6 @@ var AriClient = class {
   isWebSocketConnected() {
     return this.wsClient ? this.wsClient.isConnected() : false;
   }
-  /**
-   * Registers a listener for WebSocket events.
-   *
-   * This function allows you to attach a callback function to a specific WebSocket event type.
-   * The callback will be executed whenever an event of the specified type is received.
-   *
-   * @template T - The type of WebSocket event, extending WebSocketEvent["type"].
-   * @param {T} event - The type of WebSocket event to listen for.
-   * @param {(data: Extract<WebSocketEvent, { type: T }>) => void} callback - The function to be called when the event is received.
-   *        The callback receives the event data as its parameter.
-   * @throws {Error} Throws an error if the WebSocket client is not connected when this method is called.
-   * @returns {void} This function doesn't return a value.
-   */
-  async onWebSocketEvent(event, callback) {
-    if (this.webSocketReady) {
-      console.log(`Aguardando WebSocket conectar antes de registrar: ${event}`);
-      await this.webSocketReady;
-    }
-    if (!this.wsClient || !this.isWebSocketConnectedFlag) {
-      throw new Error("WebSocket ainda n\xE3o est\xE1 conectado.");
-    }
-    console.log(`Registrando listener para evento: ${event}`);
-    this.wsClient.on(event, callback);
-  }
-  /**
-   * Removes a specific listener for WebSocket events.
-   *
-   * This function unregisters a previously registered callback function for a specific WebSocket event type.
-   * It's useful for removing event handlers when they are no longer needed or for cleaning up resources.
-   *
-   * @template T - The type of WebSocket event, extending WebSocketEvent["type"].
-   * @param {T} event - The type of WebSocket event to remove the listener from.
-   * @param {(data: Extract<WebSocketEvent, { type: T }>) => void} callback - The callback function to be removed.
-   *        This should be the same function reference that was used when adding the event listener.
-   * @throws {Error} Throws an error if the WebSocket client is not connected when this method is called.
-   * @returns {void} This function doesn't return a value.
-   */
-  offWebSocketEvent(event, callback) {
-    if (!this.wsClient) {
-      throw new Error("WebSocket n\xE3o est\xE1 conectado.");
-    }
-    this.wsClient.off(event, callback);
-  }
-  /**
-   * Removes all listeners for a specific WebSocket event type.
-   *
-   * This function removes all event listeners that have been registered for a particular
-   * WebSocket event type. It's useful for cleaning up event listeners when they are no
-   * longer needed or before re-registering new listeners.
-   *
-   * @param event - The type of WebSocket event for which all listeners should be removed.
-   *                This should be a string identifying the event type (e.g., 'message', 'close', etc.).
-   *
-   * @throws {Error} Throws an error if the WebSocket client is not connected when this method is called.
-   *
-   * @returns {void} This function doesn't return a value.
-   */
-  removeAllWebSocketListeners(event) {
-    if (!this.wsClient) {
-      throw new Error("WebSocket n\xE3o est\xE1 conectado.");
-    }
-    this.wsClient.removeAllListeners(event);
-  }
   /**
    * Closes the WebSocket connection and removes all associated listeners.
    *
@@ -2091,45 +1820,6 @@ var AriClient = class {
       this.wsClient = null;
     }
   }
-  /**
-   * Obtém ou cria um emissor de eventos para o canal especificado.
-   */
-  getOrCreateChannelEmitter(channel) {
-    if (!this.channelEmitters.has(channel.id)) {
-      this.channelEmitters.set(channel.id, new ChannelEventEmitter(channel));
-    }
-    return this.channelEmitters.get(channel.id);
-  }
-  /**
-   * Adiciona um listener para um evento específico de canal.
-   */
-  onChannelEvent(channelId, eventType, callback) {
-    const channelEmitter = this.channelEmitters.get(channelId);
-    if (!channelEmitter) {
-      throw new Error(`Canal com ID ${channelId} n\xE3o encontrado.`);
-    }
-    channelEmitter.on(eventType, callback);
-  }
-  removeChannel(channelId) {
-    const channelEmitter = this.channelEmitters.get(channelId);
-    if (channelEmitter) {
-      channelEmitter.removeAllListeners();
-      this.channelEmitters.delete(channelId);
-      console.log(`Listeners para o canal ${channelId} foram removidos.`);
-    } else {
-      console.warn(`Nenhum listener encontrado para o canal ${channelId}.`);
-    }
-  }
-  /**
-   * Remove um listener para um evento específico de canal.
-   */
-  offChannelEvent(channelId, eventType, callback) {
-    const channelEmitter = this.channelEmitters.get(channelId);
-    if (!channelEmitter) {
-      throw new Error(`Canal com ID ${channelId} n\xE3o encontrado.`);
-    }
-    channelEmitter.off(eventType, callback);
-  }
   /**
    * Retrieves a list of active channels from the Asterisk ARI.
    *
@@ -2147,18 +1837,6 @@ var AriClient = class {
   async originateChannel(data) {
     return this.channels.originate(data);
   }
-  /**
-   * Retrieves details of a specific channel.
-   */
-  async getChannelDetails(channelId) {
-    return this.channels.getDetails(channelId);
-  }
-  /**
-   * Hangs up a specific channel.
-   */
-  async hangupChannel(channelId) {
-    return this.channels.hangup(channelId);
-  }
   /**
    * Continues the dialplan for a specific channel.
    */
@@ -2189,12 +1867,6 @@ var AriClient = class {
   async getChannelVariable(channelId, variable) {
     return this.channels.getChannelVariable(channelId, variable);
   }
-  /**
-   * Plays a media file to a channel.
-   */
-  async playMediaToChannel(channelId, media, options) {
-    return this.channels.playMedia(channelId, media, options);
-  }
   /**
    * Starts music on hold for a channel.
    */
@@ -2207,42 +1879,6 @@ var AriClient = class {
   async stopChannelMusicOnHold(channelId) {
     return this.channels.stopMusicOnHold(channelId);
   }
-  /**
-   * Starts playback of a media file on a channel.
-   */
-  async startChannelPlayback(channelId, media, options) {
-    return this.channels.startPlayback(channelId, media, options);
-  }
-  /**
-   * Stops playback of a media file on a channel.
-   */
-  async stopChannelPlayback(channelId, playbackId) {
-    return this.channels.stopPlayback(channelId, playbackId);
-  }
-  /**
-   * Pauses playback of a media file on a channel.
-   */
-  async pauseChannelPlayback(channelId, playbackId) {
-    return this.channels.pausePlayback(channelId, playbackId);
-  }
-  /**
-   * Resumes playback of a media file on a channel.
-   */
-  async resumeChannelPlayback(channelId, playbackId) {
-    return this.channels.resumePlayback(channelId, playbackId);
-  }
-  /**
-   * Rewinds playback of a media file on a channel.
-   */
-  async rewindChannelPlayback(channelId, playbackId, skipMs) {
-    return this.channels.rewindPlayback(channelId, playbackId, skipMs);
-  }
-  /**
-   * Fast-forwards playback of a media file on a channel.
-   */
-  async fastForwardChannelPlayback(channelId, playbackId, skipMs) {
-    return this.channels.fastForwardPlayback(channelId, playbackId, skipMs);
-  }
   /**
    * Records audio from a channel.
    */
@@ -2292,12 +1928,6 @@ var AriClient = class {
   async redirectChannel(channelId, endpoint) {
     return this.channels.redirectChannel(channelId, endpoint);
   }
-  /**
-   * Answers a channel.
-   */
-  async answerChannel(channelId) {
-    return this.channels.answerChannel(channelId);
-  }
   /**
    * Sends a ringing indication to a channel.
    */
@@ -2442,18 +2072,6 @@ var AriClient = class {
   async createChannel(data) {
     return this.channels.createChannel(data);
   }
-  /**
-   * Hangs up a specific channel.
-   *
-   * @param channelId - The unique identifier of the channel to hang up.
-   * @param options - Optional parameters for the hangup operation.
-   * @param options.reason_code - An optional reason code for the hangup.
-   * @param options.reason - An optional textual reason for the hangup.
-   * @returns A promise that resolves when the hangup operation is complete.
-   */
-  async hangup(channelId, options) {
-    return this.channels.hangup(channelId, options);
-  }
   /**
    * Originates a new channel with a specified ID using the provided originate request data.
    *