@ipcom/asterisk-ari 0.0.139 → 0.0.141

package/dist/esm/index.js

@@ -571,30 +571,55 @@ var require_backoff = __commonJS({
 });
 
 // src/ari-client/baseClient.ts
-import axios from "axios";
+import axios, {
+  isAxiosError
+} from "axios";
+var HTTPError = class extends Error {
+  constructor(message, status, method, url) {
+    super(message);
+    this.status = status;
+    this.method = method;
+    this.url = url;
+    this.name = "HTTPError";
+  }
+};
 var BaseClient = class {
+  /**
+   * Creates a new BaseClient instance.
+   *
+   * @param {string} baseUrl - The base URL for the API
+   * @param {string} username - Username for authentication
+   * @param {string} password - Password for authentication
+   * @param {number} [timeout=5000] - Request timeout in milliseconds
+   * @throws {Error} If the base URL format is invalid
+   */
   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://"
-      );
+      throw new Error("Invalid base URL. It must start with http:// or https://");
     }
     this.client = axios.create({
       baseURL: baseUrl,
       auth: { username, password },
-      timeout
+      timeout,
+      headers: {
+        "Content-Type": "application/json"
+      }
     });
     this.addInterceptors();
+    console.log(`BaseClient initialized for ${baseUrl}`);
   }
   client;
