@ipcom/asterisk-ari 0.0.26 → 0.0.28

package/dist/esm/index.js

@@ -572,7 +572,7 @@ var require_backoff = __commonJS({
 
 // src/ari-client/ariClient.ts
 var import_exponential_backoff = __toESM(require_backoff(), 1);
-import { EventEmitter as EventEmitter3 } from "events";
+import { EventEmitter as EventEmitter4 } from "events";
 
 // src/ari-client/baseClient.ts
 import axios from "axios";
@@ -836,55 +836,150 @@ var Bridges = class {
 };
 
 // src/ari-client/resources/channels.ts
+import { EventEmitter } from "events";
 function toQueryParams2(options) {
   return new URLSearchParams(
     Object.entries(options).filter(([, value]) => value !== void 0).map(([key, value]) => [key, value])
-    // Garante que value é string
   ).toString();
 }
-var Channels = class {
-  constructor(client) {
+var ChannelInstance = class extends EventEmitter {
+  constructor(client, channelId) {
+    super();
     this.client = client;
+    this.channelId = channelId;
   }
+  channelData = null;
   /**
-   * Lists all active channels.
+   * Origina um canal físico no Asterisk.
    */
-  async list() {
-    const channels = await this.client.get("/channels");
-    if (!Array.isArray(channels)) {
-      throw new Error("Resposta da API /channels n\xE3o \xE9 um array.");
+  async originate(data) {
+    if (this.channelData) {
+      throw new Error("O canal j\xE1 foi criado.");
     }
-    return channels;
+    const channel = await this.client.post("/channels", data);
+    this.channelData = channel;
+    this.emit("ChannelCreated", channel, this);
+    return channel;
   }
   /**
-   * Creates a new channel.
+   * Obtém os detalhes do canal.
+   */
+  async getDetails() {
+    if (!this.channelId && !this.channelData) {
+      throw new Error("Nenhum canal est\xE1 associado a esta inst\xE2ncia.");
+    }
+    const id = this.channelId || this.channelData?.id;
+    const details = await this.client.get(`/channels/${id}`);
+    this.channelData = details;
+    return details;
+  }
+  /**
+   * Encerra o canal, se ele já foi criado.
+   */
+  async hangup() {
+    if (!this.channelData) {
+      throw new Error("O canal ainda n\xE3o foi criado.");
+    }
+    await this.client.delete(`/channels/${this.channelData.id}`);
+    this.emit("ChannelHungUp", this.channelData);
+  }
+  /**
+   * Adiciona um listener para eventos de canal.
+   */
+  on(event, callback) {
+    super.on(event, callback);
+    return this;
+  }
+  /**
+   * Adiciona um listener para ser chamado apenas uma vez.
+   */
+  once(event, callback) {
+    super.once(event, callback);
+    return this;
+  }
+  /**
+   * Remove um listener específico.
+   */
+  off(event, callback) {
+    super.off(event, callback);
+    return this;
+  }
+};
+var Channels = class extends EventEmitter {
+  constructor(client) {
+    super();
+    this.client = client;
+  }
+  /**
+   * Cria uma nova instância de `ChannelInstance` sem originar um canal físico.
+   */
+  createChannelInstance(channelId) {
+    return new ChannelInstance(this.client, channelId);
+  }
+  /**
+   * Origina um canal físico diretamente, sem uma instância de `ChannelInstance`.
    */
   async originate(data) {
     return this.client.post("/channels", data);
   }
   /**
-   * Retrieves details of a specific channel.
+   * Lida com eventos relacionados ao canal e os emite para listeners registrados.
    */
-  async getDetails(channelId) {
-    return this.client.get(`/channels/${channelId}`);
+  emitChannelEvent(eventType, data) {
+    if ("channel" in data) {
+      const channelId = data.channel?.id;
+      if (channelId) {
+        this.emit(`${eventType}:${channelId}`, data);
+      }
+    }
+    this.emit(eventType, data);
   }
   /**
-   * Creates a channel and places it in a Stasis app without dialing it.
+   * Registra um listener para eventos de canal específicos.
    */
-  async createChannel(data) {
-    return this.client.post("/channels/create", data);
+  registerChannelListener(eventType, channelId, callback) {
+    this.on(`${eventType}:${channelId}`, callback);
   }
   /**
-   * Creates a new channel with a specific ID and originates a call.
+   * Remove um listener específico de eventos de canal.
    */
-  async originateWithId(channelId, data) {
-    return this.client.post(`/channels/${channelId}`, data);
+  unregisterChannelListener(eventType, channelId, callback) {
+    this.off(`${eventType}:${channelId}`, callback);
+  }
+  /**
+   * Verifica se um listener já está registrado para um evento de canal.
+   */
+  isChannelListenerRegistered(eventType, channelId) {
+    return this.listenerCount(`${eventType}:${channelId}`) > 0;
+  }
+  /**
+   * Lista todos os canais ativos.
+   */
+  async list() {
+    const channels = await this.client.get("/channels");
+    if (!Array.isArray(channels)) {
+      throw new Error("Resposta da API /channels n\xE3o \xE9 um array.");
+    }
+    return channels;
+  }
+  /**
+   * Obtém detalhes de um canal específico.
+   */
+  async getDetails(channelId) {
+    return this.client.get(`/channels/${channelId}`);
   }
   /**
-   * Hangs up (terminates) a specific channel.
+   * Reproduz mídia em um canal.
    */
+  async playMedia(channelId, media, options) {
+    const queryParams = options ? `?${new URLSearchParams(options).toString()}` : "";
+    return this.client.post(
+      `/channels/${channelId}/play${queryParams}`,
+      { media }
+    );
+  }
   /**
-   * Hangs up a specific channel with optional reason or reason code.
+   * Encerra um canal específico.
    */
   async hangup(channelId, options) {
     const queryParams = new URLSearchParams({
@@ -896,15 +991,82 @@ var Channels = class {
     );
   }
   /**
-   * Continues the dialplan for a specific channel.
+   * Inicia a escuta em um canal.
    */
-  async continueDialplan(channelId, context, extension, priority, label) {
-    return this.client.post(`/channels/${channelId}/continue`, {
-      context,
-      extension,
-      priority,
-      label
+  async snoopChannel(channelId, options) {
+    const queryParams = toQueryParams2(options);
+    return this.client.post(
+      `/channels/${channelId}/snoop?${queryParams}`
+    );
+  }
+  async startSilence(channelId) {
+    return this.client.post(`/channels/${channelId}/silence`);
+  }
+  async stopSilence(channelId) {
+    return this.client.delete(`/channels/${channelId}/silence`);
+  }
+  async getRTPStatistics(channelId) {
+    return this.client.get(`/channels/${channelId}/rtp_statistics`);
+  }
+  async createExternalMedia(options) {
+    const queryParams = new URLSearchParams(options);
+    return this.client.post(
+      `/channels/externalMedia?${queryParams.toString()}`
+    );
+  }
+  async playWithId(channelId, playbackId, media, options) {
+    const queryParams = options ? `?${new URLSearchParams(options).toString()}` : "";
+    return this.client.post(
+      `/channels/${channelId}/play/${playbackId}${queryParams}`,
+      { media }
+    );
+  }
+  async snoopChannelWithId(channelId, snoopId, options) {
+    const queryParams = new URLSearchParams(options);
+    return this.client.post(
+      `/channels/${channelId}/snoop/${snoopId}?${queryParams.toString()}`
+    );
+  }
+  async startMohWithClass(channelId, mohClass) {
+    const queryParams = `mohClass=${encodeURIComponent(mohClass)}`;
+    return this.client.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.");
+    }
+    return this.client.get(
+      `/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.");
+    }
+    const queryParams = new URLSearchParams({
+      variable,
+      ...value && { value }
     });
+    await this.client.post(
+      `/channels/${channelId}/variable?${queryParams.toString()}`
+    );
   }
   /**
    * Moves the channel to another Stasis application.
@@ -916,31 +1078,21 @@ var Channels = class {
     });
   }
   /**
-   * Sets a channel variable.
+   * Continues the dialplan for a specific channel.
    */
-  async setVariable(channelId, variable, value) {
-    return this.client.post(`/channels/${channelId}/variable`, {
-      variable,
-      value
+  async continueDialplan(channelId, context, extension, priority, label) {
+    return this.client.post(`/channels/${channelId}/continue`, {
+      context,
+      extension,
+      priority,
+      label
     });
   }
   /**
-   * Gets a channel variable.
-   */
-  async getVariable(channelId, variable) {
-    return this.client.get(
-      `/channels/${channelId}/variable?variable=${encodeURIComponent(variable)}`
-    );
-  }
-  /**
-   * Plays a media file to a channel.
+   * Stops music on hold (MOH) for a channel.
    */
-  async playMedia(channelId, media, options) {
-    const queryParams = options ? `?${new URLSearchParams(options).toString()}` : "";
-    return this.client.post(
-      `/channels/${channelId}/play${queryParams}`,
-      { media }
-    );
+  async stopMusicOnHold(channelId) {
+    return this.client.delete(`/channels/${channelId}/moh`);
   }
   /**
    * Starts music on hold (MOH) for a channel.
@@ -949,11 +1101,8 @@ var Channels = class {
     return this.client.post(`/channels/${channelId}/moh`);
   }
   /**
-   * Stops music on hold (MOH) for a channel.
+   * Starts playback of a media file on a channel.
    */
-  async stopMusicOnHold(channelId) {
-    return this.client.delete(`/channels/${channelId}/moh`);
-  }
   /**
    * Starts playback of a media file on a channel.
    */
@@ -1019,24 +1168,6 @@ var Channels = class {
       `/channels/${channelId}/record?${queryParams.toString()}`
     );
   }
-  /**
-   * Starts snooping on a channel.
-   */
-  async snoopChannel(channelId, options) {
-    const queryParams = toQueryParams2(options);
-    return this.client.post(
-      `/channels/${channelId}/snoop?${queryParams}`
-    );
-  }
-  /**
-   * Starts snooping on a channel with a specific snoop ID.
-   */
-  async snoopChannelWithId(channelId, snoopId, options) {
-    const queryParams = new URLSearchParams(options);
-    return this.client.post(
-      `/channels/${channelId}/snoop/${snoopId}?${queryParams.toString()}`
-    );
-  }
   /**
    * Dials a created channel.
    */
@@ -1049,21 +1180,6 @@ var Channels = class {
       `/channels/${channelId}/dial?${queryParams.toString()}`
     );
   }
-  /**
-   * Retrieves RTP statistics for a channel.
-   */
-  async getRTPStatistics(channelId) {
-    return this.client.get(`/channels/${channelId}/rtp_statistics`);
-  }
-  /**
-   * Creates a channel to an external media source/sink.
-   */
-  async createExternalMedia(options) {
-    const queryParams = new URLSearchParams(options);
-    return this.client.post(
-      `/channels/externalMedia?${queryParams.toString()}`
-    );
-  }
   /**
    * Redirects the channel to a different location.
    */
@@ -1133,6 +1249,18 @@ var Channels = class {
   async unholdChannel(channelId) {
     return this.client.delete(`/channels/${channelId}/hold`);
   }
+  /**
+   * Creates a channel and places it in a Stasis app without dialing it.
+   */
+  async createChannel(data) {
+    return this.client.post("/channels/create", data);
+  }
+  /**
+   * Creates a new channel with a specific ID and originates a call.
+   */
+  async originateWithId(channelId, data) {
+    return this.client.post(`/channels/${channelId}`, data);
+  }
 };
 
 // src/ari-client/resources/endpoints.ts
@@ -1182,12 +1310,93 @@ var Endpoints = class {
 };
 
 // src/ari-client/resources/playbacks.ts
-import { EventEmitter } from "events";
-var Playbacks = class extends EventEmitter {
+import { EventEmitter as EventEmitter2 } from "events";
+var PlaybackInstance = class extends EventEmitter2 {
+  constructor(client, playbackId) {
+    super();
+    this.client = client;
+    this.playbackId = playbackId;
+  }
+  playbackData = null;
+  /**
+   * Obtém os detalhes do playback.
+   */
+  async getDetails() {
+    if (!this.playbackId && !this.playbackData) {
+      throw new Error("Nenhum playback associado a esta inst\xE2ncia.");
+    }
+    const id = this.playbackId || this.playbackData?.id;
+    const details = await this.client.get(`/playbacks/${id}`);
+    this.playbackData = details;
+    return details;
+  }
+  /**
+   * Controla o playback.
+   */
+  async control(operation) {
+    if (!this.playbackId) {
+      throw new Error("Nenhum playback associado para controlar.");
+    }
+    await this.client.post(`/playbacks/${this.playbackId}/control`, {
+      operation
+    });
+  }
+  /**
+   * Encerra o playback.
+   */
+  async stop() {
+    if (!this.playbackId) {
+      throw new Error("Nenhum playback associado para encerrar.");
+    }
+    await this.client.post(`/playbacks/${this.playbackId}/stop`);
+    this.emit("PlaybackStopped", this.playbackData);
+  }
+  /**
+   * Adiciona um listener para eventos de playback.
+   */
+  on(event, callback) {
+    super.on(event, callback);
+    return this;
+  }
+  /**
+   * Adiciona um listener para ser chamado apenas uma vez.
+   */
+  once(event, callback) {
+    super.once(event, callback);
+    return this;
+  }
+  /**
+   * Remove um listener específico.
+   */
+  off(event, callback) {
+    super.off(event, callback);
+    return this;
+  }
+};
+var Playbacks = class extends EventEmitter2 {
   constructor(client) {
     super();
     this.client = client;
   }
+  /**
+   * Inicializa uma nova instância de `PlaybackInstance`.
+   */
+  Playback(playbackId) {
+    return new PlaybackInstance(this.client, playbackId);
+  }
+  /**
+   * Emite eventos de playback.
+   * Atualizado para gerenciar eventos específicos para `PlaybackInstance`.
+   */
+  emitPlaybackEvent(eventType, data) {
+    if ("playbackId" in data) {
+      const playbackId = data.playbackId;
+      if (playbackId) {
+        this.emit(`${eventType}:${playbackId}`, data);
+      }
+    }
+    this.emit(eventType, data);
+  }
   /**
    * Retrieves details of a specific playback.
    *
@@ -1255,19 +1464,6 @@ var Playbacks = class extends EventEmitter {
   isListenerRegistered(eventType, playbackId) {
     return this.listenerCount(`${eventType}:${playbackId}`) > 0;
   }
-  /**
-   * Emits playback events received via WebSocket.
-   * This method should be called by the WebSocket client when playback events occur.
-   *
-   * @param eventType - The type of the WebSocket event.
-   * @param data - The data associated with the event.
-   */
-  emitPlaybackEvent(eventType, data) {
-    if ("playbackId" in data) {
-      this.emit(`${eventType}:${data.playbackId}`, data);
-    }
-    this.emit(eventType, data);
-  }
 };
 
 // src/ari-client/resources/sounds.ts
@@ -1302,9 +1498,9 @@ var Sounds = class {
 };
 
 // src/ari-client/websocketClient.ts
-import { EventEmitter as EventEmitter2 } from "events";
+import { EventEmitter as EventEmitter3 } from "events";
 import WebSocket from "ws";
-var WebSocketClient = class extends EventEmitter2 {
+var WebSocketClient = class extends EventEmitter3 {
   /**
    * Creates a new WebSocketClient instance.
    * @param url - The WebSocket server URL to connect to.
@@ -1443,7 +1639,7 @@ var AriClient = class {
   wsClient = null;
   baseClient;
   isReconnecting = false;
-  eventEmitter = new EventEmitter3();
+  eventEmitter = new EventEmitter4();
   channels;
   endpoints;
   applications;
@@ -1545,6 +1741,7 @@ var AriClient = class {
       ChannelDtmfReceived: (data) => {
         if ("channel" in data) {
           console.log("DTMF recebido no canal:", data.channel);
+          this.channels.emitChannelEvent("ChannelDtmfReceived", data);
         }
         this.emitGlobalEvent(data);
       }
@@ -1766,13 +1963,13 @@ var AriClient = class {
    * Sets a channel variable.
    */
   async setChannelVariable(channelId, variable, value) {
-    return this.channels.setVariable(channelId, variable, value);
+    return this.channels.setChannelVariable(channelId, variable, value);
   }
   /**
    * Gets a channel variable.
    */
   async getChannelVariable(channelId, variable) {
-    return this.channels.getVariable(channelId, variable);
+    return this.channels.getChannelVariable(channelId, variable);
   }
   /**
    * Plays a media file to a channel.
@@ -2243,6 +2440,24 @@ var AriClient = class {
   async setGlobalVariable(variableName, value) {
     return this.asterisk.setGlobalVariable(variableName, value);
   }
+  /**
+   * 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.
+   * @returns Uma instância de `ChannelInstance` vinculada ao cliente atual.
+   */
+  Channel(channelId) {
+    return this.channels.createChannelInstance(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.
+   * @returns Uma instância de `PlaybackInstance` vinculada ao cliente atual.
+   */
+  Playback(playbackId) {
+    return this.playbacks.Playback(playbackId);
+  }
 };
 export {
   Applications,