@wppconnect/wa-js 3.23.2 → 4.0.2-alpha.0

package/dist/catalog/functions/updateCartEnabled.d.ts

@@ -1,5 +1,5 @@
 /*!
- * Copyright 2022 WPPConnect Team
+ * Copyright 2026 WPPConnect Team
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -13,18 +13,25 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { z } from 'zod';
+declare const catalogUpdateCartEnabledSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+}, z.core.$strip>;
+export type CatalogUpdateCartEnabledInput = z.infer<typeof catalogUpdateCartEnabledSchema>;
+export type CatalogUpdateCartEnabledOutput = void;
 /**
- * Get your current catalog
+ * Enable or disable the cart feature in your catalog
  *
  * @example
  * ```javascript
- * // Set product visibility hidden
- * const myCatalog = await WPP.catalog.setProductVisibility(54985569989897, true);
- * ```
- * // Set product visible
- * const myCatalog = await WPP.catalog.setProductVisibility(54985569989897, false);
+ * // Enable cart
+ * await WPP.catalog.updateCartEnabled({ enabled: true });
+ *
+ * // Disable cart
+ * await WPP.catalog.updateCartEnabled({ enabled: false });
  * ```
  *
- * @return Return sucess of product visibility set
+ * @category Catalog
  */
-export declare function updateCartEnabled(enabled: boolean): Promise<any>;
+export declare function updateCartEnabled(params: CatalogUpdateCartEnabledInput): Promise<CatalogUpdateCartEnabledOutput>;
+export {};

package/dist/chat/functions/archive.d.ts

@@ -13,42 +13,37 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Wid } from '../../whatsapp';
+import { z } from 'zod';
+declare const chatArchiveSchema: z.ZodObject<{
+    chatId: z.ZodString;
+    archive: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ChatArchiveInput = z.infer<typeof chatArchiveSchema>;
+export type ChatArchiveOutput = void;
 /**
  * Archive a chat
  *
  * @example
  * ```javascript
  * // Archive a chat
- * WPP.chat.archive('[number]@c.us');
+ * WPP.chat.archive({ chatId: '[number]@c.us' });
  *
  * // Unarchive a chat
- * WPP.chat.archive('[number]@c.us', false);
+ * WPP.chat.archive({ chatId: '[number]@c.us', archive: false });
  * // or
- * WPP.chat.unarchive('[number]@c.us');
+ * WPP.chat.unarchive({ chatId: '[number]@c.us' });
  * ```
  * @category Chat
  */
-export declare function archive(chatId: string | Wid, archive?: boolean): Promise<{
-    wid: Wid;
-    archive: boolean;
-}>;
+export declare function archive(params: ChatArchiveInput): Promise<ChatArchiveOutput>;
 /**
  * Unarchive a chat
  *
  * @alias archive
  *
- * @example
- * ```javascript
- * // Unarchive a chat
- * WPP.chat.unarchive('[number]@c.us');
- *
- * // Alias for
- * WPP.chat.archive('[number]@c.us', false);
- * ```
  * @category Chat
  */
-export declare function unarchive(chatId: string | Wid): Promise<{
-    wid: Wid;
-    archive: boolean;
-}>;
+export declare function unarchive(params: {
+    chatId: string;
+}): Promise<void>;
+export {};

package/dist/chat/functions/canMarkPlayed.d.ts

@@ -13,15 +13,20 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Stringable } from '../../types';
-import { MsgKey, MsgModel } from '../../whatsapp';
+import { z } from 'zod';
+declare const chatCanMarkPlayedSchema: z.ZodObject<{
+    messageId: z.ZodString;
+}, z.core.$strip>;
+export type ChatCanMarkPlayedInput = z.infer<typeof chatCanMarkPlayedSchema>;
+export type ChatCanMarkPlayedOutput = any;
 /**
  * Get if message can played
  *
  * @example
  * ```javascript
- * WPP.chat.canMarkPlayed('[message_id]');
+ * WPP.chat.canMarkPlayed({ messageId: '[message_id]' });
  * ```
  * @category Message
  */