+  /**
+   * Gets the base URL of the client.
+   */
   getBaseUrl() {
     return this.baseUrl;
   }
   /**
-   * Retorna as credenciais configuradas.
+   * Gets the configured credentials.
    */
   getCredentials() {
     return {
@@ -604,123 +629,159 @@ var BaseClient = class {
     };
   }
   /**
-   * Adds interceptors to the Axios instance.
+   * Adds request and response interceptors to the Axios instance.
    */
   addInterceptors() {
     this.client.interceptors.request.use(
       (config) => {
+        console.log(`[Request] ${config.method?.toUpperCase()} ${config.url}`);
         return config;
       },
       (error) => {
-        console.error("[Request Error]", error.message);
-        return Promise.reject(error);
+        const message = this.getErrorMessage(error);
+        console.error("[Request Error]", message);
+        return Promise.reject(new HTTPError(message));
       }
     );
     this.client.interceptors.response.use(
-      (response) => response,
+      (response) => {
+        console.log(`[Response] ${response.status} ${response.config.url}`);
+        return 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}`
-          );
+        if (isAxiosError(error)) {
+          const status = error.response?.status ?? 0;
+          const method = error.config?.method?.toUpperCase() ?? "UNKNOWN";
+          const url = error.config?.url ?? "unknown-url";
+          const message2 = error.response?.data?.message || error.message || "Unknown error";
+          if (status === 404) {
+            console.warn(`[404] Not Found: ${url}`);
+          } else if (status >= 500) {
+            console.error(`[${status}] Server Error: ${url}`);
+          } else if (status > 0) {
+            console.warn(`[${status}] ${method} ${url}: ${message2}`);
+          } else {
+            console.error(`[Network] Request failed: ${message2}`);
+          }
+          throw new HTTPError(message2, status || void 0, method, url);
         }
-        return Promise.reject(
-          new Error(
-            `[Error] ${errorDetails.method} ${errorDetails.url} - ${message} (Status: ${status})`
-          )
-        );
+        const message = this.getErrorMessage(error);
+        console.error("[Unexpected Error]", message);
+        throw new Error(message);
       }
     );
   }
   /**
    * Executes a GET request.
-   * @param path - The API endpoint path.
-   * @param config - Optional Axios request configuration.
+   *
+   * @param path - API endpoint path
+   * @param config - Optional Axios request configuration
+   * @returns Promise with the response data
    */
   async get(path, config) {
     try {
       const response = await this.client.get(path, config);
       return response.data;
     } catch (error) {
-      this.handleRequestError(error);
+      throw 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.
+   *
+   * @param path - API endpoint path
+   * @param data - Request payload
+   * @param config - Optional Axios request configuration
+   * @returns Promise with the 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);
+      throw 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.
+   *
+   * @param path - API endpoint path
+   * @param data - Request payload
+   * @param config - Optional Axios request configuration
+   * @returns Promise with the 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);
+      throw this.handleRequestError(error);
     }
   }
   /**
    * Executes a DELETE request.
-   * @param path - The API endpoint path.
-   * @param config - Optional Axios request configuration.
+   *
+   * @param path - API endpoint path
+   * @param config - Optional Axios request configuration
+   * @returns Promise with the response data
    */
   async delete(path, config) {
     try {
       const response = await this.client.delete(path, config);
       return response.data;
     } catch (error) {
-      this.handleRequestError(error);
+      throw this.handleRequestError(error);
+    }
+  }
+  /**
+   * Handles and formats error messages from various error types.
+   */
+  getErrorMessage(error) {
+    if (isAxiosError(error)) {
+      return error.response?.data?.message || error.message || "HTTP Error";
     }
+    if (error instanceof Error) {
+      return error.message;
+    }
+    return "An unknown error occurred";
   }
   /**
-   * Handles errors for HTTP requests.
-   * @param error - The error to handle.
+   * Handles errors from HTTP requests.
    */
   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;
+    const message = this.getErrorMessage(error);
+    if (isAxiosError(error)) {
+      throw new HTTPError(
+        message,
+        error.response?.status,
+        error.config?.method?.toUpperCase(),
+        error.config?.url
+      );
     }
+    throw new Error(message);
   }
   /**
    * 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
     };
+    console.log("Updated client headers");
+  }
+  /**
+   * Gets the current request timeout setting.
+   */
+  getTimeout() {
+    return this.client.defaults.timeout || 5e3;
+  }
+  /**
+   * Updates the request timeout setting.
+   */
+  setTimeout(timeout) {
+    this.client.defaults.timeout = timeout;
+    console.log(`Updated timeout to ${timeout}ms`);
   }
 };
 
@@ -944,6 +1005,7 @@ var Bridges = class {
 
 // src/ari-client/resources/channels.ts
 import { EventEmitter } from "events";
+import { isAxiosError as isAxiosError2 } from "axios";
 
 // node_modules/uuid/dist/esm/stringify.js
 var byteToHex = [];
@@ -998,102 +1060,212 @@ function toQueryParams2(options) {
 }
 
 // src/ari-client/resources/channels.ts
+var getErrorMessage = (error) => {
+  if (isAxiosError2(error)) {
+    return error.response?.data?.message || error.message || "An axios error occurred";
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return "An unknown error occurred";
+};
 var ChannelInstance = class {
-  // ID do canal
-  constructor(client, baseClient, channelId = `channel-${Date.now()}`) {
+  constructor(client, baseClient, channelId) {
     this.client = client;
     this.baseClient = baseClient;
-    this.channelId = channelId;
     this.id = channelId || `channel-${Date.now()}`;
+    console.log(`Channel instance initialized with ID: ${this.id}`);
   }
   eventEmitter = new EventEmitter();
   channelData = null;
   id;
   /**
-   * Registra um listener para eventos específicos deste canal.
+   * Registers an event listener for specific channel events
    */
   on(event, listener) {
+    if (!event) {
+      throw new Error("Event type is required");
+    }
     const wrappedListener = (data) => {
       if ("channel" in data && data.channel?.id === this.id) {
         listener(data);
       }
     };
     this.eventEmitter.on(event, wrappedListener);
+    console.log(`Event listener registered for ${event} on channel ${this.id}`);
   }
   /**
-   * Registra um listener único para eventos específicos deste canal.
+   * Registers a one-time event listener
    */
   once(event, listener) {
+    if (!event) {
+      throw new Error("Event type is required");
+    }
     const wrappedListener = (data) => {
       if ("channel" in data && data.channel?.id === this.id) {
         listener(data);
       }
     };
     this.eventEmitter.once(event, wrappedListener);
+    console.log(
+      `One-time event listener registered for ${event} on channel ${this.id}`
+    );
   }
   /**
-   * Remove um listener para eventos específicos deste canal.
+   * Removes event listener(s) for a specific WebSocket event type.
+   * If a specific listener is provided, only that listener is removed.
+   * Otherwise, all listeners for the given event type are removed.
+   *
+   * @param {T} event - The type of WebSocket event to remove listener(s) for
+   * @param {Function} [listener] - Optional specific listener to remove
+   * @throws {Error} If no event type is provided
    */
   off(event, listener) {
+    if (!event) {
+      throw new Error("Event type is required");
+    }
     if (listener) {
       this.eventEmitter.off(event, listener);
+      console.log(
+        `Specific listener removed for ${event} on channel ${this.id}`
+      );
     } else {
-      const listeners = this.eventEmitter.listeners(event);
-      listeners.forEach((fn) => {
-        this.eventEmitter.off(event, fn);
-      });
+      this.eventEmitter.removeAllListeners(event);
+      console.log(`All listeners removed for ${event} on channel ${this.id}`);
     }
   }
   /**
-   * 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.
+   * Emits an event if it matches the current channel
    */
   emitEvent(event) {
+    if (!event) {
+      console.warn("Received invalid event");
+      return;
+    }
     if ("channel" in event && event.channel?.id === this.id) {
       this.eventEmitter.emit(event.type, event);
+      console.log(`Event ${event.type} emitted for channel ${this.id}`);
     }
   }
   /**
-   * Remove todos os listeners para este canal.
+   * Removes all event listeners associated with the current instance.
+   * This ensures that there are no lingering event handlers for the channel.
+   *
+   * @return {void} This method does not return a value.
    */
   removeAllListeners() {
     console.log(`Removendo todos os listeners para o canal ${this.id}`);
     this.eventEmitter.removeAllListeners();
   }
+  /**
+   * Answers the channel
+   */
   async answer() {
-    await this.baseClient.post(`/channels/${this.id}/answer`);
+    try {
+      await this.baseClient.post(`/channels/${this.id}/answer`);
+      console.log(`Channel ${this.id} answered`);
+    } catch (error) {
+      const message = getErrorMessage(error);
+      console.error(`Error answering channel ${this.id}:`, message);
+      throw new Error(`Failed to answer channel: ${message}`);
+    }
   }
   /**
-   * Origina um canal físico no Asterisk.
+   * Originates a new channel
+   *
+   * @param data - Channel origination configuration
+   * @returns Promise resolving to the created channel
+   * @throws Error if channel already exists or origination fails
    */
   async originate(data) {
     if (this.channelData) {
-      throw new Error("O canal j\xE1 foi criado.");
+      throw new Error("Channel has already been created");
+    }
+    try {
+      this.channelData = await this.baseClient.post(
+        "/channels",
+        data
+      );
+      console.log(
+        `Channel originated successfully with ID: ${this.channelData.id}`
+      );
+      return this.channelData;
+    } catch (error) {
+      const message = getErrorMessage(error);
+      console.error(`Error originating channel:`, message);
+      throw new Error(`Failed to originate channel: ${message}`);
     }
-    const channel = await this.baseClient.post("/channels", data);
-    this.channelData = channel;
-    return channel;
   }
   /**
-   * Obtém os detalhes do canal.
+   * Plays media on the channel
    */
-  async getDetails() {
-    if (this.channelData) {
-      return this.channelData;
+  async play(options, playbackId) {
+    if (!options.media) {
+      throw new Error("Media URL is required");
     }
-    if (!this.id) {
-      throw new Error("Nenhum ID de canal associado a esta inst\xE2ncia.");
+    try {
+      if (!this.channelData) {
+        console.log("Initializing channel details...");
+        this.channelData = await this.getDetails();
+      }
+      const playback = this.client.Playback(playbackId || v4_default());
+      await this.baseClient.post(
+        `/channels/${this.id}/play/${playback.id}`,
+        options
+      );
+      console.log(`Media playback started on channel ${this.id}`);
+      return playback;
+    } catch (error) {
+      const message = getErrorMessage(error);
+      console.error(`Error playing media on channel ${this.id}:`, message);
+      throw new Error(`Failed to play media: ${message}`);
+    }
+  }
+  /**
+   * Gets the current channel details
+   */
+  async getDetails() {
+    try {
+      if (this.channelData) {
+        return this.channelData;
+      }
+      if (!this.id) {
+        throw new Error("No channel ID associated with this instance");
+      }
+      const details = await this.baseClient.get(
+        `/channels/${this.id}`
+      );
+      this.channelData = details;
+      console.log(`Retrieved channel details for ${this.id}`);
+      return details;
+    } catch (error) {
+      const message = getErrorMessage(error);
+      console.error(
+        `Error retrieving channel details for ${this.id}:`,
+        message
+      );
+      throw new Error(`Failed to get channel details: ${message}`);
     }
-    const details = await this.baseClient.get(`/channels/${this.id}`);
-    this.channelData = details;
-    return details;
   }
+  /**
+   * Checks if the channel has any listeners for a specific event
+   */
+  hasListeners(event) {
+    return this.eventEmitter.listenerCount(event) > 0;
+  }
+  /**
+   * Gets the count of listeners for a specific event
+   */
+  getListenerCount(event) {
+    return this.eventEmitter.listenerCount(event);
+  }
+  /**
+   * Fetches a specific channel variable.
+   *
+   * @param {string} variable - The name of the variable to retrieve. This parameter is required.
+   * @return {Promise<ChannelVar>} A promise that resolves with the value of the requested channel variable.
+   * @throws {Error} If the 'variable' parameter is not provided.
+   */
   async getVariable(variable) {
     if (!variable) {
       throw new Error("The 'variable' parameter is required.");
@@ -1103,7 +1275,11 @@ var ChannelInstance = class {
     );
   }
   /**
-   * Encerra o canal, se ele já foi criado.
+   * Terminates the active call associated with the current channel.
+   * This method ensures that channel details are initialized before attempting to hang up.
+   * If the channel ID is invalid or cannot be determined, an error is thrown.
+   *
+   * @return {Promise<void>} A promise that resolves when the call is successfully terminated.
    */
   async hangup() {
     if (!this.channelData) {
@@ -1116,25 +1292,12 @@ var ChannelInstance = class {
     await this.baseClient.delete(`/channels/${this.channelData.id}`);
   }
   /**
-   * Reproduz mídia no canal.
-   */
-  async play(options, playbackId) {
-    if (!this.channelData) {
-      console.log("Canal n\xE3o inicializado, buscando detalhes...");
-      this.channelData = await this.getDetails();
-    }
-    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.");
-    }
-    await this.baseClient.post(
-      `/channels/${this.channelData.id}/play/${playback.id}`,
-      options
-    );
-    return playback;
-  }
-  /**
-   * Reproduz mídia em um canal.
+   * Plays media on the specified channel using the provided media URL and optional playback options.
+   *
+   * @param {string} media - The URL or identifier of the media to be played.
+   * @param {PlaybackOptions} [options] - Optional playback settings such as volume, playback speed, etc.
+   * @return {Promise<ChannelPlayback>} A promise that resolves with the playback details for the channel.
+   * @throws {Error} Throws an error if the channel has not been created.
    */
   async playMedia(media, options) {
     if (!this.channelData) {
@@ -1147,7 +1310,11 @@ var ChannelInstance = class {
     );
   }
   /**
-   * Para a reprodução de mídia.
+   * Stops the playback for the given playback ID.
+   *
+   * @param {string} playbackId - The unique identifier for the playback to be stopped.
+   * @return {Promise<void>} A promise that resolves when the playback is successfully stopped.
+   * @throws {Error} Throws an error if the instance is not associated with a channel.
    */
   async stopPlayback(playbackId) {
     if (!this.channelData?.id) {
@@ -1158,7 +1325,11 @@ var ChannelInstance = class {
     );
   }
   /**
-   * Pausa a reprodução de mídia.
+   * Pauses the playback of the specified media on a channel.
+   *
+   * @param {string} playbackId - The unique identifier of the playback to be paused.
+   * @return {Promise<void>} A promise that resolves when the playback has been successfully paused.
+   * @throws {Error} Throws an error if the channel is not associated with the current instance.
    */
   async pausePlayback(playbackId) {
     if (!this.channelData?.id) {
@@ -1169,7 +1340,11 @@ var ChannelInstance = class {
     );
   }
   /**
-   * Retoma a reprodução de mídia.
+   * Resumes playback of the specified playback session on the associated channel.
+   *
+   * @param {string} playbackId - The unique identifier of the playback session to be resumed.
+   * @return {Promise<void>} A promise that resolves when the playback has been successfully resumed.
+   * @throws {Error} Throws an error if the channel is not associated with this instance.
    */
   async resumePlayback(playbackId) {
     if (!this.channelData?.id) {
@@ -1180,7 +1355,11 @@ var ChannelInstance = class {
     );
   }
   /**
-   * Retrocede a reprodução de mídia.
+   * Rewinds the playback of a media by a specified amount of milliseconds.
+   *
+   * @param {string} playbackId - The unique identifier for the playback session to be rewound.
+   * @param {number} skipMs - The number of milliseconds to rewind the playback.
+   * @return {Promise<void>} A promise that resolves when the rewind operation is complete.
    */
   async rewindPlayback(playbackId, skipMs) {
     if (!this.channelData?.id) {
@@ -1192,7 +1371,12 @@ var ChannelInstance = class {
     );
   }
   /**
-   * Avança a reprodução de mídia.
+   * Fast forwards the playback by a specific duration in milliseconds.
+   *
+   * @param {string} playbackId - The unique identifier of the playback to be fast-forwarded.
+   * @param {number} skipMs - The number of milliseconds to fast forward the playback.
+   * @return {Promise<void>} A Promise that resolves when the fast-forward operation is complete.
+   * @throws {Error} If no channel is associated with this instance.
    */
   async fastForwardPlayback(playbackId, skipMs) {
     if (!this.channelData?.id) {
@@ -1204,7 +1388,11 @@ var ChannelInstance = class {
     );
   }
   /**
-   * Muta o canal.
+   * Mutes the specified channel for the given direction.
+   *
+   * @param {("both" | "in" | "out")} [direction="both"] - The direction to mute the channel. It can be "both" to mute incoming and outgoing, "in" to mute incoming, or "out" to mute outgoing.
+   * @return {Promise<void>} A promise that resolves when the channel is successfully muted.
+   * @throws {Error} If the channel is not associated with this instance.
    */
   async muteChannel(direction = "both") {
     if (!this.channelData?.id) {
@@ -1215,7 +1403,12 @@ var ChannelInstance = class {
     );
   }
   /**
-   * Desmuta o canal.
+   * Unmutes a previously muted channel in the specified direction.
+   *
+   * @param {"both" | "in" | "out"} direction - The direction in which to unmute the channel.
+   *        Defaults to "both", which unmutes both incoming and outgoing communication.
+   * @return {Promise<void>} A promise that resolves once the channel has been successfully unmuted.
+   * @throws {Error} If the channel is not associated with the current instance.
    */
   async unmuteChannel(direction = "both") {
     if (!this.channelData?.id) {
@@ -1226,7 +1419,10 @@ var ChannelInstance = class {
     );
   }
   /**
-   * Coloca o canal em espera.
+   * Places the associated channel on hold if the channel is valid and linked to this instance.
+   *
+   * @return {Promise<void>} A promise that resolves when the hold action is successfully executed.
+   * @throws {Error} Throws an error if the channel is not associated with this instance.
    */
   async holdChannel() {
     if (!this.channelData?.id) {
@@ -1235,7 +1431,12 @@ var ChannelInstance = class {
     await this.baseClient.post(`/channels/${this.channelData.id}/hold`);
   }
   /**
-   * Remove o canal da espera.
+   * Removes the hold status from a specific channel associated with this instance.
+   * The method sends a delete request to the server to release the hold on the channel.
+   * If no channel is associated with this instance, an error will be thrown.
+   *
+   * @return {Promise<void>} A promise that resolves when the channel hold has been successfully removed.
+   * @throws {Error} If no channel is associated with this instance.
    */
   async unholdChannel() {
     if (!this.channelData?.id) {
@@ -1250,73 +1451,140 @@ var Channels = class {
     this.client = client;
   }
   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;
+  /**
+   * Creates or retrieves a ChannelInstance.
+   *
+   * @param {Object} [params] - Optional parameters for getting/creating a channel instance
+   * @param {string} [params.id] - Optional ID of an existing channel
+   * @returns {ChannelInstance} The requested or new channel instance
+   * @throws {Error} If channel creation/retrieval fails
+   *
+   * @example
+   * // Create new channel without ID
+   * const channel1 = client.channels.Channel();
+   *
+   * // Create/retrieve channel with specific ID
+   * const channel2 = client.channels.Channel({ id: 'some-id' });
+   */
+  Channel(params) {
+    try {
+      const id = params?.id;
+      if (!id) {
+        const instance = new ChannelInstance(this.client, this.baseClient);
+        this.channelInstances.set(instance.id, instance);
+        console.log(`New channel instance created with ID: ${instance.id}`);
+        return instance;
+      }
+      if (!this.channelInstances.has(id)) {
+        const instance = new ChannelInstance(this.client, this.baseClient, id);
+        this.channelInstances.set(id, instance);
+        console.log(`New channel instance created with provided ID: ${id}`);
+        return instance;
+      }
+      console.log(`Returning existing channel instance: ${id}`);
+      return this.channelInstances.get(id);
+    } catch (error) {
+      const message = getErrorMessage(error);
+      console.error(`Error creating/retrieving channel instance:`, message);
+      throw new Error(`Failed to manage channel instance: ${message}`);
     }
-    return this.channelInstances.get(id);
   }
   /**
-   * Remove uma instância de canal.
+   * Removes a channel instance from the collection.
    */
   removeChannelInstance(channelId) {
+    if (!channelId) {
+      throw new Error("Channel ID is required");
+    }
     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.`);
+      console.log(`Channel instance removed: ${channelId}`);
     } else {
-      console.warn(
-        `Tentativa de remover uma inst\xE2ncia inexistente: ${channelId}`
-      );
+      console.warn(`Attempt to remove non-existent instance: ${channelId}`);
     }
   }
   /**
-   * Propaga eventos do WebSocket para o canal correspondente.
+   * Propagates a WebSocket event to a specific channel.
    */
   propagateEventToChannel(event) {
+    if (!event) {
+      console.warn("Invalid WebSocket event received");
+      return;
+    }
     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}`
+        console.log(
+          `Event propagated to channel ${event.channel.id}: ${event.type}`
         );
+      } else {
+        console.warn(`No instance found for channel ${event.channel.id}`);
       }
     }
   }
   /**
-   * Origina um canal físico diretamente, sem uma instância de `ChannelInstance`.
+   * Initiates a new channel.
    */
   async originate(data) {
-    return this.baseClient.post("/channels", data);
+    if (!data.endpoint) {
+      throw new Error("Endpoint is required for channel origination");
+    }
+    try {
+      const channel = await this.baseClient.post("/channels", data);
+      console.log(`Channel originated successfully with ID: ${channel.id}`);
+      return channel;
+    } catch (error) {
+      const message = getErrorMessage(error);
+      console.error(`Error originating channel:`, message);
+      throw new Error(`Failed to originate channel: ${message}`);
+    }
   }
   /**
-   * Obtém detalhes de um canal específico.
+   * Lists all active channels.
    */
-  async getDetails(channelId) {
-    return this.baseClient.get(`/channels/${channelId}`);
+  async list() {
+    try {
+      const channels = await this.baseClient.get("/channels");
+      if (!Array.isArray(channels)) {
+        throw new Error("API response for /channels is not an array");
+      }
+      console.log(`Retrieved ${channels.length} active channels`);
+      return channels;
+    } catch (error) {
+      const message = getErrorMessage(error);
+      console.error(`Error listing channels:`, message);
+      throw new Error(`Failed to list channels: ${message}`);
+    }
   }
   /**
-   * Lista todos os canais ativos.
+   * Gets the count of active channel instances.
    */
-  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;
+  getInstanceCount() {
+    return this.channelInstances.size;
+  }
+  /**
+   * Checks if a channel instance exists.
+   */
+  hasInstance(channelId) {
+    return this.channelInstances.has(channelId);
+  }
+  /**
+   * Gets all active channel instances.
+   */
+  getAllInstances() {
+    return new Map(this.channelInstances);
   }
   /**
-   * Encerra um canal específico.
+   * Terminates an active call on the specified channel.
+   *
+   * @param {string} channelId - The unique identifier of the channel to hang up.
+   * @param {Object} [options] - Optional parameters for the hangup request.
+   * @param {string} [options.reason_code] - A code indicating the reason for the hangup.
+   * @param {string} [options.reason] - A descriptive reason for the hangup.
+   * @return {Promise<void>} A promise that resolves when the call has been successfully terminated.
    */
   async hangup(channelId, options) {
     const queryParams = new URLSearchParams({
@@ -1328,7 +1596,11 @@ var Channels = class {
     );
   }
   /**
-   * Inicia a escuta em um canal.
+   * Initiates snooping on a specified channel with the provided options.
+   *
+   * @param {string} channelId - The unique identifier of the channel to snoop on.
+   * @param {SnoopOptions} options - Configuration options for the snooping operation.
+   * @return {Promise<Channel>} A promise that resolves to the snooped channel data.
    */
   async snoopChannel(channelId, options) {
     const queryParams = toQueryParams2(options);
@@ -1336,23 +1608,56 @@ var Channels = class {
       `/channels/${channelId}/snoop?${queryParams}`
     );
   }
+  /**
+   * Starts a silence mode for the specified channel.
+   *
+   * @param {string} channelId - The unique identifier of the channel where silence mode should be started.
+   * @return {Promise<void>} A promise that resolves when the silence mode is successfully started.
+   */
   async startSilence(channelId) {
     return this.baseClient.post(`/channels/${channelId}/silence`);
   }
+  /**
+   * Stops the silence mode for a specific channel.
+   *
+   * @param {string} channelId - The unique identifier of the channel for which silence mode should be stopped.
+   * @return {Promise<void>} A promise that resolves when the operation is complete.
+   */
   async stopSilence(channelId) {
     return this.baseClient.delete(`/channels/${channelId}/silence`);
   }
+  /**
+   * Retrieves the Real-Time Protocol (RTP) statistics for a specific channel.
+   *
+   * @param {string} channelId - The unique identifier of the channel for which RTP statistics are fetched.
+   * @return {Promise<RTPStats>} A promise that resolves to the RTP statistics for the specified channel.
+   */
   async getRTPStatistics(channelId) {
     return this.baseClient.get(
       `/channels/${channelId}/rtp_statistics`
     );
   }
+  /**
+   * Creates an external media channel with the given options.
+   *
+   * @param {ExternalMediaOptions} options - The configuration options for creating the external media channel.
+   * @return {Promise<Channel>} A promise that resolves with the created external media channel.
+   */
   async createExternalMedia(options) {
     const queryParams = toQueryParams2(options);
     return this.baseClient.post(
       `/channels/externalMedia?${queryParams}`
     );
   }
+  /**
+   * Initiates playback of a specific media item on a channel using the provided playback ID.
+   *
+   * @param {string} channelId - The unique identifier of the channel where playback will occur.
+   * @param {string} playbackId - The unique identifier for the specific playback session.
+   * @param {string} media - The media content to be played.
+   * @param {PlaybackOptions} [options] - Optional playback configuration parameters.
+   * @return {Promise<ChannelPlayback>} A promise that resolves with the playback details for the channel.
+   */
   async playWithId(channelId, playbackId, media, options) {
     const queryParams = options ? `?${toQueryParams2(options)}` : "";
     return this.baseClient.post(
@@ -1360,18 +1665,41 @@ var Channels = class {
       { media }
     );
   }
+  /**
+   * Initiates a snoop operation on a specific channel using the provided channel ID and snoop ID.
+   *
+   * @param {string} channelId - The unique identifier of the channel to snoop on.
+   * @param {string} snoopId - The unique identifier for the snoop operation.
+   * @param {SnoopOptions} options - Additional options and parameters for the snoop operation.
+   * @return {Promise<Channel>} A promise that resolves to the channel details after the snoop operation is initiated.
+   */
   async snoopChannelWithId(channelId, snoopId, options) {
     const queryParams = toQueryParams2(options);
     return this.baseClient.post(
       `/channels/${channelId}/snoop/${snoopId}?${queryParams}`
     );
   }
+  /**
+   * Starts Music on Hold for the specified channel with the provided Music on Hold class.
+   *
+   * @param {string} channelId - The unique identifier of the channel.
+   * @param {string} mohClass - The Music on Hold class to be applied.
+   * @return {Promise<void>} A promise that resolves when the operation is complete.
+   */
   async startMohWithClass(channelId, mohClass) {
     const queryParams = `mohClass=${encodeURIComponent(mohClass)}`;
     await this.baseClient.post(
       `/channels/${channelId}/moh?${queryParams}`
     );
   }
+  /**
+   * Retrieves the value of a specified variable for a given channel.
+   *
+   * @param {string} channelId - The unique identifier of the channel.
+   * @param {string} variable - The name of the variable to retrieve.
+   * @return {Promise<ChannelVar>} A promise that resolves to the value of the channel variable.
+   * @throws {Error} Throws an error if the 'variable' parameter is not provided.
+   */
   async getChannelVariable(channelId, variable) {
     if (!variable) {
       throw new Error("The 'variable' parameter is required.");
@@ -1380,6 +1708,15 @@ var Channels = class {
       `/channels/${channelId}/variable?variable=${encodeURIComponent(variable)}`
     );
   }
+  /**
+   * Sets a variable for a specific channel.
+   *
+   * @param {string} channelId - The unique identifier of the channel.
+   * @param {string} variable - The name of the variable to be set. This parameter is required.
+   * @param {string} [value] - The value of the variable to be set. This parameter is optional.
+   * @return {Promise<void>} A promise that resolves when the variable is successfully set.
+   * @throws {Error} Throws an error if the `variable` parameter is not provided.
+   */
   async setChannelVariable(channelId, variable, value) {
     if (!variable) {
       throw new Error("The 'variable' parameter is required.");
@@ -1392,12 +1729,30 @@ var Channels = class {
       `/channels/${channelId}/variable?${queryParams}`
     );
   }
+  /**
+   * Moves a specified channel to the given application with optional arguments.
+   *
+   * @param {string} channelId - The unique identifier of the channel to be moved.
+   * @param {string} app - The target application to which the channel will be moved.
+   * @param {string} [appArgs] - Optional arguments to be passed to the target application.
+   * @return {Promise<void>} A promise that resolves when the operation is completed.
+   */
   async moveToApplication(channelId, app, appArgs) {
     await this.baseClient.post(`/channels/${channelId}/move`, {
       app,
       appArgs
     });
   }
+  /**
+   * Continues the execution of a dialplan for a specific channel.
+   *
+   * @param {string} channelId - The unique identifier of the channel.
+   * @param {string} [context] - The dialplan context to continue execution in, if specified.
+   * @param {string} [extension] - The dialplan extension to proceed with, if provided.
+   * @param {number} [priority] - The priority within the dialplan extension to resume at, if specified.
+   * @param {string} [label] - The label to start from within the dialplan, if given.
+   * @return {Promise<void>} Resolves when the dialplan is successfully continued.
+   */
   async continueDialplan(channelId, context, extension, priority, label) {
     await this.baseClient.post(`/channels/${channelId}/continue`, {
       context,
@@ -1406,18 +1761,45 @@ var Channels = class {
       label
     });
   }
+  /**
+   * Stops the music on hold for the specified channel.
+   *
+   * @param {string} channelId - The unique identifier of the channel where music on hold should be stopped.
+   * @return {Promise<void>} Resolves when the music on hold is successfully stopped.
+   */
   async stopMusicOnHold(channelId) {
     await this.baseClient.delete(`/channels/${channelId}/moh`);
   }
+  /**
+   * Initiates the music on hold for the specified channel.
+   *
+   * @param {string} channelId - The unique identifier of the channel where the music on hold will be started.
+   * @return {Promise<void>} A promise that resolves when the operation has been successfully invoked.
+   */
   async startMusicOnHold(channelId) {
     await this.baseClient.post(`/channels/${channelId}/moh`);
   }
+  /**
+   * Starts recording for a specific channel based on the provided options.
+   *
+   * @param {string} channelId - The unique identifier of the channel to start recording.
+   * @param {RecordingOptions} options - The recording options to configure the recording process.
+   * @return {Promise<Channel>} A promise that resolves to the channel object with updated recording state.
+   */
   async record(channelId, options) {
     const queryParams = toQueryParams2(options);
     return this.baseClient.post(
       `/channels/${channelId}/record?${queryParams}`
     );
   }
+  /**
+   * Initiates a call on the specified channel with optional parameters for caller identification and timeout duration.
+   *
+   * @param {string} channelId - The ID of the channel where the call will be initiated.
+   * @param {string} [caller] - Optional parameter specifying the name or identifier of the caller.
+   * @param {number} [timeout] - Optional parameter defining the timeout duration for the call in seconds.
+   * @return {Promise<void>} A promise that resolves when the call has been successfully initiated.
+   */
   async dial(channelId, caller, timeout) {
     const queryParams = new URLSearchParams({
       ...caller && { caller },
@@ -1427,45 +1809,126 @@ var Channels = class {
       `/channels/${channelId}/dial?${queryParams}`
     );
   }
+  /**
+   * Redirects a channel to the specified endpoint.
+   *
+   * This method sends a POST request to update the redirect endpoint for the given channel.
+   *
+   * @param {string} channelId - The unique identifier of the channel to be redirected.
+   * @param {string} endpoint - The new endpoint to redirect the channel to.
+   * @return {Promise<void>} A promise that resolves when the operation is complete.
+   */
   async redirectChannel(channelId, endpoint) {
     await this.baseClient.post(
       `/channels/${channelId}/redirect?endpoint=${encodeURIComponent(endpoint)}`
     );
   }
+  /**
+   * Answers a specified channel by sending a POST request to the corresponding endpoint.
+   *
+   * @param {string} channelId - The unique identifier of the channel to be answered.
+   * @return {Promise<void>} A promise that resolves when the channel has been successfully answered.
+   */
   async answerChannel(channelId) {
     await this.baseClient.post(`/channels/${channelId}/answer`);
   }
+  /**
+   * Rings the specified channel by sending a POST request to the appropriate endpoint.
+   *
+   * @param {string} channelId - The unique identifier of the channel to be rung.
+   * @return {Promise<void>} A promise that resolves when the operation completes successfully.
+   */
   async ringChannel(channelId) {
     await this.baseClient.post(`/channels/${channelId}/ring`);
   }
+  /**
+   * Stops the ring channel for the specified channel ID.
+   *
+   * This method sends a DELETE request to the server to stop the ring action
+   * associated with the provided channel ID.
+   *
+   * @param {string} channelId - The unique identifier of the channel for which the ring action should be stopped.
+   * @return {Promise<void>} A promise that resolves when the ring channel is successfully stopped.
+   */
   async stopRingChannel(channelId) {
     await this.baseClient.delete(`/channels/${channelId}/ring`);
   }
+  /**
+   * Sends DTMF (Dual-Tone Multi-Frequency) signals to a specified channel.
+   *
+   * @param {string} channelId - The ID of the channel to which the DTMF signals should be sent.
+   * @param {string} dtmf - The DTMF tones to be sent, represented as a string. Each character corresponds to a specific tone.
+   * @param {Object} [options] - Optional configuration for the DTMF signal timing.
+   * @param {number} [options.before] - Time in milliseconds to wait before sending the first DTMF tone.
+   * @param {number} [options.between] - Time in milliseconds to wait between sending successive DTMF tones.
+   * @param {number} [options.duration] - Duration in milliseconds for each DTMF tone.
+   * @param {number} [options.after] - Time in milliseconds to wait after sending the last DTMF tone.
+   * @return {Promise<void>} A promise that resolves when the DTMF signals are successfully sent.
+   */
   async sendDTMF(channelId, dtmf, options) {
     const queryParams = toQueryParams2({ dtmf, ...options });
     await this.baseClient.post(
       `/channels/${channelId}/dtmf?${queryParams}`
     );
   }
+  /**
+   * Mutes a specified channel in the given direction.
+   *
+   * @param {string} channelId - The unique identifier of the channel to be muted.
+   * @param {"both" | "in" | "out"} [direction="both"] - The direction for muting, can be "both", "in", or "out". Default is "both".
+   * @return {Promise<void>} A promise that resolves when the channel is successfully muted.
+   */
   async muteChannel(channelId, direction = "both") {
     await this.baseClient.post(
       `/channels/${channelId}/mute?direction=${direction}`
     );
   }
+  /**
+   * Unmutes a previously muted channel, allowing communication in the specified direction(s).
+   *
+   * @param {string} channelId - The unique identifier of the channel to be unmuted.
+   * @param {"both" | "in" | "out"} [direction="both"] - The direction of communication to unmute. Valid options are "both", "in" (incoming messages), or "out" (outgoing messages). Defaults to "both".
+   * @return {Promise<void>} A promise that resolves when the channel is successfully unmuted.
+   */
   async unmuteChannel(channelId, direction = "both") {
     await this.baseClient.delete(
       `/channels/${channelId}/mute?direction=${direction}`
     );
   }
+  /**
+   * Places a specific channel on hold by sending a POST request to the server.
+   *
+   * @param {string} channelId - The unique identifier of the channel to be placed on hold.
+   * @return {Promise<void>} A promise that resolves when the channel hold operation is completed.
+   */
   async holdChannel(channelId) {
     await this.baseClient.post(`/channels/${channelId}/hold`);
   }
+  /**
+   * Removes the hold status from a specific channel by its ID.
+   *
+   * @param {string} channelId - The unique identifier of the channel to unhold.
+   * @return {Promise<void>} A promise that resolves when the channel hold is successfully removed.
+   */
   async unholdChannel(channelId) {
     await this.baseClient.delete(`/channels/${channelId}/hold`);
   }
+  /**
+   * Creates a new communication channel with the specified configuration.
+   *
+   * @param {OriginateRequest} data - The configuration data required to create the channel, including relevant details such as endpoint and channel variables.
+   * @return {Promise<Channel>} A promise that resolves with the details of the created channel.
+   */
   async createChannel(data) {
     return this.baseClient.post("/channels/create", data);
   }
+  /**
+   * Initiates a new channel with the specified channel ID and originates a call using the provided data.
+   *
+   * @param {string} channelId - The unique identifier of the channel to be created.
+   * @param {OriginateRequest} data - The data required to originate the call, including details such as endpoint and caller information.
+   * @return {Promise<Channel>} A promise that resolves to the created Channel object.
+   */
   async originateWithId(channelId, data) {
     return this.baseClient.post(`/channels/${channelId}`, data);
   }
@@ -1519,93 +1982,195 @@ var Endpoints = class {
 
 // src/ari-client/resources/playbacks.ts
 import { EventEmitter as EventEmitter2 } from "events";
+import { isAxiosError as isAxiosError3 } from "axios";
+var getErrorMessage2 = (error) => {
+  if (isAxiosError3(error)) {
+    return error.response?.data?.message || error.message || "An axios error occurred";
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return "An unknown error occurred";
+};
 var PlaybackInstance = class {
+  /**
+   * Creates a new PlaybackInstance.
+   *
+   * @param {AriClient} client - ARI client for communication
+   * @param {BaseClient} baseClient - Base client for HTTP requests
+   * @param {string} [playbackId] - Optional playback ID, generates timestamp-based ID if not provided
+   */
   constructor(client, baseClient, playbackId = `playback-${Date.now()}`) {
     this.client = client;
     this.baseClient = baseClient;
     this.playbackId = playbackId;
     this.id = playbackId;
+    console.log(`PlaybackInstance initialized with ID: ${this.id}`);
   }
   eventEmitter = new EventEmitter2();
   playbackData = null;
   id;
   /**
-   * Registra um listener para eventos específicos deste playback.
+   * Registers an event listener for a specific WebSocket event type.
+   *
+   * @param {T} event - Event type to listen for
+   * @param {Function} listener - Callback function for the event
    */
   on(event, listener) {
+    if (!event) {
+      throw new Error("Event type is required");
+    }
     const wrappedListener = (data) => {
       if ("playback" in data && data.playback?.id === this.id) {
         listener(data);
       }
     };
     this.eventEmitter.on(event, wrappedListener);
+    console.log(
+      `Event listener registered for ${event} on playback ${this.id}`
+    );
   }
   /**
-   * Registra um listener único para eventos específicos deste playback.
+   * Registers a one-time event listener for a specific WebSocket event type.
+   *
+   * @param {T} event - Event type to listen for
+   * @param {Function} listener - Callback function for the event
    */
   once(event, listener) {
+    if (!event) {
+      throw new Error("Event type is required");
+    }
     const wrappedListener = (data) => {
       if ("playback" in data && data.playback?.id === this.id) {
         listener(data);
       }
     };
     this.eventEmitter.once(event, wrappedListener);
+    console.log(
+      `One-time event listener registered for ${event} on playback ${this.id}`
+    );
   }
   /**
-   * Remove um listener para eventos específicos deste playback.
+   * Removes event listener(s) for a specific WebSocket event type.
+   *
+   * @param {T} event - Event type to remove listener(s) for
+   * @param {Function} [listener] - Optional specific listener to remove
    */
   off(event, listener) {
+    if (!event) {
+      throw new Error("Event type is required");
+    }
     if (listener) {
       this.eventEmitter.off(event, listener);
+      console.log(
+        `Specific listener removed for ${event} on playback ${this.id}`
+      );
     } else {
       this.eventEmitter.removeAllListeners(event);
+      console.log(`All listeners removed for ${event} on playback ${this.id}`);
     }
   }
   /**
-   * Emite eventos internamente para o playback.
+   * Emits a WebSocket event if it matches the current playback instance.
+   *
+   * @param {WebSocketEvent} event - Event to emit
    */
   emitEvent(event) {
+    if (!event) {
+      console.warn("Received invalid event");
+      return;
+    }
     if ("playback" in event && event.playback?.id === this.id) {
       this.eventEmitter.emit(event.type, event);
+      console.log(`Event ${event.type} emitted for playback ${this.id}`);
     }
   }
   /**
-   * Obtém os detalhes do playback.
+   * Retrieves current playback data.
+   *
+   * @returns {Promise<Playback>} Current playback data
+   * @throws {Error} If playback is not properly initialized
    */
   async get() {
     if (!this.id) {
-      throw new Error("Nenhum playback associado a esta inst\xE2ncia.");
+      throw new Error("No playback associated with this instance");
+    }
+    try {
+      this.playbackData = await this.baseClient.get(
+        `/playbacks/${this.id}`
+      );
+      console.log(`Retrieved playback data for ${this.id}`);
+      return this.playbackData;
+    } catch (error) {
+      const message = getErrorMessage2(error);
+      console.error(`Error retrieving playback data for ${this.id}:`, message);
+      throw new Error(`Failed to get playback data: ${message}`);
     }
-    this.playbackData = await this.baseClient.get(
-      `/playbacks/${this.id}`
-    );
-    return this.playbackData;
   }
   /**
-   * Controla o playback.
+   * Controls playback with specified operation.
+   *
+   * @param {"pause" | "unpause" | "reverse" | "forward"} operation - Control operation to perform
+   * @throws {Error} If playback is not properly initialized or operation fails
    */
   async control(operation) {
     if (!this.id) {
-      throw new Error("Nenhum playback associado para controlar.");
+      throw new Error("No playback associated with this instance");
+    }
+    try {
+      await this.baseClient.post(
+        `/playbacks/${this.id}/control?operation=${operation}`
+      );
+      console.log(
+        `Operation ${operation} executed successfully on playback ${this.id}`
+      );
+    } catch (error) {
+      const message = getErrorMessage2(error);
+      console.error(`Error controlling playback ${this.id}:`, message);
+      throw new Error(`Failed to control playback: ${message}`);
     }
-    await this.baseClient.post(
-      `/playbacks/${this.id}/control?operation=${operation}`
-    );
   }
   /**
-   * Encerra o playback.
+   * Stops the current playback.
+   *
+   * @throws {Error} If playback is not properly initialized or stop operation fails
    */
   async stop() {
     if (!this.id) {
-      throw new Error("Nenhum playback associado para encerrar.");
+      throw new Error("No playback associated with this instance");
+    }
+    try {
+      await this.baseClient.delete(`/playbacks/${this.id}`);
+      console.log(`Playback ${this.id} stopped successfully`);
+    } catch (error) {
+      const message = getErrorMessage2(error);
+      console.error(`Error stopping playback ${this.id}:`, message);
+      throw new Error(`Failed to stop playback: ${message}`);
     }
-    await this.baseClient.delete(`/playbacks/${this.id}`);
   }
   /**
-   * Remove todos os listeners para este playback.
+   * Removes all event listeners from this playback instance.
    */
   removeAllListeners() {
     this.eventEmitter.removeAllListeners();
+    console.log(`All listeners removed from playback ${this.id}`);
+  }
+  /**
+   * Checks if the playback instance has any listeners for a specific event.
+   *
+   * @param {string} event - Event type to check
+   * @returns {boolean} True if there are listeners for the event
+   */
+  hasListeners(event) {
+    return this.eventEmitter.listenerCount(event) > 0;
+  }
+  /**
+   * Gets the current playback data without making an API call.
+   *
+   * @returns {Playback | null} Current playback data or null if not available
+   */
+  getCurrentData() {
+    return this.playbackData;
   }
 };
 var Playbacks = class {
@@ -1615,61 +2180,144 @@ var Playbacks = class {
   }
   playbackInstances = /* @__PURE__ */ new Map();
   /**
-   * Gerencia instâncias de playback.
+   * Gets or creates a playback instance
+   * @param {Object} [params] - Optional parameters for getting/creating a playback instance
+   * @param {string} [params.id] - Optional ID of an existing playback
+   * @returns {PlaybackInstance} The requested or new playback instance
    */
-  Playback({ id }) {
-    if (!id) {
-      const instance = new PlaybackInstance(this.client, this.baseClient);
-      this.playbackInstances.set(instance.id, instance);
-      return instance;
-    }
-    if (!this.playbackInstances.has(id)) {
-      const instance = new PlaybackInstance(this.client, this.baseClient, id);
-      this.playbackInstances.set(id, instance);
-      return instance;
+  Playback(params) {
+    try {
+      const id = params?.id;
+      if (!id) {
+        const instance = new PlaybackInstance(this.client, this.baseClient);
+        this.playbackInstances.set(instance.id, instance);
+        console.log(`New playback instance created with ID: ${instance.id}`);
+        return instance;
+      }
+      if (!this.playbackInstances.has(id)) {
+        const instance = new PlaybackInstance(this.client, this.baseClient, id);
+        this.playbackInstances.set(id, instance);
+        console.log(`New playback instance created with provided ID: ${id}`);
+        return instance;
+      }
+      console.log(`Returning existing playback instance: ${id}`);
+      return this.playbackInstances.get(id);
+    } catch (error) {
+      const message = getErrorMessage2(error);
+      console.error(`Error creating/retrieving playback instance:`, message);
+      throw new Error(`Failed to manage playback instance: ${message}`);
     }
-    return this.playbackInstances.get(id);
   }
   /**
-   * Remove uma instância de playback.
+   * Removes a playback instance and cleans up its resources
+   * @param {string} playbackId - ID of the playback instance to remove
+   * @throws {Error} If the playback instance doesn't exist
    */
   removePlaybackInstance(playbackId) {
+    if (!playbackId) {
+      throw new Error("Playback ID is required");
+    }
     if (this.playbackInstances.has(playbackId)) {
       const instance = this.playbackInstances.get(playbackId);
       instance?.removeAllListeners();
       this.playbackInstances.delete(playbackId);
+      console.log(`Playback instance removed: ${playbackId}`);
+    } else {
+      console.warn(`Attempt to remove non-existent instance: ${playbackId}`);
     }
   }
   /**
-   * Propaga eventos do WebSocket para o playback correspondente.
+   * Propagates WebSocket events to the corresponding playback instance
+   * @param {WebSocketEvent} event - The WebSocket event to propagate
    */
   propagateEventToPlayback(event) {
+    if (!event) {
+      console.warn("Invalid WebSocket event received");
+      return;
+    }
     if ("playback" in event && event.playback?.id) {
       const instance = this.playbackInstances.get(event.playback.id);
       if (instance) {
         instance.emitEvent(event);
+        console.log(
+          `Event propagated to playback ${event.playback.id}: ${event.type}`
+        );
+      } else {
+        console.warn(`No instance found for playback ${event.playback.id}`);
       }
     }
   }
   /**
-   * Obtém detalhes de um playback específico.
+   * Retrieves details of a specific playback
+   * @param {string} playbackId - ID of the playback to get details for
+   * @returns {Promise<Playback>} Promise resolving to playback details
+   * @throws {Error} If the playback ID is invalid or the request fails
    */
   async getDetails(playbackId) {
-    return this.baseClient.get(`/playbacks/${playbackId}`);
+    if (!playbackId) {
+      throw new Error("Playback ID is required");
+    }
+    try {
+      return await this.baseClient.get(`/playbacks/${playbackId}`);
+    } catch (error) {
+      const message = getErrorMessage2(error);
+      console.error(`Error getting playback details ${playbackId}:`, message);
+      throw new Error(`Failed to get playback details: ${message}`);
+    }
   }
   /**
-   * Controla um playback específico.
+   * Controls a specific playback instance
+   * @param {string} playbackId - ID of the playback to control
+   * @param {"pause" | "unpause" | "reverse" | "forward"} operation - Operation to perform
+   * @throws {Error} If the playback ID is invalid or the operation fails
    */
   async control(playbackId, operation) {
-    const playback = this.Playback({ id: playbackId });
-    await playback.control(operation);
+    if (!playbackId) {
+      throw new Error("Playback ID is required");
+    }
+    try {
+      const playback = this.Playback({ id: playbackId });
+      await playback.control(operation);
+      console.log(`Operation ${operation} executed on playback ${playbackId}`);
+    } catch (error) {
+      const message = getErrorMessage2(error);
+      console.error(`Error controlling playback ${playbackId}:`, message);
+      throw new Error(`Failed to control playback: ${message}`);
+    }
   }
   /**
-   * Encerra um playback específico.
+   * Stops a specific playback instance
+   * @param {string} playbackId - ID of the playback to stop
+   * @throws {Error} If the playback ID is invalid or the stop operation fails
    */
   async stop(playbackId) {
-    const playback = this.Playback({ id: playbackId });
-    await playback.stop();
+    if (!playbackId) {
+      throw new Error("Playback ID is required");
+    }
+    try {
+      const playback = this.Playback({ id: playbackId });
+      await playback.stop();
+      console.log(`Playback ${playbackId} stopped`);
+    } catch (error) {
+      const message = getErrorMessage2(error);
+      console.error(`Error stopping playback ${playbackId}:`, message);
+      throw new Error(`Failed to stop playback: ${message}`);
+    }
+  }
+  /**
+   * Gets the count of active playback instances
+   * @returns {number} Number of active playback instances
+   */
+  getInstanceCount() {
+    return this.playbackInstances.size;
+  }
+  /**
+   * Checks if a playback instance exists
+   * @param {string} playbackId - ID of the playback to check
+   * @returns {boolean} True if the playback instance exists
+   */
+  hasInstance(playbackId) {
+    return this.playbackInstances.has(playbackId);
   }
 };
 
@@ -1708,40 +2356,51 @@ var Sounds = class {
 var import_exponential_backoff = __toESM(require_backoff(), 1);
 import { EventEmitter as EventEmitter3 } from "events";
 import WebSocket from "ws";
+var DEFAULT_MAX_RECONNECT_ATTEMPTS = 10;
+var DEFAULT_STARTING_DELAY = 500;
+var DEFAULT_MAX_DELAY = 1e4;
 var WebSocketClient = class extends EventEmitter3 {
+  /**
+   * Creates a new WebSocket client instance.
+   *
+   * @param {BaseClient} baseClient - The base client containing connection details
+   * @param {string[]} apps - List of applications to connect to
+   * @param {WebSocketEventType[]} [subscribedEvents] - Optional list of events to subscribe to
+   * @param {AriClient} [ariClient] - Optional ARI client for handling channel and playback events
+   */
   constructor(baseClient, apps, subscribedEvents, ariClient) {
     super();
     this.baseClient = baseClient;
     this.apps = apps;
     this.subscribedEvents = subscribedEvents;
     this.ariClient = ariClient;
+    if (!apps.length) {
+      throw new Error("At least one application name is required");
+    }
   }
   ws;
   isReconnecting = false;
-  maxReconnectAttempts = 10;
+  maxReconnectAttempts = DEFAULT_MAX_RECONNECT_ATTEMPTS;
   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
+    numOfAttempts: DEFAULT_MAX_RECONNECT_ATTEMPTS,
+    startingDelay: DEFAULT_STARTING_DELAY,
+    maxDelay: DEFAULT_MAX_DELAY,
     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
+        `Connection attempt #${attemptNumber} failed:`,
+        error.message || "Unknown error"
       );
