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

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

@@ -1,5 +1,5 @@
 /*!
- * Copyright 2026 WPPConnect Team
+ * Copyright 2021 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,26 +13,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { z } from 'zod';
 import { ProductModel } from '../../whatsapp';
-declare const catalogRemoveProductImageSchema: z.ZodObject<{
-    productId: z.ZodString;
-    index: z.ZodString;
-}, z.core.$strip>;
-export type CatalogRemoveProductImageInput = z.infer<typeof catalogRemoveProductImageSchema>;
-export type CatalogRemoveProductImageOutput = ProductModel;
 /**
- * Remove an additional image from a product by its index
+ * Remove image on product
+ * This function remove additional images of product
+ * for change main image use @changeProductImage
  *
  * @example
  * ```javascript
- * await WPP.catalog.removeProductImage({
- *   productId: '[productId]',
- *   index: '0',
- * });
+ * await WPP.catalog.removeProductImage('68685985868923', '0');
  * ```
- *
+ * @param index - Index of array additionalImageCdnUrl
  * @category Catalog
  */
-export declare function removeProductImage(params: CatalogRemoveProductImageInput): Promise<CatalogRemoveProductImageOutput>;
-export {};
+export declare function removeProductImage(productId: string, index: string): Promise<ProductModel>;

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

@@ -1,5 +1,5 @@
 /*!
- * Copyright 2026 WPPConnect Team
+ * Copyright 2022 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,27 +13,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { z } from 'zod';
-import { ProductModel } from '../../whatsapp';
-declare const catalogSetProductVisibilitySchema: z.ZodObject<{
-    productId: z.ZodString;
-    isHidden: z.ZodBoolean;
-}, z.core.$strip>;
-export type CatalogSetProductVisibilityInput = z.infer<typeof catalogSetProductVisibilitySchema>;
-export type CatalogSetProductVisibilityOutput = ProductModel;
 /**
- * Show or hide a product in your catalog
+ * Get your current catalog
  *
  * @example
  * ```javascript
- * // Hide a product
- * await WPP.catalog.setProductVisibility({ productId: '[productId]', isHidden: true });
- *
- * // Make a product visible
- * await WPP.catalog.setProductVisibility({ productId: '[productId]', isHidden: false });
+ * // Set product visibility hidden
+ * const myCatalog = await WPP.catalog.setProductVisibility(54985569989897, true);
+ * ```
+ * // Set product visible
+ * const myCatalog = await WPP.catalog.setProductVisibility(54985569989897, false);
  * ```
  *
- * @category Catalog
+ * @return Return sucess of product visibility set
  */
-export declare function setProductVisibility(params: CatalogSetProductVisibilityInput): Promise<CatalogSetProductVisibilityOutput>;
-export {};
+export declare function setProductVisibility(productId: any, isHidden: boolean): Promise<any>;

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

@@ -1,5 +1,5 @@
 /*!
- * Copyright 2026 WPPConnect Team
+ * Copyright 2022 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,25 +13,18 @@
  * 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;
 /**
- * Enable or disable the cart feature in your catalog
+ * Get your current catalog
  *
  * @example
  * ```javascript
- * // Enable cart
- * await WPP.catalog.updateCartEnabled({ enabled: true });
- *
- * // Disable cart
- * await WPP.catalog.updateCartEnabled({ enabled: false });
+ * // Set product visibility hidden
+ * const myCatalog = await WPP.catalog.setProductVisibility(54985569989897, true);
+ * ```
+ * // Set product visible
+ * const myCatalog = await WPP.catalog.setProductVisibility(54985569989897, false);
  * ```
  *
- * @category Catalog
+ * @return Return sucess of product visibility set
  */
-export declare function updateCartEnabled(params: CatalogUpdateCartEnabledInput): Promise<CatalogUpdateCartEnabledOutput>;
-export {};
+export declare function updateCartEnabled(enabled: boolean): Promise<any>;

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

@@ -13,37 +13,42 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-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;
+import { Wid } from '../../whatsapp';
 /**
  * Archive a chat
  *
  * @example
  * ```javascript
  * // Archive a chat
- * WPP.chat.archive({ chatId: '[number]@c.us' });
+ * WPP.chat.archive('[number]@c.us');
  *
  * // Unarchive a chat
- * WPP.chat.archive({ chatId: '[number]@c.us', archive: false });
+ * WPP.chat.archive('[number]@c.us', false);
  * // or
- * WPP.chat.unarchive({ chatId: '[number]@c.us' });
+ * WPP.chat.unarchive('[number]@c.us');
  * ```
  * @category Chat
  */