-export declare function canMarkPlayed(messageId: string | MsgKey | MsgModel | Stringable): Promise<any>;
+export declare function canMarkPlayed(params: ChatCanMarkPlayedInput): Promise<ChatCanMarkPlayedOutput>;
+export {};

package/dist/chat/functions/canMute.d.ts

@@ -1,5 +1,5 @@
 /*!
- * Copyright 2021 WPPConnect Team
+ * Copyright 2026 WPPConnect Team
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -13,7 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Wid } from '../../whatsapp';
+import { z } from 'zod';
+declare const chatCanMuteSchema: z.ZodObject<{
+    chatId: z.ZodString;
+}, z.core.$strip>;
+export type ChatCanMuteInput = z.infer<typeof chatCanMuteSchema>;
+export type ChatCanMuteOutput = boolean;
 /**
  * Check if is possible to mute this chat
  *
@@ -24,4 +29,5 @@ import { Wid } from '../../whatsapp';
  *
  * @category Chat
  */
-export declare function canMute(chatId: string | Wid): boolean;
+export declare function canMute(params: ChatCanMuteInput): ChatCanMuteOutput;
+export {};

package/dist/chat/functions/canReply.d.ts

@@ -13,15 +13,20 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Stringable } from '../../types';
-import { MsgKey, MsgModel } from '../../whatsapp';
+import { z } from 'zod';
+declare const chatCanReplySchema: z.ZodObject<{
+    messageId: z.ZodString;
+}, z.core.$strip>;
+export type ChatCanReplyInput = z.infer<typeof chatCanReplySchema>;
+export type ChatCanReplyOutput = boolean;
 /**
  * Get if message can reply
  *
  * @example
  * ```javascript
- * WPP.chat.canReply('[message_id]');
+ * WPP.chat.canReply({ messageId: '[message_id]' });
  * ```
  * @category Message
  */
-export declare function canReply(messageId: string | MsgKey | MsgModel | Stringable): Promise<boolean>;
+export declare function canReply(params: ChatCanReplyInput): Promise<ChatCanReplyOutput>;
+export {};

package/dist/chat/functions/clear.d.ts

@@ -13,14 +13,22 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { z } from 'zod';
 import { Wid } from '../../whatsapp';