-      return true;
+      return attemptNumber < this.maxReconnectAttempts;
     }
   };
   /**
-   * Conecta ao WebSocket.
+   * Establishes a WebSocket connection.
+   *
+   * @returns {Promise<void>} Resolves when connection is established
+   * @throws {Error} If connection fails
    */
   async connect() {
     const { baseUrl, username, password } = this.baseClient.getCredentials();
@@ -1749,7 +2408,7 @@ var WebSocketClient = class extends EventEmitter3 {
     const normalizedHost = baseUrl.replace(/^https?:\/\//, "").replace(/\/ari$/, "");
     const queryParams = new URLSearchParams();
     queryParams.append("app", this.apps.join(","));
-    if (this.subscribedEvents && this.subscribedEvents.length > 0) {
+    if (this.subscribedEvents?.length) {
       this.subscribedEvents.forEach(
         (event) => queryParams.append("event", event)
       );
@@ -1757,48 +2416,57 @@ var WebSocketClient = class extends EventEmitter3 {
       queryParams.append("subscribeAll", "true");
     }
     const wsUrl = `${protocol}://${encodeURIComponent(username)}:${encodeURIComponent(password)}@${normalizedHost}/ari/events?${queryParams.toString()}`;
-    console.log("Conectando ao WebSocket em:", wsUrl);
+    console.log("Connecting to WebSocket...");
     return this.initializeWebSocket(wsUrl);
   }
   /**
-   * Inicializa a conexão WebSocket com lógica de reconexão.
+   * Initializes WebSocket connection with reconnection logic.
+   *
+   * @param {string} wsUrl - The WebSocket URL to connect to
+   * @returns {Promise<void>} Resolves when connection is established
    */
   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);
-        });
+        try {
+          this.ws = new WebSocket(wsUrl);
+          this.ws.on("open", () => {
+            console.log("WebSocket connection established successfully");
+            this.isReconnecting = false;
+            this.emit("connected");
+            resolve();
+          });
+          this.ws.on("message", (data) => this.handleMessage(data.toString()));
+          this.ws.on("close", (code) => {
+            console.warn(
+              `WebSocket disconnected with code ${code}. Attempting to reconnect...`
+            );
+            if (!this.isReconnecting) {
+              this.reconnect(wsUrl);
+            }
+          });
+          this.ws.on("error", (err) => {
+            console.error("WebSocket error:", err.message);
+            if (!this.isReconnecting) {
+              this.reconnect(wsUrl);
+            }
+            reject(err);
+          });
+        } catch (error) {
+          reject(error);
+        }
       });
     }, this.backOffOptions);
   }
   /**
-   * Processa as mensagens recebidas do WebSocket.
+   * Processes incoming WebSocket messages.
+   *
+   * @param {string} rawMessage - The raw message received from WebSocket
    */
   handleMessage(rawMessage) {
     try {
       const event = JSON.parse(rawMessage);
-      if (this.subscribedEvents && !this.subscribedEvents.includes(event.type)) {
+      if (this.subscribedEvents?.length && !this.subscribedEvents.includes(event.type)) {
         return;
       }
       if ("channel" in event && event.channel?.id && this.ariClient) {
@@ -1812,40 +2480,77 @@ var WebSocketClient = class extends EventEmitter3 {
         event.instancePlayback = instancePlayback;
       }
       this.emit(event.type, event);
-    } catch (err) {
-      console.error("Erro ao processar mensagem WebSocket:", err);
-      this.emit("error", new Error("Falha ao decodificar mensagem WebSocket."));
+      console.log(`Event processed: ${event.type}`);
+    } catch (error) {
+      console.error("Error processing WebSocket message:", error instanceof Error ? error.message : "Unknown error");
+      this.emit("error", new Error("Failed to decode WebSocket message"));
     }
   }
   /**
-   * Tenta reconectar ao WebSocket.
+   * Attempts to reconnect to the WebSocket.
+   *
+   * @param {string} wsUrl - The WebSocket URL to reconnect to
    */
   reconnect(wsUrl) {
     this.isReconnecting = true;
-    console.log("Iniciando tentativa de reconex\xE3o...");
+    console.log("Initiating reconnection attempt...");
     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
-        );
-      }
-    );
+    (0, import_exponential_backoff.backOff)(() => this.initializeWebSocket(wsUrl), this.backOffOptions).catch((error) => {
+      console.error(
+        "Failed to reconnect after multiple attempts:",
+        error instanceof Error ? error.message : "Unknown error"
+      );
+      this.emit("reconnectFailed", error);
+    });
   }
   /**
-   * Fecha o WebSocket manualmente.
+   * Manually closes the WebSocket connection.
    */
   close() {
-    this.ws?.close();
-    this.ws = void 0;
+    try {
+      if (this.ws) {
+        this.ws.close();
+        this.ws = void 0;
+        console.log("WebSocket connection closed");
+      }
+    } catch (error) {
+      console.error(
+        "Error closing WebSocket:",
+        error instanceof Error ? error.message : "Unknown error"
+      );
+    }
+  }
+  /**
+   * Checks if the WebSocket is currently connected.
+   *
+   * @returns {boolean} True if connected, false otherwise
+   */
+  isConnected() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+  /**
+   * Gets the current connection state.
+   *
+   * @returns {number} The WebSocket ready state
+   */
+  getState() {
+    return this.ws?.readyState ?? WebSocket.CLOSED;
   }
 };
 
 // src/ari-client/ariClient.ts
 var AriClient = class {
+  /**
+   * Creates a new instance of the ARI client.
+   *
+   * @param {AriClientConfig} config - Configuration options for the ARI client
+   * @throws {Error} If required configuration parameters are missing
+   */
   constructor(config) {
     this.config = config;
+    if (!config.host || !config.port || !config.username || !config.password) {
+      throw new Error("Missing required configuration parameters");
+    }
     const httpProtocol = config.secure ? "https" : "http";
     const normalizedHost = config.host.replace(/^https?:\/\//, "");
     const baseUrl = `${httpProtocol}://${normalizedHost}:${config.port}/ari`;
@@ -1857,6 +2562,7 @@ var AriClient = class {
     this.sounds = new Sounds(this.baseClient);
     this.asterisk = new Asterisk(this.baseClient);
     this.bridges = new Bridges(this.baseClient);
+    console.log(`ARI Client initialized with base URL: ${baseUrl}`);
   }
   baseClient;
   webSocketClient;
@@ -1868,58 +2574,117 @@ var AriClient = class {
   asterisk;
   bridges;
   /**
-   * Inicializa uma conexão WebSocket.
+   * Initializes a WebSocket connection for receiving events.
+   *
+   * @param {string[]} apps - List of application names to subscribe to
+   * @param {WebSocketEventType[]} [subscribedEvents] - Optional list of specific event types to subscribe to
+   * @returns {Promise<void>} Resolves when connection is established
+   * @throws {Error} If connection fails or if WebSocket is already connected
    */
   async connectWebSocket(apps, subscribedEvents) {
+    if (!apps.length) {
+      throw new Error("At least one application name is required");
+    }
     if (this.webSocketClient) {
-      console.warn("WebSocket j\xE1 est\xE1 conectado.");
+      console.warn("WebSocket is already connected");
       return;
     }
-    this.webSocketClient = new WebSocketClient(
-      this.baseClient,
-      apps,
-      subscribedEvents,
-      this
-    );
-    await this.webSocketClient.connect();
+    try {
+      this.webSocketClient = new WebSocketClient(
+        this.baseClient,
+        apps,
+        subscribedEvents,
+        this
+      );
+      await this.webSocketClient.connect();
+      console.log("WebSocket connection established successfully");
+    } catch (error) {
+      console.error("Failed to establish WebSocket connection:", error);
+      this.webSocketClient = void 0;
+      throw error;
+    }
   }
   /**
-   * Adiciona um listener para eventos do WebSocket.
+   * Registers an event listener for WebSocket events.
+   *
+   * @param {T} event - The event type to listen for
+   * @param {Function} listener - Callback function for handling the event
+   * @throws {Error} If WebSocket is not connected
    */
   on(event, listener) {
-    this.webSocketClient?.on(event, listener);
+    if (!this.webSocketClient) {
+      throw new Error("WebSocket is not connected");
+    }
+    this.webSocketClient.on(event, listener);
+    console.log(`Event listener registered for ${event}`);
   }
   /**
-   * Adiciona um listener único para eventos do WebSocket.
+   * Registers a one-time event listener for WebSocket events.
+   *
+   * @param {T} event - The event type to listen for
+   * @param {Function} listener - Callback function for handling the event
+   * @throws {Error} If WebSocket is not connected
    */
   once(event, listener) {
-    this.webSocketClient?.once(event, listener);
+    if (!this.webSocketClient) {
+      throw new Error("WebSocket is not connected");
+    }
+    this.webSocketClient.once(event, listener);
+    console.log(`One-time event listener registered for ${event}`);
   }
   /**
-   * Remove um listener para eventos do WebSocket.
+   * Removes an event listener for WebSocket events.
+   *
+   * @param {T} event - The event type to remove listener for
+   * @param {Function} listener - The listener function to remove
    */
   off(event, listener) {
-    this.webSocketClient?.off(event, listener);
+    if (!this.webSocketClient) {
+      console.warn("No WebSocket connection to remove listener from");
+      return;
+    }
+    this.webSocketClient.off(event, listener);
+    console.log(`Event listener removed for ${event}`);
   }
   /**
-   * Fecha a conexão WebSocket.
+   * Closes the WebSocket connection if one exists.
    */
   closeWebSocket() {
-    this.webSocketClient?.close();
+    if (!this.webSocketClient) {
+      console.warn("No WebSocket connection to close");
+      return;
+    }
+    this.webSocketClient.close();
     this.webSocketClient = void 0;
+    console.log("WebSocket connection closed");
   }
   /**
-   * Inicializa uma nova instância de `ChannelInstance` para manipular canais localmente.
+   * Creates or retrieves a Channel instance.
+   *
+   * @param {string} [channelId] - Optional ID of an existing channel
+   * @returns {ChannelInstance} A new or existing channel instance
    */
   Channel(channelId) {
     return this.channels.Channel({ id: channelId });
   }
   /**
-   * Inicializa uma nova instância de `PlaybackInstance` para manipular playbacks.
+   * Creates or retrieves a Playback instance.
+   *
+   * @param {string} [playbackId] - Optional ID of an existing playback
+   * @param {string} [_app] - Optional application name (deprecated)
+   * @returns {PlaybackInstance} A new or existing playback instance
    */
   Playback(playbackId, _app) {
     return this.playbacks.Playback({ id: playbackId });
   }
+  /**
+   * Gets the current WebSocket connection status.
+   *
+   * @returns {boolean} True if WebSocket is connected, false otherwise
+   */
+  isWebSocketConnected() {
+    return !!this.webSocketClient;
+  }
 };
 export {
   Applications,