-export declare function archive(params: ChatArchiveInput): Promise<ChatArchiveOutput>;
+export declare function archive(chatId: string | Wid, archive?: boolean): Promise<{
+    wid: Wid;
+    archive: boolean;
+}>;
 /**
  * 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(params: {
-    chatId: string;
-}): Promise<void>;
-export {};
+export declare function unarchive(chatId: string | Wid): Promise<{
+    wid: Wid;
+    archive: boolean;
+}>;

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

@@ -13,20 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-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;
+import { Stringable } from '../../types';
+import { MsgKey, MsgModel } from '../../whatsapp';
 /**
  * Get if message can played
  *
  * @example
  * ```javascript
- * WPP.chat.canMarkPlayed({ messageId: '[message_id]' });
+ * WPP.chat.canMarkPlayed('[message_id]');
  * ```
  * @category Message
  */
-export declare function canMarkPlayed(params: ChatCanMarkPlayedInput): Promise<ChatCanMarkPlayedOutput>;
-export {};
+export declare function canMarkPlayed(messageId: string | MsgKey | MsgModel | Stringable): Promise<any>;

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

@@ -1,5 +1,5 @@
 /*!
- * Copyright 2026 WPPConnect Team
+ * Copyright 2021 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,12 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-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;
+import { Wid } from '../../whatsapp';
 /**
  * Check if is possible to mute this chat
  *
@@ -29,5 +24,4 @@ export type ChatCanMuteOutput = boolean;
  *
  * @category Chat
  */
-export declare function canMute(params: ChatCanMuteInput): ChatCanMuteOutput;
-export {};
+export declare function canMute(chatId: string | Wid): boolean;

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

@@ -13,20 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-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;
+import { Stringable } from '../../types';
+import { MsgKey, MsgModel } from '../../whatsapp';
 /**
  * Get if message can reply
  *
  * @example
  * ```javascript
- * WPP.chat.canReply({ messageId: '[message_id]' });
+ * WPP.chat.canReply('[message_id]');
  * ```
  * @category Message
  */
-export declare function canReply(params: ChatCanReplyInput): Promise<ChatCanReplyOutput>;
-export {};
+export declare function canReply(messageId: string | MsgKey | MsgModel | Stringable): Promise<boolean>;

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

@@ -13,22 +13,14 @@
  * 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(params: ChatClearInput): Promise<ChatClearOutput>;
-export {};
+export declare function clear(chatId: string | Wid, keepStarred?: boolean): Promise<{
+    wid: Wid;
+    status: number;
+    keepStarred: boolean;
+}>;

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

@@ -1,5 +1,5 @@
 /*!
- * Copyright 2026 WPPConnect Team
+ * Copyright 2024 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,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export type ChatCloseChatOutput = boolean;
 /**
  * Close the chat tab
  *
@@ -24,4 +23,4 @@ export type ChatCloseChatOutput = boolean;
  *
  * @category Chat
  */
-export declare function closeChat(): Promise<ChatCloseChatOutput>;
+export declare function closeChat(): Promise<boolean>;

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

@@ -13,20 +13,14 @@
  * 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(params: ChatDeleteInput): Promise<ChatDeleteOutput>;