+declare const chatClearSchema: z.ZodObject<{
+    chatId: z.ZodString;
+    keepStarred: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ChatClearInput = z.infer<typeof chatClearSchema>;
+export type ChatClearOutput = {
+    wid: Wid;
+    status: number;
+    keepStarred: boolean;
+};
 /**
  * Clear a chat message
  *
  * @category Chat
  */
-export declare function clear(chatId: string | Wid, keepStarred?: boolean): Promise<{
-    wid: Wid;
-    status: number;
-    keepStarred: boolean;
-}>;
+export declare function clear(params: ChatClearInput): Promise<ChatClearOutput>;
+export {};

package/dist/chat/functions/closeChat.d.ts

@@ -1,5 +1,5 @@
 /*!
- * Copyright 2024 WPPConnect Team
+ * Copyright 2026 WPPConnect Team
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+export type ChatCloseChatOutput = boolean;
 /**
  * Close the chat tab
  *
@@ -23,4 +24,4 @@
  *
  * @category Chat
  */
-export declare function closeChat(): Promise<boolean>;
+export declare function closeChat(): Promise<ChatCloseChatOutput>;

package/dist/chat/functions/delete.d.ts

@@ -13,14 +13,20 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { z } from 'zod';
 import { Wid } from '../../whatsapp';
+declare const chatDeleteSchema: z.ZodObject<{
+    chatId: z.ZodString;
+}, z.core.$strip>;
+export type ChatDeleteInput = z.infer<typeof chatDeleteSchema>;
+export type ChatDeleteOutput = {
+    wid: Wid;
+    status: number;
+};
 /**
  * Delete a chat
  *
  * @category Chat
  */
-declare function _delete(chatId: string | Wid): Promise<{
-    wid: Wid;
-    status: number;
-}>;
+declare function _delete(params: ChatDeleteInput): Promise<ChatDeleteOutput>;
 export { _delete as delete };

package/dist/chat/functions/{deleteMessage.d.ts → deleteMessages.d.ts}

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Wid } from '../../whatsapp';
+import { z } from 'zod';
 import { SendMsgResult } from '../../whatsapp/enums';
 export interface DeleteMessageReturn {
     id: string;
@@ -22,21 +22,30 @@ export interface DeleteMessageReturn {
     isDeleted: boolean;
     isSentByMe: boolean;
 }
+declare const chatDeleteMessageSchema: z.ZodObject<{
+    chatId: z.ZodString;
+    ids: z.ZodArray<z.ZodString>;
+    deleteMediaInDevice: z.ZodOptional<z.ZodBoolean>;
+    revoke: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ChatDeleteMessageInput = z.infer<typeof chatDeleteMessageSchema>;
+export type ChatDeleteMessageOutput = DeleteMessageReturn[];
 /**
  * Delete a message
  *
  * @example
  * ```javascript
  * // Delete a message
- * WPP.chat.deleteMessage('[number]@c.us', 'msgid');
+ * WPP.chat.deleteMessage({ chatId: '[number]@c.us', ids: ['msgid'] });
  * // Delete a list of messages
- * WPP.chat.deleteMessage('[number]@c.us', ['msgid1', 'msgid2]);
+ * WPP.chat.deleteMessage({ chatId: '[number]@c.us', ids: ['msgid1', 'msgid2'] });
  * // Delete a message and delete media
- * WPP.chat.deleteMessage('[number]@c.us', 'msgid', true);
+ * WPP.chat.deleteMessage({ chatId: '[number]@c.us', ids: ['msgid'], deleteMediaInDevice: true });
  * // Revoke a message
- * WPP.chat.deleteMessage('[number]@c.us', 'msgid', true, true);
+ * WPP.chat.deleteMessage({ chatId: '[number]@c.us', ids: ['msgid'], deleteMediaInDevice: true, revoke: true });
  * ```
  *
  * @category Message
  */
-export declare function deleteMessage(chatId: string | Wid, ids: string | string[], deleteMediaInDevice?: boolean, revoke?: boolean): Promise<DeleteMessageReturn | DeleteMessageReturn[]>;
+export declare function deleteMessages(params: ChatDeleteMessageInput): Promise<ChatDeleteMessageOutput>;
+export {};

package/dist/chat/functions/downloadMedia.d.ts

@@ -13,17 +13,24 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { z } from 'zod';
+declare const chatDownloadMediaSchema: z.ZodObject<{
+    msgId: z.ZodString;
+}, z.core.$strip>;
+export type ChatDownloadMediaInput = z.infer<typeof chatDownloadMediaSchema>;
+export type ChatDownloadMediaOutput = Blob;
 /**
  * Download the blob of a media message
  *
  * ```javascript
  * // Get a blob file
- * await WPP.chat.downloadMedia('true_[number]@c.us_ABCDEF');
+ * await WPP.chat.downloadMedia({ msgId: 'true_[number]@c.us_ABCDEF' });
  *
  * // Get a base64Content
- * await WPP.chat.downloadMedia('true_[number]@c.us_ABCDEF').then(WPP.util.blobToBase64);
+ * await WPP.chat.downloadMedia({ msgId: 'true_[number]@c.us_ABCDEF' }).then(WPP.util.blobToBase64);
  * ```
  *
  * @category Message
  */
-export declare function downloadMedia(id: string): Promise<Blob>;
+export declare function downloadMedia(params: ChatDownloadMediaInput): Promise<ChatDownloadMediaOutput>;
+export {};

package/dist/chat/functions/editMessage.d.ts

@@ -13,18 +13,45 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { MsgKey } from '../../whatsapp';
-import { LinkPreviewOptions, SendMessageOptions, SendMessageReturn } from '..';
-export type EditMessageOptions = SendMessageOptions & LinkPreviewOptions;
+import { z } from 'zod';
+import { SendMessageReturn } from '..';
+declare const chatEditMessageSchema: z.ZodObject<{
+    msgId: z.ZodString;
+    newText: z.ZodString;
+    options: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        linkPreview: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+            title: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            canonicalUrl: z.ZodOptional<z.ZodString>;
+            matchedText: z.ZodOptional<z.ZodString>;
+            richPreviewType: z.ZodOptional<z.ZodNumber>;
+            thumbnail: z.ZodOptional<z.ZodString>;
+            doNotPlayInline: z.ZodBoolean;
+        }, z.core.$strip>]>>;
+    }, z.core.$strip>, z.ZodObject<{
+        createChat: z.ZodOptional<z.ZodBoolean>;
+        detectMentioned: z.ZodOptional<z.ZodBoolean>;
+        markIsRead: z.ZodOptional<z.ZodBoolean>;
+        messageId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<import("../../whatsapp").MsgKey, import("../../whatsapp").MsgKey>]>>;
+        mentionedList: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<import("../../whatsapp").Wid, import("../../whatsapp").Wid>]>>>;
+        quotedMsg: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<import("../../whatsapp").MsgKey, import("../../whatsapp").MsgKey>, z.ZodCustom<import("../../whatsapp").MsgModel, import("../../whatsapp").MsgModel>]>>;
+        quotedMsgPayload: z.ZodOptional<z.ZodString>;
+        waitForAck: z.ZodOptional<z.ZodBoolean>;
+        delay: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>]>>;
+}, z.core.$strip>;
+export type ChatEditMessageInput = z.infer<typeof chatEditMessageSchema>;
+export type ChatEditMessageOutput = SendMessageReturn;
 /**
  * Edit a message previously sent.
  *
  * @example
- * WPP.chat.editMessage('true_[number]@c.us_[msgId]', 'New text for message', {
+ * WPP.chat.editMessage({ msgId: 'true_[number]@c.us_[msgId]', newText: 'New text for message', options: {
  *   linkPreview: true,
  *   mentionedJidList: ['5521985232287@c.us']
- * });
+ * } });
  * ```
  * @category Message
  */
