@zapyapi/sdk 1.0.0-beta.1 → 1.0.0-beta.10

package/index.cjs

@@ -3,7 +3,7 @@
 var axios = require('axios');
 
 /** SDK version - auto-generated from package.json */
-const SDK_VERSION = '1.0.0-beta.1';
+const SDK_VERSION = '1.0.0-beta.10';
 
 /**
  * Custom error classes for @zapyapi/sdk
@@ -12,11 +12,30 @@ const SDK_VERSION = '1.0.0-beta.1';
  * Base error class for all ZapyAPI errors
  */
 class ZapyError extends Error {
-  constructor(message) {
-    super(message);
+  /**
+   * Original error that caused this error (if any)
+   */
+  cause;
+  constructor(message, cause) {
+    super(message, {
+      cause
+    });
     this.name = 'ZapyError';
     Object.setPrototypeOf(this, ZapyError.prototype);
   }
+  /**
+   * Get a detailed string representation of the error
+   */
+  toDetailedString() {
+    let result = `${this.name}: ${this.message}`;
+    if (this.cause) {
+      result += `\nCaused by: ${this.cause.message}`;
+      if (this.cause.stack) {
+        result += `\n${this.cause.stack}`;
+      }
+    }
+    return result;
+  }
 }
 /**
  * Error thrown when the API returns an error response
@@ -38,13 +57,28 @@ class ZapyApiError extends ZapyError {
    * Additional error details
    */
   details;
-  constructor(message, statusCode, code, requestId, details) {
-    super(message);
+  /**
+   * HTTP method used in the request
+   */
+  method;
+  /**
+   * URL that was requested
+   */
+  url;
+  /**
+   * Raw response body (for debugging)
+   */
+  responseBody;
+  constructor(message, statusCode, code, options) {
+    super(message, options?.cause);
     this.name = 'ZapyApiError';
     this.statusCode = statusCode;
     this.code = code;
-    this.requestId = requestId;
-    this.details = details;
+    this.requestId = options?.requestId;
+    this.details = options?.details;
+    this.method = options?.method;
+    this.url = options?.url;
+    this.responseBody = options?.responseBody;
     Object.setPrototypeOf(this, ZapyApiError.prototype);
   }
   /**
@@ -54,10 +88,81 @@ class ZapyApiError extends ZapyError {
     const statusCode = error.response?.status ?? 500;
     const data = error.response?.data;
     const requestId = error.response?.headers?.['x-request-id'];
-    if (data && typeof data === 'object' && 'code' in data) {
-      return new ZapyApiError(data.message || error.message, statusCode, data.code, requestId || data.requestId, data.details);
+    const method = error.config?.method?.toUpperCase();
+    const url = error.config?.url;
+    // Build a descriptive message
+    let message;
+    if (data && typeof data === 'object' && 'message' in data && data.message) {
+      message = data.message;
+    } else if (error.message) {
+      message = error.message;
+    } else {
+      message = `Request failed with status ${statusCode}`;
+    }
+    // Add context to the message
+    const context = [];
+    if (method && url) {
+      context.push(`${method} ${url}`);
+    }
+    if (statusCode) {
+      context.push(`Status: ${statusCode}`);
     }
-    return new ZapyApiError(error.message || 'An unexpected error occurred', statusCode, 'UNKNOWN_ERROR', requestId);
+    if (requestId) {
+      context.push(`Request ID: ${requestId}`);
+    }
+    const fullMessage = context.length > 0 ? `${message} [${context.join(' | ')}]` : message;
+    const code = data && typeof data === 'object' && 'code' in data && data.code ? data.code : 'UNKNOWN_ERROR';
+    const details = data && typeof data === 'object' && 'details' in data ? data.details : undefined;
+    return new ZapyApiError(fullMessage, statusCode, code, {
+      requestId: requestId || (data && typeof data === 'object' && 'requestId' in data ? data.requestId : undefined),
+      details,
+      method,
+      url,
+      responseBody: data,
+      cause: error
+    });
+  }
+  /**
+   * Get a detailed string representation for logging
+   */
+  toDetailedString() {
+    const lines = [`${this.name}: ${this.message}`, `  Status Code: ${this.statusCode}`, `  Error Code: ${this.code}`];
+    if (this.method && this.url) {
+      lines.push(`  Request: ${this.method} ${this.url}`);
+    }
+    if (this.requestId) {
+      lines.push(`  Request ID: ${this.requestId}`);
+    }
+    if (this.details && Object.keys(this.details).length > 0) {
+      lines.push(`  Details: ${JSON.stringify(this.details, null, 2)}`);
+    }
+    if (this.responseBody && typeof this.responseBody === 'object') {
+      lines.push(`  Response Body: ${JSON.stringify(this.responseBody, null, 2)}`);
+    }
+    if (this.cause) {
+      lines.push(`  Caused by: ${this.cause.message}`);
+      if (this.cause.stack) {
+        lines.push(`  Stack: ${this.cause.stack.split('\n').slice(1, 4).join('\n    ')}`);
+      }
+    }
+    return lines.join('\n');
+  }
+  /**
+   * Convert to a plain object for logging/serialization
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      statusCode: this.statusCode,
+      code: this.code,
+      requestId: this.requestId,
+      method: this.method,
+      url: this.url,
+      details: this.details,
+      responseBody: this.responseBody,
+      cause: this.cause?.message
+    };
   }
 }
 /**
@@ -74,16 +179,32 @@ class ValidationError extends ZapyError {
     this.details = details;
     Object.setPrototypeOf(this, ValidationError.prototype);
   }
+  toDetailedString() {
+    const fieldErrors = Object.entries(this.details).map(([field, errors]) => `  ${field}: ${errors.join(', ')}`).join('\n');
+    return `${this.name}: ${this.message}\n${fieldErrors}`;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      details: this.details
+    };
+  }
 }
 /**
  * Error thrown when an instance is not found
  */
 class InstanceNotFoundError extends ZapyApiError {
-  constructor(instanceId, requestId) {
-    super(`Instance '${instanceId}' not found`, 404, 'INSTANCE_NOT_FOUND', requestId, {
-      instanceId
+  instanceId;
+  constructor(instanceId, options) {
+    super(`Instance '${instanceId}' not found`, 404, 'INSTANCE_NOT_FOUND', {
+      ...options,
+      details: {
+        instanceId
+      }
     });
     this.name = 'InstanceNotFoundError';
+    this.instanceId = instanceId;
     Object.setPrototypeOf(this, InstanceNotFoundError.prototype);
   }
 }
@@ -91,8 +212,8 @@ class InstanceNotFoundError extends ZapyApiError {
  * Error thrown when authentication fails
  */
 class AuthenticationError extends ZapyApiError {
-  constructor(message = 'Invalid or missing API key', requestId) {
-    super(message, 401, 'UNAUTHORIZED', requestId);
+  constructor(message = 'Invalid or missing API key', options) {
+    super(message, 401, 'UNAUTHORIZED', options);
     this.name = 'AuthenticationError';
     Object.setPrototypeOf(this, AuthenticationError.prototype);
   }
@@ -105,14 +226,89 @@ class RateLimitError extends ZapyApiError {
    * Timestamp when the rate limit resets (Unix ms)
    */
   retryAfter;
-  constructor(message = 'Rate limit exceeded', retryAfter, requestId) {
-    super(message, 429, 'RATE_LIMIT_EXCEEDED', requestId, {
-      retryAfter
+  constructor(message = 'Rate limit exceeded', retryAfter, options) {
+    super(message, 429, 'RATE_LIMIT_EXCEEDED', {
+      ...options,
+      details: retryAfter ? {
+        retryAfter
+      } : undefined
     });
     this.name = 'RateLimitError';
     this.retryAfter = retryAfter;
     Object.setPrototypeOf(this, RateLimitError.prototype);
   }
+  /**
+   * Get the Date when the rate limit resets
+   */
+  getRetryAfterDate() {
+    return this.retryAfter ? new Date(this.retryAfter) : undefined;
+  }
+}
+/**
+ * Error thrown when a network error occurs (no response received)
+ */
+class NetworkError extends ZapyError {
+  /**
+   * HTTP method used in the request
+   */
+  method;
+  /**
+   * URL that was requested
+   */
+  url;
+  /**
+   * Error code (e.g., ECONNREFUSED, ETIMEDOUT)
+   */
+  code;
+  constructor(message, options) {
+    super(message, options?.cause);
+    this.name = 'NetworkError';
+    this.method = options?.method;
+    this.url = options?.url;
+    this.code = options?.code;
+    Object.setPrototypeOf(this, NetworkError.prototype);
+  }
+  toDetailedString() {
+    const lines = [`${this.name}: ${this.message}`];
+    if (this.code) {
+      lines.push(`  Error Code: ${this.code}`);
+    }
+    if (this.method && this.url) {
+      lines.push(`  Request: ${this.method} ${this.url}`);
+    }
+    if (this.cause) {
+      lines.push(`  Caused by: ${this.cause.message}`);
+    }
+    return lines.join('\n');
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      method: this.method,
+      url: this.url,
+      cause: this.cause?.message
+    };
+  }
+}
+/**
+ * Error thrown when request times out
+ */
+class TimeoutError extends NetworkError {
+  /**
+   * Timeout duration in milliseconds
+   */
+  timeout;
+  constructor(message = 'Request timed out', options) {
+    super(message, {
+      ...options,
+      code: 'ETIMEDOUT'
+    });
+    this.name = 'TimeoutError';
+    this.timeout = options?.timeout;
+    Object.setPrototypeOf(this, TimeoutError.prototype);
+  }
 }
 
 /**
@@ -128,18 +324,58 @@ class BaseResource {
    */
   handleError(error) {
     if (this.isAxiosError(error)) {
-      const statusCode = error.response?.status;
-      const retryAfter = error.response?.headers?.['retry-after'];
+      const method = error.config?.method?.toUpperCase();
+      const url = error.config?.url;
+      const requestId = error.response?.headers?.['x-request-id'];
+      // Network errors (no response received)
+      if (!error.response) {
+        const code = error.code;
+        // Timeout errors
+        if (code === 'ECONNABORTED' || code === 'ETIMEDOUT' || error.message?.includes('timeout')) {
+          const timeout = error.config?.timeout;
+          throw new TimeoutError(`Request timed out${timeout ? ` after ${timeout}ms` : ''}`, {
+            method,
+            url,
+            timeout,
+            cause: error
+          });
+        }
+        // Other network errors (connection refused, DNS failure, etc.)
+        throw new NetworkError(error.message || 'Network error occurred', {
+          method,
+          url,
+          code,
+          cause: error
+        });
+      }
+      const statusCode = error.response.status;
+      const retryAfter = error.response.headers?.['retry-after'];
       if (statusCode === 401) {
-        throw new AuthenticationError(error.response?.data?.message || 'Invalid or missing API key', error.response?.headers?.['x-request-id']);
+        throw new AuthenticationError(error.response.data?.message || 'Invalid or missing API key', {
+          requestId,
+          method,
+          url,
+          cause: error
+        });
       }
       if (statusCode === 429) {
-        throw new RateLimitError(error.response?.data?.message || 'Rate limit exceeded', retryAfter ? parseInt(retryAfter, 10) * 1000 : undefined, error.response?.headers?.['x-request-id']);
+        const retryAfterMs = retryAfter ? parseInt(retryAfter, 10) * 1000 : undefined;
+        throw new RateLimitError(error.response.data?.message || 'Rate limit exceeded', retryAfterMs, {
+          requestId,
+          method,
+          url,
+          cause: error
+        });
       }
       throw ZapyApiError.fromAxiosError(error);
     }
+    if (error instanceof ZapyError) {
+      throw error;
+    }
     if (error instanceof Error) {
-      throw new ZapyApiError(error.message, 500, 'UNKNOWN_ERROR');
+      throw new ZapyApiError(error.message, 500, 'UNKNOWN_ERROR', {
+        cause: error
+      });
     }
     throw new ZapyApiError('An unexpected error occurred', 500, 'UNKNOWN_ERROR');
   }
@@ -428,6 +664,121 @@ class MessagesResource extends BaseResource {
       this.handleError(error);
     }
   }
+  /**
+   * Send a location message
+   *
+   * @param instanceId - Instance ID
+   * @param options - Location message options
+   * @returns Message response with ID and status
+   *
+   * @example
+   * await client.messages.sendLocation('my-instance', {
+   *   to: '5511999999999',
+   *   latitude: -23.5505,
+   *   longitude: -46.6333,
+   *   name: 'São Paulo',
+   *   address: 'São Paulo, Brazil'
+   * });
+   */
+  async sendLocation(instanceId, options) {
+    try {
+      const response = await this.http.post(`/message/${instanceId}/location`, {
+        to: options.to,
+        latitude: options.latitude,
+        longitude: options.longitude,
+        name: options.name,
+        address: options.address,
+        quoteMessageId: options.quotedMessageId
+      });
+      return response.data;
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  /**
+   * Send a contact card message
+   *
+   * @param instanceId - Instance ID
+   * @param options - Contact message options
+   * @returns Message response with ID and status
+   *
+   * @example
+   * await client.messages.sendContact('my-instance', {
+   *   to: '5511999999999',
+   *   contact: {
+   *     fullName: 'John Doe',
+   *     phoneNumber: '+5511988887777',
+   *     organization: 'Acme Inc'
+   *   }
+   * });
+   */
+  async sendContact(instanceId, options) {
+    try {
+      const response = await this.http.post(`/message/${instanceId}/contact`, {
+        to: options.to,
+        contact: options.contact,
+        quoteMessageId: options.quotedMessageId
+      });
+      return response.data;
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  /**
+   * Send a sticker message
+   *
+   * @param instanceId - Instance ID
+   * @param options - Sticker message options
+   * @returns Message response with ID and status
+   *
+   * @example
+   * await client.messages.sendSticker('my-instance', {
+   *   to: '5511999999999',
+   *   url: 'https://example.com/sticker.webp'
+   * });
+   */
+  async sendSticker(instanceId, options) {
+    try {
+      const response = await this.http.post(`/message/${instanceId}/sticker`, {
+        to: options.to,
+        url: options.url,
+        base64: options.base64,
+        quoteMessageId: options.quotedMessageId
+      });
+      return response.data;
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  /**
+   * Send a reaction to a message
+   *
+   * @param instanceId - Instance ID
+   * @param options - Reaction options
+   *
+   * @example
+   * // Add a reaction
+   * await client.messages.sendReaction('my-instance', {
+   *   messageId: 'ABC123...',
+   *   reaction: '👍'
+   * });
+   *
+   * // Remove a reaction
+   * await client.messages.sendReaction('my-instance', {
+   *   messageId: 'ABC123...',
+   *   reaction: ''
+   * });
+   */
+  async sendReaction(instanceId, options) {
+    try {
+      await this.http.post(`/message/${instanceId}/reaction`, {
+        messageId: options.messageId,
+        reaction: options.reaction
+      });
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
 }
 
 /**
@@ -691,6 +1042,155 @@ class InstancesResource extends BaseResource {
       this.handleError(error);
     }
   }
+  /**
+   * Check if phone numbers are registered on WhatsApp
+   *
+   * This method verifies if the provided phone numbers are registered on WhatsApp.
+   * Useful for validating contacts before sending messages.
+   *
+   * @param instanceId - Instance ID (must be connected)
+   * @param numbers - Array of phone numbers to check (with country code, e.g., "5511999999999")
+   * @returns Results indicating which numbers are registered on WhatsApp
+   *
+   * @example
+   * const result = await client.instances.checkNumbers('my-instance', [
+   *   '5511999999999',
+   *   '5521888888888'
+   * ]);
+   *
+   * for (const check of result.results) {
+   *   if (check.exists) {
+   *     console.log(`${check.number} is on WhatsApp (JID: ${check.jid})`);
+   *   } else {
+   *     console.log(`${check.number} is NOT on WhatsApp`);
+   *   }
+   * }
+   */
+  async checkNumbers(instanceId, numbers) {
+    try {
+      const response = await this.http.post(`/instances/${instanceId}/check-numbers`, {
+        numbers
+      });
+      return response.data;
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  /**
+   * Send a presence update (typing indicator, online status, etc.)
+   *
+   * Use this to show typing indicators or update online status for a contact.
+   *
+   * @param instanceId - Instance ID (must be connected)
+   * @param options - Presence options
+   *
+   * @example
+   * // Show typing indicator
+   * await client.instances.sendPresence('my-instance', {
+   *   to: '5511999999999',
+   *   presence: 'composing'
+   * });
+   *
+   * // Show recording audio indicator
+   * await client.instances.sendPresence('my-instance', {
+   *   to: '5511999999999',
+   *   presence: 'recording'
+   * });
+   *
+   * // Stop typing indicator
+   * await client.instances.sendPresence('my-instance', {
+   *   to: '5511999999999',
+   *   presence: 'paused'
+   * });
+   */
+  async sendPresence(instanceId, options) {
+    try {
+      await this.http.post(`/instances/${instanceId}/presence`, {
+        to: options.to,
+        presence: options.presence
+      });
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  /**
+   * Get profile picture URL for a contact
+   *
+   * @param instanceId - Instance ID (must be connected)
+   * @param phone - Phone number or JID of the contact
+   * @returns Profile picture response with URL (null if not available)
+   *
+   * @example
+   * const result = await client.instances.getProfilePicture('my-instance', '5511999999999');
+   * if (result.url) {
+   *   console.log('Profile picture:', result.url);
+   * } else {
+   *   console.log('No profile picture available');
+   * }
+   */
+  async getProfilePicture(instanceId, phone) {
+    try {
+      const response = await this.http.get(`/instances/${instanceId}/contacts/${phone}/profile-picture`);
+      return response.data;
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  /**
+   * Block a contact
+   *
+   * @param instanceId - Instance ID (must be connected)
+   * @param phone - Phone number or JID of the contact to block
+   *
+   * @example
+   * await client.instances.blockContact('my-instance', '5511999999999');
+   */
+  async blockContact(instanceId, phone) {
+    try {
+      await this.http.post(`/instances/${instanceId}/contacts/${phone}/block`);
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  /**
+   * Unblock a contact
+   *
+   * @param instanceId - Instance ID (must be connected)
+   * @param phone - Phone number or JID of the contact to unblock
+   *
+   * @example
+   * await client.instances.unblockContact('my-instance', '5511999999999');
+   */
+  async unblockContact(instanceId, phone) {
+    try {
+      await this.http.delete(`/instances/${instanceId}/contacts/${phone}/block`);
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  /**
+   * Get group metadata
+   *
+   * @param instanceId - Instance ID (must be connected)
+   * @param groupId - Group JID (e.g., "120363123456789012@g.us")
+   * @returns Group metadata including participants
+   *
+   * @example
+   * const metadata = await client.instances.getGroupMetadata('my-instance', '120363123456789012@g.us');
+   * console.log(`Group: ${metadata.subject}`);
+   * console.log(`Participants: ${metadata.participants.length}`);
+   * for (const p of metadata.participants) {
+   *   console.log(`  - ${p.id} (${p.admin || 'member'})`);
+   * }
+   */
+  async getGroupMetadata(instanceId, groupId) {
+    try {
+      const response = await this.http.get(`/instances/${instanceId}/groups/${groupId}`);
+      return response.data;
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
 }
 
 /**
@@ -701,7 +1201,7 @@ class InstancesResource extends BaseResource {
  *
  * @example
  * ```typescript
- * import { ZapyClient, WebhookEventType, isMessageEvent } from '@zapyapi/sdk';
+ * import { ZapyClient, ZapyEventTypes, isTextMessage } from '@zapyapi/sdk';
  *
  * const client = new ZapyClient({
  *   apiKey: 'your-api-key',
@@ -811,42 +1311,21 @@ function createClient(options) {
 /**
  * SDK Enums - Type-safe enums for ZapyAPI SDK
  *
- * These enums can be imported and used for type-safe comparisons and
- * webhook event handling.
- *
  * @example
  * ```typescript
- * import { WebhookEventType, InstanceStatus, MessageAckStatus } from '@zapyapi/sdk';
- *
- * // Type-safe event handling
- * if (event.event === WebhookEventType.MESSAGE) {
- *   // Handle message event
- * }
+ * import { InstanceStatus, ZapyEventTypes, ZapyMessageType } from '@zapyapi/sdk';
  *
  * // Check instance status
  * if (instance.status === InstanceStatus.CONNECTED) {
  *   // Instance is ready
  * }
+ *
+ * // Handle webhook events
+ * if (payload.event === ZapyEventTypes.MESSAGE) {
+ *   // Handle message
+ * }
  * ```
  */
-/**
- * Webhook event types sent by ZapyAPI
- * These are the event types you'll receive in webhook payloads
- */
-const WebhookEventType = {
-  /** New message received */
-  MESSAGE: 'message',
-  /** Message delivery status update */
-  MESSAGE_STATUS: 'message-status',
-  /** QR code generated for authentication */
-  QR_CODE: 'qr-code',
-  /** New contact discovered */
-  CONTACT_CREATED: 'contact-created',
-  /** Contact information updated */
-  CONTACT_UPDATED: 'contact-updated',
-  /** Duplicate contacts merged */
-  CONTACT_DEDUPLICATED: 'contact-deduplicated'
-};
 /**
  * Instance status values
  * Represents the current state of a WhatsApp instance
@@ -871,48 +1350,6 @@ const InstanceStatus = {
   /** Payment pending for this instance */
   PAYMENT_PENDING: 'payment_pending'
 };
-/**
- * Message acknowledgment status
- * Represents the delivery status of a sent message
- */
-const MessageAckStatus = {
-  /** Message is pending to be sent */
-  PENDING: 'pending',
-  /** Message was sent to server */
-  SENT: 'sent',
-  /** Message was delivered to recipient */
-  DELIVERED: 'delivered',
-  /** Message was read by recipient */
-  READ: 'read',
-  /** Audio/video message was played */
-  PLAYED: 'played'
-};
-/**
- * Message types for incoming messages
- * Identifies the type of content in a received message
- */
-const MessageType = {
-  /** Text message */
-  TEXT: 'text',
-  /** Image message */
-  IMAGE: 'image',
-  /** Video message */
-  VIDEO: 'video',
-  /** Audio message (voice note or file) */
-  AUDIO: 'audio',
-  /** Document/file message */
-  DOCUMENT: 'document',
-  /** Sticker message */
-  STICKER: 'sticker',
-  /** Location message */
-  LOCATION: 'location',
-  /** Contact card message */
-  CONTACT: 'contact',
-  /** Poll message */
-  POLL: 'poll',
-  /** Reaction message */
-  REACTION: 'reaction'
-};
 /**
  * Webhook queue item status
  * Used for monitoring webhook delivery status
@@ -929,49 +1366,113 @@ const WebhookQueueStatus = {
   /** Webhook delivery is paused due to repeated failures */
   PAUSED: 'paused'
 };
-/**
- * Connection status for webhook events
- * Sent in connection.update webhook events
- */
-const ConnectionStatus = {
-  /** Instance is connecting */
-  CONNECTING: 'connecting',
-  /** Instance is connected */
-  CONNECTED: 'connected',
-  /** Instance disconnected */
-  DISCONNECTED: 'disconnected',
-  /** Connection error occurred */
-  ERROR: 'error'
-};
 
 /**
- * Webhook event type definitions
- * Types for webhook payloads sent by ZapyAPI
+ * WhatsApp Message Event Types
+ * Comprehensive type definitions for all WhatsApp message types
  */
-/** Type guard for message events */
-function isMessageEvent(event) {
-  return event.event === 'message';
+// ============================================================================
+// Message Status
+// ============================================================================
+exports.ZapyMessageStatusEnum = void 0;
+(function (ZapyMessageStatusEnum) {
+  ZapyMessageStatusEnum["UNKNOWN"] = "UNKNOWN";
+  ZapyMessageStatusEnum["ERROR"] = "ERROR";
+  ZapyMessageStatusEnum["PENDING"] = "PENDING";
+  ZapyMessageStatusEnum["SENT"] = "SENT";
+  ZapyMessageStatusEnum["RECEIVED"] = "RECEIVED";
+  ZapyMessageStatusEnum["READ"] = "READ";
+  ZapyMessageStatusEnum["PLAYED"] = "PLAYED";
+})(exports.ZapyMessageStatusEnum || (exports.ZapyMessageStatusEnum = {}));
+exports.ZapyMessageType = void 0;
+(function (ZapyMessageType) {
+  ZapyMessageType["TEXT"] = "text";
+  ZapyMessageType["IMAGE"] = "image";
+  ZapyMessageType["VIDEO"] = "video";
+  ZapyMessageType["AUDIO"] = "audio";
+  ZapyMessageType["DOCUMENT"] = "document";
+  ZapyMessageType["STICKER"] = "sticker";
+  ZapyMessageType["LOCATION"] = "location";
+  ZapyMessageType["LIVE_LOCATION"] = "live_location";
+  ZapyMessageType["CONTACT"] = "contact";
+  ZapyMessageType["REACTION"] = "reaction";
+  ZapyMessageType["EDITED"] = "edited";
+  ZapyMessageType["DELETED"] = "deleted";
+  ZapyMessageType["POLL"] = "poll";
+  ZapyMessageType["POLL_VOTE"] = "poll_vote";
+  ZapyMessageType["CALL"] = "call";
+  ZapyMessageType["UNSUPPORTED"] = "unsupported";
+})(exports.ZapyMessageType || (exports.ZapyMessageType = {}));
+// ============================================================================
+// Type Guards
+// ============================================================================
+function isTextMessage(message) {
+  return message.messageType === exports.ZapyMessageType.TEXT;
+}
+function isImageMessage(message) {
+  return message.messageType === exports.ZapyMessageType.IMAGE;
+}
+function isVideoMessage(message) {
+  return message.messageType === exports.ZapyMessageType.VIDEO;
+}
+function isAudioMessage(message) {
+  return message.messageType === exports.ZapyMessageType.AUDIO;
+}
+function isDocumentMessage(message) {
+  return message.messageType === exports.ZapyMessageType.DOCUMENT;
+}
+function isStickerMessage(message) {
+  return message.messageType === exports.ZapyMessageType.STICKER;
+}
+function isLocationMessage(message) {
+  return message.messageType === exports.ZapyMessageType.LOCATION;
+}
+function isLiveLocationMessage(message) {
+  return message.messageType === exports.ZapyMessageType.LIVE_LOCATION;
+}
+function isContactMessage(message) {
+  return message.messageType === exports.ZapyMessageType.CONTACT;
 }
-/** Type guard for message status events */
-function isMessageStatusEvent(event) {
-  return event.event === 'message-status';
+function isReactionMessage(message) {
+  return message.messageType === exports.ZapyMessageType.REACTION;
 }
-/** Type guard for QR code events */
-function isQRCodeEvent(event) {
-  return event.event === 'qr-code';
+function isEditedMessage(message) {
+  return message.messageType === exports.ZapyMessageType.EDITED;
 }
-/** Type guard for contact created events */
-function isContactCreatedEvent(event) {
-  return event.event === 'contact-created';
+function isDeletedMessage(message) {
+  return message.messageType === exports.ZapyMessageType.DELETED;
 }
-/** Type guard for contact updated events */
-function isContactUpdatedEvent(event) {
-  return event.event === 'contact-updated';
+function isPollMessage(message) {
+  return message.messageType === exports.ZapyMessageType.POLL;
 }
-/** Type guard for contact deduplicated events */
-function isContactDeduplicatedEvent(event) {
-  return event.event === 'contact-deduplicated';
+function isPollVoteMessage(message) {
+  return message.messageType === exports.ZapyMessageType.POLL_VOTE;
 }
+function isCallMessage(message) {
+  return message.messageType === exports.ZapyMessageType.CALL;
+}
+function isUnsupportedMessage(message) {
+  return message.messageType === exports.ZapyMessageType.UNSUPPORTED;
+}
+function isMediaMessage(message) {
+  return [exports.ZapyMessageType.IMAGE, exports.ZapyMessageType.VIDEO, exports.ZapyMessageType.AUDIO, exports.ZapyMessageType.DOCUMENT, exports.ZapyMessageType.STICKER].includes(message.messageType);
+}
+
+// Re-export all event types
+/**
+ * Event type constants for type-safe event handling
+ */
+const ZapyEventTypes = {
+  MESSAGE: 'message',
+  MESSAGE_STATUS: 'message-status',
+  REACTION: 'reaction',
+  PRESENCE: 'presence',
+  QR_CODE: 'qr-code',
+  CONTACT_CREATED: 'contact-created',
+  CONTACT_UPDATED: 'contact-updated',
+  CONTACT_DEDUPLICATED: 'contact-deduplicated',
+  INSTANCE_STATUS: 'instance-status'
+};
 
 /**
  * Phone number utilities for @zapyapi/sdk
@@ -986,7 +1487,7 @@ function isContactDeduplicatedEvent(event) {
  * normalizePhone('11999999999')     // '5511999999999'
  * normalizePhone('5511999999999')   // '5511999999999'
  * normalizePhone('+5511999999999')  // '5511999999999'
- * normalizePhone('5511999999999@c.us') // '5511999999999@c.us'
+ * normalizePhone('5511999999999@s.whatsapp.net') // '5511999999999@s.whatsapp.net'
  */
 function normalizePhone(phone) {
   // If it's already a WhatsApp ID, return as-is
@@ -1015,7 +1516,7 @@ function normalizePhone(phone) {
 function isValidPhone(phone) {
   // WhatsApp IDs are valid
   if (phone.includes('@')) {
-    return phone.endsWith('@c.us') || phone.endsWith('@g.us') || phone.endsWith('@lid');
+    return phone.endsWith('@s.whatsapp.net') || phone.endsWith('@c.us') || phone.endsWith('@g.us') || phone.endsWith('@lid');
   }
   // Clean and check if it's a valid number
   const cleaned = phone.replace(/[^\d]/g, '');
@@ -1081,7 +1582,6 @@ function extractPhone(jid) {
 function verifyWebhookSignature(payload, signature, secret) {
   if (!signature || !secret) return false;
   try {
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
     const crypto = require('crypto');
     return verifySignatureWithCrypto(crypto, payload, signature, secret);
   } catch {
@@ -1148,29 +1648,896 @@ function verifySignatureWithCrypto(crypto, payload, signature, secret) {
   return crypto.timingSafeEqual(Buffer.from(signature, 'utf8'), Buffer.from(expectedSignature, 'utf8'));
 }
 
+/* eslint-disable */
+/* tslint:disable */
+// @ts-nocheck
+/*
+ * ---------------------------------------------------------------
+ * ## THIS FILE WAS GENERATED VIA SWAGGER-TYPESCRIPT-API        ##
+ * ##                                                           ##
+ * ## AUTHOR: acacode                                           ##
+ * ## SOURCE: https://github.com/acacode/swagger-typescript-api ##
+ * ---------------------------------------------------------------
+ */
+var ContentType;
+(function (ContentType) {
+  ContentType["Json"] = "application/json";
+  ContentType["JsonApi"] = "application/vnd.api+json";
+  ContentType["FormData"] = "multipart/form-data";
+  ContentType["UrlEncoded"] = "application/x-www-form-urlencoded";
+  ContentType["Text"] = "text/plain";
+})(ContentType || (ContentType = {}));
+class HttpClient {
+  instance;
+  securityData = null;
+  securityWorker;
+  secure;
+  format;
+  constructor({
+    securityWorker,
+    secure,
+    format,
+    ...axiosConfig
+  } = {}) {
+    this.instance = axios.create({
+      ...axiosConfig,
+      baseURL: axiosConfig.baseURL || ""
+    });
+    this.secure = secure;
+    this.format = format;
+    this.securityWorker = securityWorker;
+  }
+  setSecurityData = data => {
+    this.securityData = data;
+  };
+  mergeRequestParams(params1, params2) {
+    const method = params1.method || params2 && params2.method;
+    return {
+      ...this.instance.defaults,
+      ...params1,
+      ...(params2 || {}),
+      headers: {
+        ...(method && this.instance.defaults.headers[method.toLowerCase()] || {}),
+        ...(params1.headers || {}),
+        ...(params2 && params2.headers || {})
+      }
+    };
+  }
+  stringifyFormItem(formItem) {
+    if (typeof formItem === "object" && formItem !== null) {
+      return JSON.stringify(formItem);
+    } else {
+      return `${formItem}`;
+    }
+  }
+  createFormData(input) {
+    if (input instanceof FormData) {
+      return input;
+    }
+    return Object.keys(input || {}).reduce((formData, key) => {
+      const property = input[key];
+      const propertyContent = property instanceof Array ? property : [property];
+      for (const formItem of propertyContent) {
+        const isFileType = formItem instanceof Blob || formItem instanceof File;
+        formData.append(key, isFileType ? formItem : this.stringifyFormItem(formItem));
+      }
+      return formData;
+    }, new FormData());
+  }
+  request = async ({
+    secure,
+    path,
+    type,
+    query,
+    format,
+    body,
+    ...params
+  }) => {
+    const secureParams = (typeof secure === "boolean" ? secure : this.secure) && this.securityWorker && (await this.securityWorker(this.securityData)) || {};
+    const requestParams = this.mergeRequestParams(params, secureParams);
+    const responseFormat = format || this.format || undefined;
+    if (type === ContentType.FormData && body && body !== null && typeof body === "object") {
+      body = this.createFormData(body);
+    }
+    if (type === ContentType.Text && body && body !== null && typeof body !== "string") {
+      body = JSON.stringify(body);
+    }
+    return this.instance.request({
+      ...requestParams,
+      headers: {
+        ...(requestParams.headers || {}),
+        ...(type ? {
+          "Content-Type": type
+        } : {})
+      },
+      params: query,
+      responseType: responseFormat,
+      data: body,
+      url: path
+    });
+  };
+}
+/**
+ * @title Zapy API - Gerenciador de Instâncias WhatsApp
+ * @version 1.0.0
+ * @contact Suporte Zapy API <contato@zapyapi.com> (http://app.zapyapi.com/)
+ *
+ *
+ *         Formatos de Mensagem
+ *         - Números de Telefone: Formato brasileiro (11999999999) ou internacional (5511999999999)
+ *         - IDs do WhatsApp: Pessoal (@s.whatsapp.net), Grupos (@g.us), LIDs (@lid)
+ *         - Mídia: Arquivos codificados em Base64 ou URLs públicas
+ *
+ *         Suporte
+ *         Para suporte técnico e documentação, visite nosso site.
+ *         https://app.zapyapi.com/
+ *
+ */
+class Api extends HttpClient {
+  instances = {
+    /**
+    * @description Lista todas as instâncias do WhatsApp
+    *
+    * @tags Instâncias
+    * @name ManagerInstancesControllerListInstances
+    * @summary Listar Instâncias
+    * @request GET:/api/instances
+    * @secure
+    * @response `200` `(ResponsePaginated & {
+    data?: (ListInstancesResponseDto)[],
+     })` Lista paginada de instâncias obtida com sucesso
+    * @response `400` `BadRequestErrorDto` Dados da requisição inválidos
+    * @response `401` `UnauthorizedErrorDto` Não autorizado - API key inválida ou ausente
+    */
+    managerInstancesControllerListInstances: (query, params = {}) => this.request({
+      path: `/api/instances`,
+      method: "GET",
+      query: query,
+      secure: true,
+      format: "json",
+      ...params
+    }),
+    /**
+     * No description
+     *
+     * @tags Instâncias
+     * @name ManagerInstancesControllerCreateInstance
+     * @summary Create a new WhatsApp instance (Partner only - post-paid subscriptions required)
+     * @request POST:/api/instances
+     * @secure
+     * @response `201` `ManagerInstanceResponseDto` Instance created successfully
+     * @response `400` `void` Bad request
+     */
+    managerInstancesControllerCreateInstance: (data, params = {}) => this.request({
+      path: `/api/instances`,
+      method: "POST",
+      body: data,
+      secure: true,
+      type: ContentType.Json,
+      format: "json",
+      ...params
+    }),
+    /**
+     * @description Obtém o código QR para conectar a instância do WhatsApp
+     *
+     * @tags Instâncias
+     * @name ManagerInstancesControllerGetQrCode
+     * @summary Obter Código QR
+     * @request GET:/api/instances/{instanceId}/qr
+     * @secure
+     * @response `200` `QRCodeResponseDto` Código QR obtido com sucesso
+     * @response `403` `ForbiddenErrorDto` Acesso negado - Sem acesso ao recurso
+     * @response `404` `NotFoundErrorDto` Recurso não encontrado
+     */
+    managerInstancesControllerGetQrCode: ({
+      instanceId,
+      ...query
+    }, params = {}) => this.request({
+      path: `/api/instances/${instanceId}/qr`,
+      method: "GET",
+      secure: true,
+      format: "json",
+      ...params
+    }),
+    /**
+     * @description Reinicia uma instância do WhatsApp
+     *
+     * @tags Instâncias
+     * @name ManagerInstancesControllerRestartInstance
+     * @summary Reiniciar Instância do WhatsApp
+     * @request POST:/api/instances/{instanceId}/restart
+     * @secure
+     * @response `200` `EmptyResponseDto` Instância reiniciada com sucesso
+     * @response `400` `BadRequestErrorDto` Dados da requisição inválidos
+     * @response `403` `ForbiddenErrorDto` Acesso negado - Sem acesso ao recurso
+     * @response `404` `NotFoundErrorDto` Recurso não encontrado
+     */
+    managerInstancesControllerRestartInstance: ({
+      instanceId,
+      ...query
+    }, params = {}) => this.request({
+      path: `/api/instances/${instanceId}/restart`,
+      method: "POST",
+      secure: true,
+      format: "json",
+      ...params
+    }),
+    /**
+     * @description Desloga uma instância do WhatsApp
+     *
+     * @tags Instâncias
+     * @name ManagerInstancesControllerLogoutInstance
+     * @summary Deslogar Instância do WhatsApp
+     * @request POST:/api/instances/{instanceId}/logout
+     * @secure
+     * @response `200` `EmptyResponseDto` Instância deslogada com sucesso
+     * @response `400` `BadRequestErrorDto` Dados da requisição inválidos
+     * @response `403` `ForbiddenErrorDto` Acesso negado - Sem acesso ao recurso
+     * @response `404` `NotFoundErrorDto` Recurso não encontrado
+     */
+    managerInstancesControllerLogoutInstance: ({
+      instanceId,
+      ...query
+    }, params = {}) => this.request({
+      path: `/api/instances/${instanceId}/logout`,
+      method: "POST",
+      secure: true,
+      format: "json",
+      ...params
+    }),
+    /**
+     * @description Exclui permanentemente uma instância do WhatsApp. Esta ação é irreversível.
+     *
+     * @tags Instâncias
+     * @name ManagerInstancesControllerDeleteInstance
+     * @summary Excluir Instância do WhatsApp (Somente Parceiros)
+     * @request DELETE:/api/instances/{instanceId}
+     * @secure
+     * @response `204` `void` Instância excluída com sucesso
+     * @response `400` `BadRequestErrorDto` Dados da requisição inválidos
+     * @response `403` `ForbiddenErrorDto` Acesso negado - Sem acesso ao recurso
+     * @response `404` `NotFoundErrorDto` Recurso não encontrado
+     */
+    managerInstancesControllerDeleteInstance: ({
+      instanceId,
+      ...query
+    }, params = {}) => this.request({
+      path: `/api/instances/${instanceId}`,
+      method: "DELETE",
+      secure: true,
+      ...params
+    }),
+    /**
+     * @description Verifica se uma lista de números de telefone está registrada no WhatsApp
+     *
+     * @tags Instâncias
+     * @name ManagerInstancesControllerCheckNumbers
+     * @summary Verificar Números no WhatsApp
+     * @request POST:/api/instances/{instanceId}/check-numbers
+     * @secure
+     * @response `200` `CheckNumbersResponseDto` Números verificados com sucesso
+     * @response `400` `BadRequestErrorDto` Dados da requisição inválidos
+     * @response `403` `ForbiddenErrorDto` Acesso negado - Sem acesso ao recurso
+     * @response `404` `NotFoundErrorDto` Recurso não encontrado
+     */
+    managerInstancesControllerCheckNumbers: ({
+      instanceId,
+      ...query
+    }, data, params = {}) => this.request({
+      path: `/api/instances/${instanceId}/check-numbers`,
+      method: "POST",
+      body: data,
+      secure: true,
+      type: ContentType.Json,
+      format: "json",
+      ...params
+    }),
+    /**
+     * @description Envia um indicador de presença (digitando, gravando, online, etc.) para um contato
+     *
+     * @tags Instâncias
+     * @name ManagerInstancesControllerSendPresence
+     * @summary Enviar Indicador de Presença
+     * @request POST:/api/instances/{instanceId}/presence
+     * @secure
+     * @response `204` `void` Presença enviada com sucesso
+     * @response `400` `BadRequestErrorDto` Dados da requisição inválidos
+     * @response `403` `ForbiddenErrorDto` Acesso negado - Sem acesso ao recurso
+     * @response `404` `NotFoundErrorDto` Recurso não encontrado
+     */
+    managerInstancesControllerSendPresence: ({
+      instanceId,
+      ...query
+    }, data, params = {}) => this.request({
+      path: `/api/instances/${instanceId}/presence`,
+      method: "POST",
+      body: data,
+      secure: true,
+      type: ContentType.Json,
+      ...params
+    }),
+    /**
+     * @description Obtém a URL da foto de perfil de um contato
+     *
+     * @tags Instâncias
+     * @name ManagerInstancesControllerGetProfilePicture
+     * @summary Obter Foto de Perfil
+     * @request GET:/api/instances/{instanceId}/contacts/{phone}/profile-picture
+     * @secure
+     * @response `200` `void` Foto de perfil obtida com sucesso
+     * @response `400` `BadRequestErrorDto` Dados da requisição inválidos
+     * @response `403` `ForbiddenErrorDto` Acesso negado - Sem acesso ao recurso
+     * @response `404` `NotFoundErrorDto` Recurso não encontrado
+     */
+    managerInstancesControllerGetProfilePicture: ({
+      instanceId,
+      phone,
+      ...query
+    }, params = {}) => this.request({
+      path: `/api/instances/${instanceId}/contacts/${phone}/profile-picture`,
+      method: "GET",
+      secure: true,
+      ...params
+    }),
+    /**
+     * @description Bloqueia um contato no WhatsApp
+     *
+     * @tags Instâncias
+     * @name ManagerInstancesControllerBlockContact
+     * @summary Bloquear Contato
+     * @request POST:/api/instances/{instanceId}/contacts/{phone}/block
+     * @secure
+     * @response `204` `void` Contato bloqueado com sucesso
+     * @response `400` `BadRequestErrorDto` Dados da requisição inválidos
+     * @response `403` `ForbiddenErrorDto` Acesso negado - Sem acesso ao recurso
+     * @response `404` `NotFoundErrorDto` Recurso não encontrado
+     */
+    managerInstancesControllerBlockContact: ({
+      instanceId,
+      phone,
+      ...query
+    }, params = {}) => this.request({
+      path: `/api/instances/${instanceId}/contacts/${phone}/block`,
+      method: "POST",
+      secure: true,
+      ...params
+    }),
+    /**
+     * @description Desbloqueia um contato no WhatsApp
+     *
+     * @tags Instâncias
+     * @name ManagerInstancesControllerUnblockContact
+     * @summary Desbloquear Contato
+     * @request DELETE:/api/instances/{instanceId}/contacts/{phone}/block
+     * @secure
+     * @response `204` `void` Contato desbloqueado com sucesso
+     * @response `400` `BadRequestErrorDto` Dados da requisição inválidos
+     * @response `403` `ForbiddenErrorDto` Acesso negado - Sem acesso ao recurso
+     * @response `404` `NotFoundErrorDto` Recurso não encontrado
+     */
+    managerInstancesControllerUnblockContact: ({
+      instanceId,
+      phone,
+      ...query
+    }, params = {}) => this.request({
+      path: `/api/instances/${instanceId}/contacts/${phone}/block`,
+      method: "DELETE",
+      secure: true,
+      ...params
+    }),
+    /**
+     * @description Obtém informações detalhadas sobre um grupo do WhatsApp
+     *
+     * @tags Instâncias
+     * @name ManagerInstancesControllerGetGroupMetadata
+     * @summary Obter Metadados do Grupo
+     * @request GET:/api/instances/{instanceId}/groups/{groupId}
+     * @secure
+     * @response `200` `void` Metadados do grupo obtidos com sucesso
+     * @response `400` `BadRequestErrorDto` Dados da requisição inválidos
+     * @response `403` `ForbiddenErrorDto` Acesso negado - Sem acesso ao recurso
+     * @response `404` `NotFoundErrorDto` Recurso não encontrado
+     */
+    managerInstancesControllerGetGroupMetadata: ({
+      instanceId,
+      groupId,
+      ...query
+    }, params = {}) => this.request({
+      path: `/api/instances/${instanceId}/groups/${groupId}`,
+      method: "GET",
+      secure: true,
+      ...params
+    })
+  };
+  webhooks = {
+    /**
+     * @description Get the webhook configuration for the authenticated user. Returns null if no webhook is configured.
+     *
+     * @tags Webhooks
+     * @name WebhookControllerGetConfig
+     * @summary Get Webhook Configuration
+     * @request GET:/api/webhooks/config
+     * @secure
+     * @response `200` `WebhookConfigResponseDto` Webhook configuration retrieved successfully
+     * @response `401` `UnauthorizedErrorDto` Não autorizado - API key inválida ou ausente
+     */
+    webhookControllerGetConfig: (params = {}) => this.request({
+      path: `/api/webhooks/config`,
+      method: "GET",
+      secure: true,
+      format: "json",
+      ...params
+    }),
+    /**
+     * @description Create or update the webhook configuration for the authenticated user. Only one webhook URL can be configured per user, and all instance events will be sent to this URL.
+     *
+     * @tags Webhooks
+     * @name WebhookControllerUpsertConfig
+     * @summary Configure Webhook
+     * @request PUT:/api/webhooks/config
+     * @secure
+     * @response `200` `WebhookConfigResponseDto` Webhook configuration saved successfully
+     * @response `400` `BadRequestErrorDto` Dados da requisição inválidos
+     * @response `401` `UnauthorizedErrorDto` Não autorizado - API key inválida ou ausente
+     */
+    webhookControllerUpsertConfig: (data, params = {}) => this.request({
+      path: `/api/webhooks/config`,
+      method: "PUT",
+      body: data,
+      secure: true,
+      type: ContentType.Json,
+      format: "json",
+      ...params
+    }),
+    /**
+     * @description Delete the webhook configuration and all queued webhooks for the authenticated user.
+     *
+     * @tags Webhooks
+     * @name WebhookControllerDeleteConfig
+     * @summary Delete Webhook Configuration
+     * @request DELETE:/api/webhooks/config
+     * @secure
+     * @response `204` `void` Webhook configuration deleted successfully
+     * @response `401` `UnauthorizedErrorDto` Não autorizado - API key inválida ou ausente
+     */
+    webhookControllerDeleteConfig: (params = {}) => this.request({
+      path: `/api/webhooks/config`,
+      method: "DELETE",
+      secure: true,
+      ...params
+    }),
+    /**
+     * @description Get the status of the webhook delivery queue, including counts of pending, failed, paused, and delivered webhooks.
+     *
+     * @tags Webhooks
+     * @name WebhookControllerGetQueueStatus
+     * @summary Get Queue Status
+     * @request GET:/api/webhooks/queue/status
+     * @secure
+     * @response `200` `WebhookQueueStatusResponseDto` Queue status retrieved successfully
+     * @response `401` `UnauthorizedErrorDto` Não autorizado - API key inválida ou ausente
+     */
+    webhookControllerGetQueueStatus: (params = {}) => this.request({
+      path: `/api/webhooks/queue/status`,
+      method: "GET",
+      secure: true,
+      format: "json",
+      ...params
+    }),
+    /**
+     * @description Resume all paused and failed webhooks. This will unpause the webhook configuration and reset all paused/failed items to pending.
+     *
+     * @tags Webhooks
+     * @name WebhookControllerResumeAll
+     * @summary Resume Webhooks
+     * @request POST:/api/webhooks/queue/resume
+     * @secure
+     * @response `200` `WebhookResumeResponseDto` Webhooks resumed successfully
+     * @response `401` `UnauthorizedErrorDto` Não autorizado - API key inválida ou ausente
+     */
+    webhookControllerResumeAll: (params = {}) => this.request({
+      path: `/api/webhooks/queue/resume`,
+      method: "POST",
+      secure: true,
+      format: "json",
+      ...params
+    })
+  };
+  message = {
+    /**
+     * @description Envia uma mensagem de texto para um contato ou grupo do WhatsApp
+     *
+     * @tags Mensagens
+     * @name SendMessageControllerSendTextMessage
+     * @summary Enviar Mensagem de Texto
+     * @request POST:/api/message/{instanceId}/text
+     * @secure
+     * @response `201` `CommonSendMessageResponseDto` Mensagem enviada com sucesso
+     * @response `400` `void` Dados da requisição inválidos
+     * @response `404` `void` Instância do WhatsApp não encontrada
+     */
+    sendMessageControllerSendTextMessage: ({
+      instanceId,
+      ...query
+    }, data, params = {}) => this.request({
+      path: `/api/message/${instanceId}/text`,
+      method: "POST",
+      body: data,
+      secure: true,
+      type: ContentType.Json,
+      format: "json",
+      ...params
+    }),
+    /**
+     * @description Envia uma mensagem de imagem para um contato ou grupo do WhatsApp
+     *
+     * @tags Mensagens
+     * @name SendMessageControllerSendImageMessage
+     * @summary Enviar Mensagem de Imagem
+     * @request POST:/api/message/{instanceId}/image
+     * @secure
+     * @response `201` `CommonSendMessageResponseDto` Mensagem de imagem enviada com sucesso
+     * @response `400` `void` Dados da requisição inválidos ou formato de imagem inválido
+     * @response `404` `void` Instância do WhatsApp não encontrada
+     */
+    sendMessageControllerSendImageMessage: ({
+      instanceId,
+      ...query
+    }, data, params = {}) => this.request({
+      path: `/api/message/${instanceId}/image`,
+      method: "POST",
+      body: data,
+      secure: true,
+      type: ContentType.Json,
+      format: "json",
+      ...params
+    }),
+    /**
+     * @description Envia uma mensagem de vídeo para um contato ou grupo do WhatsApp
+     *
+     * @tags Mensagens
+     * @name SendMessageControllerSendVideoMessage
+     * @summary Enviar Mensagem de Vídeo
+     * @request POST:/api/message/{instanceId}/video
+     * @secure
+     * @response `201` `CommonSendMessageResponseDto` Mensagem de vídeo enviada com sucesso
+     * @response `400` `void` Dados da requisição inválidos ou formato de vídeo inválido
+     * @response `404` `void` Instância do WhatsApp não encontrada
+     */
+    sendMessageControllerSendVideoMessage: ({
+      instanceId,
+      ...query
+    }, data, params = {}) => this.request({
+      path: `/api/message/${instanceId}/video`,
+      method: "POST",
+      body: data,
+      secure: true,
+      type: ContentType.Json,
+      format: "json",
+      ...params
+    }),
+    /**
+     * @description Envia uma nota de voz para um contato ou grupo do WhatsApp
+     *
+     * @tags Mensagens
+     * @name SendMessageControllerSendAudioNoteMessage
+     * @summary Enviar Mensagem de Áudio (Nota de Voz)
+     * @request POST:/api/message/{instanceId}/audio-note
+     * @secure
+     * @response `201` `CommonSendMessageResponseDto` Nota de voz enviada com sucesso
+     * @response `400` `void` Dados da requisição inválidos ou formato de áudio inválido
+     * @response `404` `void` Instância do WhatsApp não encontrada
+     */
+    sendMessageControllerSendAudioNoteMessage: ({
+      instanceId,
+      ...query
+    }, data, params = {}) => this.request({
+      path: `/api/message/${instanceId}/audio-note`,
+      method: "POST",
+      body: data,
+      secure: true,
+      type: ContentType.Json,
+      format: "json",
+      ...params
+    }),
+    /**
+     * @description Envia um arquivo de áudio para um contato ou grupo do WhatsApp
+     *
+     * @tags Mensagens
+     * @name SendMessageControllerSendAudioFileMessage
+     * @summary Enviar Arquivo de Áudio
+     * @request POST:/api/message/{instanceId}/audio-file
+     * @secure
+     * @response `201` `CommonSendMessageResponseDto` Arquivo de áudio enviado com sucesso
+     * @response `400` `void` Dados da requisição inválidos ou formato de áudio inválido
+     * @response `404` `void` Instância do WhatsApp não encontrada
+     */
+    sendMessageControllerSendAudioFileMessage: ({
+      instanceId,
+      ...query
+    }, data, params = {}) => this.request({
+      path: `/api/message/${instanceId}/audio-file`,
+      method: "POST",
+      body: data,
+      secure: true,
+      type: ContentType.Json,
+      format: "json",
+      ...params
+    }),
+    /**
+     * @description Envia um arquivo de documento para um contato ou grupo do WhatsApp
+     *
+     * @tags Mensagens
+     * @name SendMessageControllerSendDocumentMessage
+     * @summary Enviar Documento
+     * @request POST:/api/message/{instanceId}/document
+     * @secure
+     * @response `201` `CommonSendMessageResponseDto` Documento enviado com sucesso
+     * @response `400` `void` Dados da requisição inválidos ou formato de documento inválido
+     * @response `404` `void` Instância do WhatsApp não encontrada
+     */
+    sendMessageControllerSendDocumentMessage: ({
+      instanceId,
+      ...query
+    }, data, params = {}) => this.request({
+      path: `/api/message/${instanceId}/document`,
+      method: "POST",
+      body: data,
+      secure: true,
+      type: ContentType.Json,
+      format: "json",
+      ...params
+    }),
+    /**
+     * @description Encaminha uma mensagem existente para outro contato ou grupo do WhatsApp
+     *
+     * @tags Mensagens
+     * @name SendMessageControllerForwardMessage
+     * @summary Encaminhar Mensagem
+     * @request POST:/api/message/{instanceId}/forward
+     * @secure
+     * @response `201` `CommonSendMessageResponseDto` Mensagem encaminhada com sucesso
+     * @response `400` `void` Dados da requisição inválidos ou mensagem não encontrada
+     * @response `404` `void` Instância do WhatsApp não encontrada
+     */
+    sendMessageControllerForwardMessage: ({
+      instanceId,
+      ...query
+    }, data, params = {}) => this.request({
+      path: `/api/message/${instanceId}/forward`,
+      method: "POST",
+      body: data,
+      secure: true,
+      type: ContentType.Json,
+      format: "json",
+      ...params
+    }),
+    /**
+     * @description Edita o conteúdo de uma mensagem de texto existente
+     *
+     * @tags Mensagens
+     * @name SendMessageControllerEditMessage
+     * @summary Editar Mensagem
+     * @request POST:/api/message/{instanceId}/edit
+     * @secure
+     * @response `201` `CommonSendMessageResponseDto` Mensagem editada com sucesso
+     * @response `400` `void` Dados da requisição inválidos ou mensagem não pode ser editada
+     * @response `404` `void` Instância do WhatsApp ou mensagem não encontrada
+     */
+    sendMessageControllerEditMessage: ({
+      instanceId,
+      ...query
+    }, data, params = {}) => this.request({
+      path: `/api/message/${instanceId}/edit`,
+      method: "POST",
+      body: data,
+      secure: true,
+      type: ContentType.Json,
+      format: "json",
+      ...params
+    }),
+    /**
+     * @description Marca uma mensagem como lida (envia confirmação de leitura)
+     *
+     * @tags Mensagens
+     * @name SendMessageControllerReadMessage
+     * @summary Marcar Mensagem como Lida
+     * @request POST:/api/message/{instanceId}/read
+     * @secure
+     * @response `201` `ReadMessageResponseDto` Mensagem marcada como lida com sucesso
+     * @response `400` `void` Dados da requisição inválidos
+     * @response `404` `void` Instância do WhatsApp ou mensagem não encontrada
+     */
+    sendMessageControllerReadMessage: ({
+      instanceId,
+      ...query
+    }, data, params = {}) => this.request({
+      path: `/api/message/${instanceId}/read`,
+      method: "POST",
+      body: data,
+      secure: true,
+      type: ContentType.Json,
+      format: "json",
+      ...params
+    }),
+    /**
+     * @description Envia uma localização geográfica para um contato ou grupo do WhatsApp
+     *
+     * @tags Mensagens
+     * @name SendMessageControllerSendLocationMessage
+     * @summary Enviar Localização
+     * @request POST:/api/message/{instanceId}/location
+     * @secure
+     * @response `201` `CommonSendMessageResponseDto` Localização enviada com sucesso
+     * @response `400` `void` Dados da requisição inválidos
+     * @response `404` `void` Instância do WhatsApp não encontrada
+     */
+    sendMessageControllerSendLocationMessage: ({
+      instanceId,
+      ...query
+    }, data, params = {}) => this.request({
+      path: `/api/message/${instanceId}/location`,
+      method: "POST",
+      body: data,
+      secure: true,
+      type: ContentType.Json,
+      format: "json",
+      ...params
+    }),
+    /**
+     * @description Envia um cartão de contato para um contato ou grupo do WhatsApp
+     *
+     * @tags Mensagens
+     * @name SendMessageControllerSendContactMessage
+     * @summary Enviar Contato
+     * @request POST:/api/message/{instanceId}/contact
+     * @secure
+     * @response `201` `CommonSendMessageResponseDto` Contato enviado com sucesso
+     * @response `400` `void` Dados da requisição inválidos
+     * @response `404` `void` Instância do WhatsApp não encontrada
+     */
+    sendMessageControllerSendContactMessage: ({
+      instanceId,
+      ...query
+    }, data, params = {}) => this.request({
+      path: `/api/message/${instanceId}/contact`,
+      method: "POST",
+      body: data,
+      secure: true,
+      type: ContentType.Json,
+      format: "json",
+      ...params
+    }),
+    /**
+     * @description Envia um sticker para um contato ou grupo do WhatsApp
+     *
+     * @tags Mensagens
+     * @name SendMessageControllerSendStickerMessage
+     * @summary Enviar Sticker
+     * @request POST:/api/message/{instanceId}/sticker
+     * @secure
+     * @response `201` `CommonSendMessageResponseDto` Sticker enviado com sucesso
+     * @response `400` `void` Dados da requisição inválidos ou formato de sticker inválido
+     * @response `404` `void` Instância do WhatsApp não encontrada
+     */
+    sendMessageControllerSendStickerMessage: ({
+      instanceId,
+      ...query
+    }, data, params = {}) => this.request({
+      path: `/api/message/${instanceId}/sticker`,
+      method: "POST",
+      body: data,
+      secure: true,
+      type: ContentType.Json,
+      format: "json",
+      ...params
+    }),
+    /**
+     * @description Adiciona uma reação (emoji) a uma mensagem existente
+     *
+     * @tags Mensagens
+     * @name SendMessageControllerSendReaction
+     * @summary Enviar Reação
+     * @request POST:/api/message/{instanceId}/reaction
+     * @secure
+     * @response `204` `void` Reação enviada com sucesso
+     * @response `400` `void` Dados da requisição inválidos
+     * @response `404` `void` Instância do WhatsApp ou mensagem não encontrada
+     */
+    sendMessageControllerSendReaction: ({
+      instanceId,
+      ...query
+    }, data, params = {}) => this.request({
+      path: `/api/message/${instanceId}/reaction`,
+      method: "POST",
+      body: data,
+      secure: true,
+      type: ContentType.Json,
+      ...params
+    }),
+    /**
+     * @description Exclui uma mensagem para todos no chat
+     *
+     * @tags Mensagens
+     * @name SendMessageControllerDeleteMessage
+     * @summary Excluir Mensagem
+     * @request DELETE:/api/message/{instanceId}/delete
+     * @secure
+     * @response `204` `void` Mensagem excluída com sucesso
+     * @response `400` `void` Dados da requisição inválidos ou mensagem não pode ser excluída
+     * @response `404` `void` Instância do WhatsApp ou mensagem não encontrada
+     */
+    sendMessageControllerDeleteMessage: ({
+      instanceId,
+      ...query
+    }, data, params = {}) => this.request({
+      path: `/api/message/${instanceId}/delete`,
+      method: "DELETE",
+      body: data,
+      secure: true,
+      type: ContentType.Json,
+      ...params
+    }),
+    /**
+     * @description Obtém um link de download para conteúdo de mídia de uma mensagem
+     *
+     * @tags Mensagens
+     * @name SendMessageControllerGetMessageMediaDownloadLink
+     * @summary Obter Link de Download de Mídia
+     * @request GET:/api/message/{instanceId}/media-download-link/{messageId}
+     * @secure
+     * @response `200` `GetMessageMediaDownloadLinkResponseDto` Link de download de mídia obtido com sucesso
+     * @response `400` `void` Formato de ID da mensagem inválido
+     * @response `404` `void` Instância do WhatsApp, mensagem ou mídia não encontrada
+     */
+    sendMessageControllerGetMessageMediaDownloadLink: ({
+      instanceId,
+      messageId,
+      ...query
+    }, params = {}) => this.request({
+      path: `/api/message/${instanceId}/media-download-link/${messageId}`,
+      method: "GET",
+      secure: true,
+      format: "json",
+      ...params
+    })
+  };
+}
+
 exports.AuthenticationError = AuthenticationError;
-exports.ConnectionStatus = ConnectionStatus;
 exports.InstanceNotFoundError = InstanceNotFoundError;
 exports.InstanceStatus = InstanceStatus;
-exports.MessageAckStatus = MessageAckStatus;
-exports.MessageType = MessageType;
+exports.NetworkError = NetworkError;
 exports.RateLimitError = RateLimitError;
+exports.TimeoutError = TimeoutError;
 exports.ValidationError = ValidationError;
-exports.WebhookEventType = WebhookEventType;
 exports.WebhookQueueStatus = WebhookQueueStatus;
 exports.ZapyApiError = ZapyApiError;
 exports.ZapyClient = ZapyClient;
 exports.ZapyError = ZapyError;
+exports.ZapyEventTypes = ZapyEventTypes;
+exports.ZapyRestApi = Api;
 exports.createClient = createClient;
 exports.extractPhone = extractPhone;
-exports.isContactCreatedEvent = isContactCreatedEvent;
-exports.isContactDeduplicatedEvent = isContactDeduplicatedEvent;
-exports.isContactUpdatedEvent = isContactUpdatedEvent;
+exports.isAudioMessage = isAudioMessage;
+exports.isCallMessage = isCallMessage;
+exports.isContactMessage = isContactMessage;
+exports.isDeletedMessage = isDeletedMessage;
+exports.isDocumentMessage = isDocumentMessage;
+exports.isEditedMessage = isEditedMessage;
 exports.isGroup = isGroup;
-exports.isMessageEvent = isMessageEvent;
-exports.isMessageStatusEvent = isMessageStatusEvent;
-exports.isQRCodeEvent = isQRCodeEvent;
+exports.isImageMessage = isImageMessage;
+exports.isLiveLocationMessage = isLiveLocationMessage;
+exports.isLocationMessage = isLocationMessage;
+exports.isMediaMessage = isMediaMessage;
+exports.isPollMessage = isPollMessage;
+exports.isPollVoteMessage = isPollVoteMessage;
+exports.isReactionMessage = isReactionMessage;
+exports.isStickerMessage = isStickerMessage;
+exports.isTextMessage = isTextMessage;
+exports.isUnsupportedMessage = isUnsupportedMessage;
 exports.isValidPhone = isValidPhone;
+exports.isVideoMessage = isVideoMessage;
 exports.normalizePhone = normalizePhone;
 exports.verifyWebhookSignature = verifyWebhookSignature;
 exports.verifyWebhookSignatureAsync = verifyWebhookSignatureAsync;