+declare function _delete(chatId: string | Wid): Promise<{
+    wid: Wid;
+    status: number;
+}>;
 export { _delete as delete };

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

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { z } from 'zod';
+import { Wid } from '../../whatsapp';
 import { SendMsgResult } from '../../whatsapp/enums';
 export interface DeleteMessageReturn {
     id: string;
@@ -22,30 +22,21 @@ 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({ chatId: '[number]@c.us', ids: ['msgid'] });
+ * WPP.chat.deleteMessage('[number]@c.us', 'msgid');
  * // Delete a list of messages
- * WPP.chat.deleteMessage({ chatId: '[number]@c.us', ids: ['msgid1', 'msgid2'] });
+ * WPP.chat.deleteMessage('[number]@c.us', ['msgid1', 'msgid2]);
  * // Delete a message and delete media
- * WPP.chat.deleteMessage({ chatId: '[number]@c.us', ids: ['msgid'], deleteMediaInDevice: true });
+ * WPP.chat.deleteMessage('[number]@c.us', 'msgid', true);
  * // Revoke a message
- * WPP.chat.deleteMessage({ chatId: '[number]@c.us', ids: ['msgid'], deleteMediaInDevice: true, revoke: true });
+ * WPP.chat.deleteMessage('[number]@c.us', 'msgid', true, true);
  * ```
  *
  * @category Message
  */
-export declare function deleteMessages(params: ChatDeleteMessageInput): Promise<ChatDeleteMessageOutput>;
-export {};
+export declare function deleteMessage(chatId: string | Wid, ids: string | string[], deleteMediaInDevice?: boolean, revoke?: boolean): Promise<DeleteMessageReturn | DeleteMessageReturn[]>;

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

@@ -13,24 +13,17 @@
  * 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({ msgId: 'true_[number]@c.us_ABCDEF' });
+ * await WPP.chat.downloadMedia('true_[number]@c.us_ABCDEF');
  *
  * // Get a base64Content
- * await WPP.chat.downloadMedia({ msgId: 'true_[number]@c.us_ABCDEF' }).then(WPP.util.blobToBase64);
+ * await WPP.chat.downloadMedia('true_[number]@c.us_ABCDEF').then(WPP.util.blobToBase64);
  * ```
  *
  * @category Message
  */
-export declare function downloadMedia(params: ChatDownloadMediaInput): Promise<ChatDownloadMediaOutput>;
-export {};
+export declare function downloadMedia(id: string): Promise<Blob>;

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

@@ -13,45 +13,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-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;
+import { MsgKey } from '../../whatsapp';
+import { LinkPreviewOptions, SendMessageOptions, SendMessageReturn } from '..';
+export type EditMessageOptions = SendMessageOptions & LinkPreviewOptions;
 /**
  * Edit a message previously sent.
  *
  * @example
- * WPP.chat.editMessage({ msgId: 'true_[number]@c.us_[msgId]', newText: 'New text for message', options: {
+ * WPP.chat.editMessage('true_[number]@c.us_[msgId]', 'New text for message', {
  *   linkPreview: true,
  *   mentionedJidList: ['5521985232287@c.us']
- * } });
+ * });
  * ```
  * @category Message
  */
-export declare function editMessage(params: ChatEditMessageInput): Promise<ChatEditMessageOutput>;
-export {};
+export declare function editMessage(msgId: string | MsgKey, newText: string, options?: EditMessageOptions): Promise<SendMessageReturn>;

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

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

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

@@ -13,27 +13,20 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-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;
+import { MsgKey, Wid } from '../../whatsapp';
+export interface ForwardMessageOptions {
+    displayCaptionText?: boolean;
+    multicast?: boolean;
+}
 /**
  * Forward message to a chat
  *
  * @example
  * ```javascript
  * // Forward message
- * WPP.chat.forwardMessage({ toChatId: '[number]@c.us', msgId: 'true_[number]@c.us_ABCDEF' });
+ * WPP.chat.forwardMessage('[number]@c.us', 'true_[number]@c.us_ABCDEF');
  * ```
  * @category Message
  * @return  {any} Any
  */
-export declare function forwardMessage(params: ChatForwardMessageInput): Promise<ChatForwardMessageOutput>;
-export {};
+export declare function forwardMessage(toChatId: string | Wid, msgId: string | MsgKey, options?: ForwardMessageOptions): Promise<boolean>;

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

@@ -13,28 +13,21 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-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>;
+import { MsgKey, MsgModel, Wid } from '../../whatsapp';
+export interface ForwardMessagesOptions {
+    displayCaptionText?: boolean;
+    multicast?: boolean;
+    appendedText?: boolean;
+}
 /**
  * Forward many messages to a chat
  *
  * @example
  * ```javascript
  * // Forward messages
- * WPP.chat.forwardMessages({ toChatId: '[number]@c.us', msgsId: ['true_[number]@c.us_ABCDEF', ...] });
+ * WPP.chat.forwardMessagesWhatsApp('[number]@c.us', ['true_[number]@c.us_ABCDEF', ...]);
  * ```
  * @category Message
  * @return  {any} Any
  */
-export declare function forwardMessages(params: ChatForwardMessagesInput): Promise<ChatForwardMessagesOutput>;
-export {};
+export declare function forwardMessages(toChatId: string | Wid, msgsId: string[] | MsgKey[] | MsgModel[], options?: ForwardMessagesOptions): Promise<Array<any>>;

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

@@ -13,17 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-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;
+import { ChatModel, MsgKey, Wid } from '../../whatsapp';
 /**
  * Generate a new message ID
  *
  * @category Message
  */
-export declare function generateMessageID(params: ChatGenerateMessageIDInput): Promise<ChatGenerateMessageIDOutput>;
-export {};
+export declare function generateMessageID(chat: string | ChatModel | Wid): Promise<MsgKey>;

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

@@ -13,17 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-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;
+import { ChatModel, Wid } from '../../whatsapp';
 /**
  * Find a chat by id
  *
  * @category Chat
  */
-export declare function get(params: ChatGetInput): ChatGetOutput;
-export {};
+export declare function get(chatId: string | Wid): ChatModel | undefined;

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

@@ -1,5 +1,5 @@
 /*!
- * Copyright 2026 WPPConnect Team
+ * Copyright 2021 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,8 +13,6 @@
  * 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
  *
@@ -29,4 +27,4 @@ export type ChatGetActiveChatOutput = ChatModel | undefined;
  * ```
  * @category Chat
  */
-export declare function getActiveChat(): ChatGetActiveChatOutput;
+export declare function getActiveChat(): import("../../whatsapp").ChatModel | undefined;

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

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