-export declare function editMessage(msgId: string | MsgKey, newText: string, options?: EditMessageOptions): Promise<SendMessageReturn>;
+export declare function editMessage(params: ChatEditMessageInput): Promise<ChatEditMessageOutput>;
+export {};

package/dist/chat/functions/find.d.ts

@@ -13,7 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { ChatModel, Wid } from '../../whatsapp';
+import { z } from 'zod';
+import { ChatModel } from '../../whatsapp';
+declare const chatFindSchema: z.ZodObject<{
+    chatId: z.ZodString;
+}, z.core.$strip>;
+export type ChatFindInput = z.infer<typeof chatFindSchema>;
+export type ChatFindOutput = ChatModel;
 /**
  * Find a chat by id
  *
@@ -21,4 +27,5 @@ import { ChatModel, Wid } from '../../whatsapp';
  *
  * @category Chat
  */
-export declare function find(chatId: string | Wid): Promise<ChatModel>;
+export declare function find(params: ChatFindInput): Promise<ChatFindOutput>;
+export {};

package/dist/chat/functions/forwardMessage.d.ts

@@ -13,20 +13,27 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { MsgKey, Wid } from '../../whatsapp';
-export interface ForwardMessageOptions {
-    displayCaptionText?: boolean;
-    multicast?: boolean;
-}
+import { z } from 'zod';
+declare const chatForwardMessageSchema: z.ZodObject<{
+    toChatId: z.ZodString;
+    msgId: z.ZodString;
+    options: z.ZodOptional<z.ZodObject<{
+        displayCaptionText: z.ZodOptional<z.ZodBoolean>;
+        multicast: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ChatForwardMessageInput = z.infer<typeof chatForwardMessageSchema>;
+export type ChatForwardMessageOutput = boolean;
 /**
  * Forward message to a chat
  *
  * @example
  * ```javascript
  * // Forward message
- * WPP.chat.forwardMessage('[number]@c.us', 'true_[number]@c.us_ABCDEF');
+ * WPP.chat.forwardMessage({ toChatId: '[number]@c.us', msgId: 'true_[number]@c.us_ABCDEF' });
  * ```
  * @category Message
  * @return  {any} Any
  */
-export declare function forwardMessage(toChatId: string | Wid, msgId: string | MsgKey, options?: ForwardMessageOptions): Promise<boolean>;
+export declare function forwardMessage(params: ChatForwardMessageInput): Promise<ChatForwardMessageOutput>;
+export {};

package/dist/chat/functions/forwardMessages.d.ts

@@ -13,21 +13,28 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { MsgKey, MsgModel, Wid } from '../../whatsapp';
-export interface ForwardMessagesOptions {
-    displayCaptionText?: boolean;
-    multicast?: boolean;
-    appendedText?: boolean;
-}
+import { z } from 'zod';
+declare const chatForwardMessagesSchema: z.ZodObject<{
+    toChatId: z.ZodString;
+    msgsIds: z.ZodArray<z.ZodString>;
+    options: z.ZodOptional<z.ZodObject<{
+        displayCaptionText: z.ZodOptional<z.ZodBoolean>;
+        multicast: z.ZodOptional<z.ZodBoolean>;
+        appendedText: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ChatForwardMessagesInput = z.infer<typeof chatForwardMessagesSchema>;
+export type ChatForwardMessagesOutput = Array<any>;
 /**
  * Forward many messages to a chat
  *
  * @example
  * ```javascript
  * // Forward messages
- * WPP.chat.forwardMessagesWhatsApp('[number]@c.us', ['true_[number]@c.us_ABCDEF', ...]);
+ * WPP.chat.forwardMessages({ toChatId: '[number]@c.us', msgsId: ['true_[number]@c.us_ABCDEF', ...] });
  * ```
  * @category Message
  * @return  {any} Any
  */
-export declare function forwardMessages(toChatId: string | Wid, msgsId: string[] | MsgKey[] | MsgModel[], options?: ForwardMessagesOptions): Promise<Array<any>>;
+export declare function forwardMessages(params: ChatForwardMessagesInput): Promise<ChatForwardMessagesOutput>;
+export {};

package/dist/chat/functions/generateMessageID.d.ts

@@ -13,10 +13,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { ChatModel, MsgKey, Wid } from '../../whatsapp';
+import { z } from 'zod';
+import { MsgKey } from '../../whatsapp';
+declare const chatGenerateMessageIDSchema: z.ZodObject<{
+    chatId: z.ZodString;
+}, z.core.$strip>;
+export type ChatGenerateMessageIDInput = z.infer<typeof chatGenerateMessageIDSchema>;
+export type ChatGenerateMessageIDOutput = MsgKey;
 /**
  * Generate a new message ID
  *
  * @category Message
  */
-export declare function generateMessageID(chat: string | ChatModel | Wid): Promise<MsgKey>;
+export declare function generateMessageID(params: ChatGenerateMessageIDInput): Promise<ChatGenerateMessageIDOutput>;
+export {};

package/dist/chat/functions/get.d.ts

@@ -13,10 +13,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { ChatModel, Wid } from '../../whatsapp';
+import { z } from 'zod';
+import { ChatModel } from '../../whatsapp';
+declare const chatGetSchema: z.ZodObject<{
+    chatId: z.ZodString;
+}, z.core.$strip>;
+export type ChatGetInput = z.infer<typeof chatGetSchema>;
+export type ChatGetOutput = ChatModel | undefined;
 /**
  * Find a chat by id
  *
  * @category Chat
  */
-export declare function get(chatId: string | Wid): ChatModel | undefined;
+export declare function get(params: ChatGetInput): ChatGetOutput;
+export {};

package/dist/chat/functions/getActiveChat.d.ts

@@ -1,5 +1,5 @@
 /*!
- * Copyright 2021 WPPConnect Team
+ * Copyright 2026 WPPConnect Team
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -13,6 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { ChatModel } from '../../whatsapp';
+export type ChatGetActiveChatOutput = ChatModel | undefined;
 /**
  * Return the current active chat
  *
@@ -27,4 +29,4 @@
  * ```
  * @category Chat
  */
-export declare function getActiveChat(): import("../../whatsapp").ChatModel | undefined;
+export declare function getActiveChat(): ChatGetActiveChatOutput;

package/dist/chat/functions/getLastSeen.d.ts

@@ -13,7 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Wid } from '../../whatsapp';
+import { z } from 'zod';
+declare const chatGetLastSeenSchema: z.ZodObject<{
+    chatId: z.ZodString;
+}, z.core.$strip>;
+export type ChatGetLastSeenInput = z.infer<typeof chatGetLastSeenSchema>;
+export type ChatGetLastSeenOutput = number | boolean;
 /**
  * Get timestamp of last seen
  * @example
@@ -22,4 +27,5 @@ import { Wid } from '../../whatsapp';
  * ```
  * @category Chat
  */
-export declare function getLastSeen(chatId: string | Wid): Promise<number | boolean>;
+export declare function getLastSeen(params: ChatGetLastSeenInput): Promise<ChatGetLastSeenOutput>;
+export {};

package/dist/chat/functions/getMessageACK.d.ts

@@ -13,7 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { MsgKey, Wid } from '../../whatsapp';
+import { z } from 'zod';
+import { Wid } from '../../whatsapp';
 import { ACK } from '../../whatsapp/enums';
 export interface ParticipantStatusACK {
     id: string;
@@ -22,13 +23,25 @@ export interface ParticipantStatusACK {
     readAt?: number;
     playedAt?: number;
 }
+declare const chatGetMessageACKSchema: z.ZodObject<{
+    msgId: z.ZodString;
+}, z.core.$strip>;
+export type ChatGetMessageACKInput = z.infer<typeof chatGetMessageACKSchema>;
+export type ChatGetMessageACKOutput = {
+    ack: ACK;
+    fromMe: boolean;
+    deliveryRemaining: number;
+    readRemaining: number;
+    playedRemaining: number;
+    participants: ParticipantStatusACK[];
+};
 /**
  * Get message ACK from a message
  *
  * @example
  * ```javascript
  * // Get message ACK
- * const ackInfo = await WPP.chat.getMessageACK('true_[number]@c.us_ABCDEF');
+ * const ackInfo = await WPP.chat.getMessageACK({ msgId: 'true_[number]@c.us_ABCDEF' });
  *
  * console.log(ackInfo.deliveryRemaining); // Delivery Remaining
  * console.log(ackInfo.readRemaining); // Read Remaining
@@ -48,13 +61,7 @@ export interface ParticipantStatusACK {
  * const played = ackInfo.participants.filter(p => p.playedAt);
  * ```
  * @category Message
- * @return  {any} Any
+ * @return  {Promise<ChatGetMessageACKOutput>} Message ACK information
  */
-export declare function getMessageACK(msgId: string | MsgKey): Promise<{
-    ack: ACK;
-    fromMe: boolean;
-    deliveryRemaining: number;
-    readRemaining: number;
-    playedRemaining: number;
-    participants: ParticipantStatusACK[];
-}>;
+export declare function getMessageACK(params: ChatGetMessageACKInput): Promise<ChatGetMessageACKOutput>;
+export {};

package/dist/chat/functions/getMessageById.d.ts

@@ -13,21 +13,23 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { MsgKey, MsgModel } from '../../whatsapp';
+import { z } from 'zod';
+import { MsgModel } from '../../whatsapp';
+declare const chatGetMessageByIdSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export type ChatGetMessageByIdInput = z.infer<typeof chatGetMessageByIdSchema>;
+export type ChatGetMessageByIdOutput = MsgModel;
 /**
- * Get message by a single ID or array of IDs
+ * Get message by ID
  *
  * @example
  * ```javascript
- * // Single message
- * WPP.chat.getMessageById('true_[number]@c.us_ABCDEF');
- *
- * // List of messages
- * WPP.chat.getMessageById(['true_[number]@c.us_ABCDEF', 'false_[number]@c.us_789456']);
+ * WPP.chat.getMessageById({ id: 'true_[number]@c.us_ABCDEF' });
  * ```
  *
  * @category Message
- * @return  {Promise<MsgModel> | Promise<MsgModel[]>} List of raw messages
+ * @return  {Promise<MsgModel>} Raw message
  */
-export declare function getMessageById(id: string | MsgKey): Promise<MsgModel>;
-export declare function getMessageById(ids: (string | MsgKey)[]): Promise<MsgModel[]>;
+export declare function getMessageById(params: ChatGetMessageByIdInput): Promise<ChatGetMessageByIdOutput>;
+export {};