@ipcom/asterisk-ari 0.0.27 → 0.0.29

package/dist/esm/index.js

@@ -840,22 +840,111 @@ 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 extends EventEmitter {
-  constructor(client) {
+var ChannelInstance = class extends EventEmitter {
+  constructor(client, baseClient, channelId) {
     super();
     this.client = client;
+    this.baseClient = baseClient;
+    this.channelId = channelId;
   }
+  channelData = null;
   /**
-   * Emits a specific channel-related event.
-   *
-   * This method is called by the WebSocket client to notify about channel-related events.
-   * It will emit events like "ChannelDtmfReceived" to registered listeners.
+   * Origina um canal físico no Asterisk.
+   */
+  async originate(data) {
+    if (this.channelData) {
+      throw new Error("O canal j\xE1 foi criado.");
+    }
+    const channel = await this.baseClient.post("/channels", data);
+    this.channelData = channel;
+    this.emit("ChannelCreated", channel, this);
+    return 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.baseClient.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.baseClient.delete(`/channels/${this.channelData.id}`);
+    this.emit("ChannelHungUp", this.channelData);
+  }
+  /**
+   * Toca um arquivo de mídia no canal.
    *
-   * @param eventType - The type of WebSocket event to emit.
-   * @param data - The data associated with the event.
+   * @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.
+   */
+  async play(options, playback) {
+    if (!playback) {
+      playback = this.client.Playback();
+    }
+    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.
+   */
+  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(baseClient, client, channelId) {
+    super();
+    this.baseClient = baseClient;
+    this.client = client;
+    this.channelId = channelId;
+  }
+  /**
+   * Cria uma nova instância de `ChannelInstance` sem originar um canal físico.
+   */
+  createChannelInstance(channelId) {
+    return new ChannelInstance(this.client, this.baseClient, channelId);
+  }
+  /**
+   * Origina um canal físico diretamente, sem uma instância de `ChannelInstance`.
+   */
+  async originate(data) {
+    return this.baseClient.post("/channels", data);
+  }
+  /**
+   * Lida com eventos relacionados ao canal e os emite para listeners registrados.
    */
   emitChannelEvent(eventType, data) {
     if ("channel" in data) {
@@ -867,149 +956,184 @@ var Channels = class extends EventEmitter {
     this.emit(eventType, data);
   }
   /**
-   * Registers a listener for a specific channel-related event.
-   *
-   * @param eventType - The type of WebSocket event to listen for.
-   * @param channelId - The ID of the channel to listen for.
-   * @param callback - The callback function to execute when the event occurs.
+   * Registra um listener para eventos de canal específicos.
    */
   registerChannelListener(eventType, channelId, callback) {
     this.on(`${eventType}:${channelId}`, callback);
   }
   /**
-   * Unregisters a listener for a specific channel-related event.
-   *
-   * @param eventType - The type of WebSocket event to stop listening for.
-   * @param channelId - The ID of the channel to stop listening for.
-   * @param callback - The callback function to remove.
+   * Remove um listener específico de eventos de canal.
    */
   unregisterChannelListener(eventType, channelId, callback) {
     this.off(`${eventType}:${channelId}`, callback);
   }
   /**
-   * Checks if a listener is already registered for a specific channel event.
-   *
-   * @param eventType - The type of event to check.
-   * @param channelId - The channel ID associated with the listener.
-   * @returns True if a listener is already registered, false otherwise.
+   * Verifica se um listener já está registrado para um evento de canal.
    */
   isChannelListenerRegistered(eventType, channelId) {
     return this.listenerCount(`${eventType}:${channelId}`) > 0;
   }
   /**
-   * Lists all active channels.
+   * Lista todos os canais ativos.
    */
   async list() {
-    const channels = await this.client.get("/channels");
+    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;
   }
   /**
-   * Creates a new channel.
-   */
-  async originate(data) {
-    return this.client.post("/channels", data);
-  }
-  /**
-   * Retrieves details of a specific channel.
+   * Obtém detalhes de um canal específico.
    */
   async getDetails(channelId) {
-    return this.client.get(`/channels/${channelId}`);
-  }
-  /**
-   * Creates a channel and places it in a Stasis app without dialing it.
-   */
-  async createChannel(data) {
-    return this.client.post("/channels/create", data);
+    return this.baseClient.get(`/channels/${channelId}`);
   }
   /**
-   * Creates a new channel with a specific ID and originates a call.
+   * Reproduz mídia em um canal.
    */
-  async originateWithId(channelId, data) {
-    return this.client.post(`/channels/${channelId}`, data);
+  async playMedia(channelId, media, options) {
+    const queryParams = options ? `?${new URLSearchParams(options).toString()}` : "";
+    return this.baseClient.post(
+      `/channels/${channelId}/play${queryParams}`,
+      { media }
+    );
   }
   /**
-   * Hangs up (terminates) a specific channel.
-   */
-  /**
-   * Hangs up a specific channel with optional reason or reason code.
+   * Encerra um canal específico.
    */
   async hangup(channelId, options) {
     const queryParams = new URLSearchParams({
       ...options?.reason_code && { reason_code: options.reason_code },
       ...options?.reason && { reason: options.reason }
     });
-    return this.client.delete(
+    return this.baseClient.delete(
       `/channels/${channelId}?${queryParams.toString()}`
     );
   }
   /**
-   * 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.baseClient.post(
+      `/channels/${channelId}/snoop?${queryParams}`
+    );
+  }
+  async startSilence(channelId) {
+    return this.baseClient.post(`/channels/${channelId}/silence`);
+  }
+  async stopSilence(channelId) {
+    return this.baseClient.delete(`/channels/${channelId}/silence`);
+  }
+  async getRTPStatistics(channelId) {
+    return this.baseClient.get(
+      `/channels/${channelId}/rtp_statistics`
+    );
+  }
+  async createExternalMedia(options) {
+    const queryParams = new URLSearchParams(options);
+    return this.baseClient.post(
+      `/channels/externalMedia?${queryParams.toString()}`
+    );
+  }
+  async playWithId(channelId, playbackId, media, options) {
+    const queryParams = options ? `?${new URLSearchParams(options).toString()}` : "";
+    return this.baseClient.post(
+      `/channels/${channelId}/play/${playbackId}${queryParams}`,
+      { media }
+    );
+  }
+  async snoopChannelWithId(channelId, snoopId, options) {
+    const queryParams = new URLSearchParams(options);
+    return this.baseClient.post(
+      `/channels/${channelId}/snoop/${snoopId}?${queryParams.toString()}`
+    );
+  }
+  async startMohWithClass(channelId, mohClass) {
+    const queryParams = `mohClass=${encodeURIComponent(mohClass)}`;
+    return 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.");
+    }
+    return this.baseClient.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.baseClient.post(
+      `/channels/${channelId}/variable?${queryParams.toString()}`
+    );
   }
   /**
    * Moves the channel to another Stasis application.
    */
   async moveToApplication(channelId, app, appArgs) {
-    return this.client.post(`/channels/${channelId}/move`, {
+    return this.baseClient.post(`/channels/${channelId}/move`, {
       app,
       appArgs
     });
   }
   /**
-   * 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.baseClient.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.baseClient.delete(`/channels/${channelId}/moh`);
   }
   /**
    * Starts music on hold (MOH) for a channel.
    */
   async startMusicOnHold(channelId) {
-    return this.client.post(`/channels/${channelId}/moh`);
+    return this.baseClient.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.
    */
   async startPlayback(channelId, media, options) {
     const queryParams = options ? `?${new URLSearchParams(options).toString()}` : "";
-    return this.client.post(
+    return this.baseClient.post(
       `/channels/${channelId}/play${queryParams}`,
       { media }
     );
@@ -1018,7 +1142,7 @@ var Channels = class extends EventEmitter {
    * Stops playback of a media file on a channel.
    */
   async stopPlayback(channelId, playbackId) {
-    return this.client.delete(
+    return this.baseClient.delete(
       `/channels/${channelId}/play/${playbackId}`
     );
   }
@@ -1026,7 +1150,7 @@ var Channels = class extends EventEmitter {
    * Pauses playback of a media file on a channel.
    */
   async pausePlayback(channelId, playbackId) {
-    return this.client.post(
+    return this.baseClient.post(
       `/channels/${channelId}/play/${playbackId}/pause`
     );
   }
@@ -1034,7 +1158,7 @@ var Channels = class extends EventEmitter {
    * Resumes playback of a media file on a channel.
    */
   async resumePlayback(channelId, playbackId) {
-    return this.client.delete(
+    return this.baseClient.delete(
       `/channels/${channelId}/play/${playbackId}/pause`
     );
   }
@@ -1042,7 +1166,7 @@ var Channels = class extends EventEmitter {
    * Rewinds playback of a media file on a channel.
    */
   async rewindPlayback(channelId, playbackId, skipMs) {
-    return this.client.post(
+    return this.baseClient.post(
       `/channels/${channelId}/play/${playbackId}/rewind`,
       { skipMs }
     );
@@ -1051,7 +1175,7 @@ var Channels = class extends EventEmitter {
    * Fast-forwards playback of a media file on a channel.
    */
   async fastForwardPlayback(channelId, playbackId, skipMs) {
-    return this.client.post(
+    return this.baseClient.post(
       `/channels/${channelId}/play/${playbackId}/forward`,
       { skipMs }
     );
@@ -1065,28 +1189,10 @@ var Channels = class extends EventEmitter {
         ([, value]) => value !== void 0
       )
     );
-    return this.client.post(
+    return this.baseClient.post(
       `/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.
    */
@@ -1095,30 +1201,15 @@ var Channels = class extends EventEmitter {
       ...caller && { caller },
       ...timeout && { timeout: timeout.toString() }
     });
-    return this.client.post(
+    return this.baseClient.post(
       `/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.
    */
   async redirectChannel(channelId, endpoint) {
-    return this.client.post(
+    return this.baseClient.post(
       `/channels/${channelId}/redirect?endpoint=${encodeURIComponent(endpoint)}`
     );
   }
@@ -1126,19 +1217,19 @@ var Channels = class extends EventEmitter {
    * Answers a channel.
    */
   async answerChannel(channelId) {
-    return this.client.post(`/channels/${channelId}/answer`);
+    return this.baseClient.post(`/channels/${channelId}/answer`);
   }
   /**
    * Sends a ringing indication to a channel.
    */
   async ringChannel(channelId) {
-    return this.client.post(`/channels/${channelId}/ring`);
+    return this.baseClient.post(`/channels/${channelId}/ring`);
   }
   /**
    * Stops ringing indication on a channel.
    */
   async stopRingChannel(channelId) {
-    return this.client.delete(`/channels/${channelId}/ring`);
+    return this.baseClient.delete(`/channels/${channelId}/ring`);
   }
   /**
    * Sends DTMF to a channel.
@@ -1151,7 +1242,7 @@ var Channels = class extends EventEmitter {
       ...options?.duration && { duration: options.duration.toString() },
       ...options?.after && { after: options.after.toString() }
     });
-    return this.client.post(
+    return this.baseClient.post(
       `/channels/${channelId}/dtmf?${queryParams.toString()}`
     );
   }
@@ -1159,7 +1250,7 @@ var Channels = class extends EventEmitter {
    * Mutes a channel.
    */
   async muteChannel(channelId, direction = "both") {
-    return this.client.post(
+    return this.baseClient.post(
       `/channels/${channelId}/mute?direction=${direction}`
     );
   }
@@ -1167,7 +1258,7 @@ var Channels = class extends EventEmitter {
    * Unmutes a channel.
    */
   async unmuteChannel(channelId, direction = "both") {
-    return this.client.delete(
+    return this.baseClient.delete(
       `/channels/${channelId}/mute?direction=${direction}`
     );
   }
@@ -1175,13 +1266,25 @@ var Channels = class extends EventEmitter {
    * Puts a channel on hold.
    */
   async holdChannel(channelId) {
-    return this.client.post(`/channels/${channelId}/hold`);
+    return this.baseClient.post(`/channels/${channelId}/hold`);
   }
   /**
    * Removes a channel from hold.
    */
   async unholdChannel(channelId) {
-    return this.client.delete(`/channels/${channelId}/hold`);
+    return 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);
   }
 };
 
@@ -1233,11 +1336,96 @@ 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(baseClient, playbackId) {
+    super();
+    this.baseClient = baseClient;
+    this.playbackId = playbackId;
+    this.id = playbackId || `playback-${Date.now()}`;
+  }
+  playbackData = null;
+  id;
+  /**
+   * 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.baseClient.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.baseClient.post(`/playbacks/${this.playbackId}/control`, {
+      operation
+    });
+  }
+  /**
+   * Encerra o playback.
+   */
+  async stop() {
+    if (!this.playbackId) {
+      throw new Error("Nenhum playback associado para encerrar.");
+    }
+    await this.baseClient.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) {
+    const id = playbackId || `playback-${Date.now()}`;
+    return new PlaybackInstance(this.client, id);
+  }
+  /**
+   * 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.
    *
@@ -1305,19 +1493,6 @@ var Playbacks = class extends EventEmitter2 {
   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
@@ -1482,7 +1657,7 @@ var AriClient = class {
     const normalizedHost = config.host.replace(/^https?:\/\//, "");
     const baseUrl = `${httpProtocol}://${normalizedHost}:${config.port}/ari`;
     this.baseClient = new BaseClient(baseUrl, config.username, config.password);
-    this.channels = new Channels(this.baseClient);
+    this.channels = new Channels(this.baseClient, this);
     this.endpoints = new Endpoints(this.baseClient);
     this.applications = new Applications(this.baseClient);
     this.playbacks = new Playbacks(this.baseClient);
@@ -1817,13 +1992,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.
@@ -2294,6 +2469,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,