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

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

@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { z } from 'zod';
 import { SendMessageOptions, SendMessageReturn } from '..';
 import { MessageButtonsOptions } from './prepareMessageButtons';
 export interface LocationMessageOptions extends SendMessageOptions, MessageButtonsOptions {
@@ -38,67 +37,64 @@ export interface LocationMessageOptions extends SendMessageOptions, MessageButto
      */
     url?: string;
 }
-declare const chatSendLocationMessageSchema: z.ZodObject<{
-    chatId: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
-    options: 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>;
-        lat: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
-        lng: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
-        address: z.ZodOptional<z.ZodString>;
-        name: z.ZodOptional<z.ZodString>;
-        url: z.ZodOptional<z.ZodString>;
-        buttons: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-            id: z.ZodString;
-            text: z.ZodString;
-        }, z.core.$strip>, z.ZodObject<{
-            phoneNumber: z.ZodString;
-            text: z.ZodString;
-        }, z.core.$strip>, z.ZodObject<{
-            url: z.ZodString;
-            text: z.ZodString;
-        }, z.core.$strip>, z.ZodObject<{
-            code: z.ZodString;
-            text: z.ZodString;
-        }, z.core.$strip>]>>>;
-        title: z.ZodOptional<z.ZodString>;
-        footer: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export type ChatSendLocationMessageInput = z.infer<typeof chatSendLocationMessageSchema>;
-export type ChatSendLocationMessageOutput = SendMessageReturn;
 /**
  * Send a location message
  *
  * @example
  * ```javascript
  * // full example
- * WPP.chat.sendLocationMessage({
- *   chatId: '[number]@c.us',
- *   options: {
- *     lat: -22.95201,
- *     lng: -43.2102601,
- *     name: 'Cristo Rendentor',
- *     address: 'Parque Nacional da Tijuca - Alto da Boa Vista, Rio de Janeiro - RJ',
- *     url: 'https://santuariocristoredentor.com.br/'
- *   }
+ * WPP.chat.sendLocationMessage('[number]@c.us', {
+ *  lat: -22.95201,
+ *  lng: -43.2102601,
+ *  name: 'Cristo Rendentor', // optional
+ *  address: 'Parque Nacional da Tijuca - Alto da Boa Vista, Rio de Janeiro - RJ', // optional
+ *  url: 'https://santuariocristoredentor.com.br/' // optional
  * });
  *
  * // minimal
- * WPP.chat.sendLocationMessage({
- *   chatId: '[number]@c.us',
- *   options: { lat: -22.95201, lng: -43.2102601 }
+ * WPP.chat.sendLocationMessage('[number]@c.us', {
+ *  lat: -22.95201,
+ *  lng: -43.2102601,
+ * });
+ *
+ * // name and address
+ * WPP.chat.sendLocationMessage('[number]@c.us', {
+ *  lat: -22.95201,
+ *  lng: -43.2102601,
+ *  name: 'Cristo Rendentor',
+ *  address: 'Parque Nacional da Tijuca - Alto da Boa Vista, Rio de Janeiro - RJ'
  * });
- * ```
  *
+ * // with buttons
+ * WPP.chat.sendLocationMessage('[number]@c.us', {
+ *  lat: -22.95201,
+ *  lng: -43.2102601,
+ *  name: 'Cristo Rendentor',
+ *  address: 'Parque Nacional da Tijuca - Alto da Boa Vista, Rio de Janeiro - RJ',
+ *  buttons: [
+ *      {
+ *          url: 'https://example.test/',
+ *          text: 'URL example'
+ *      },
+ *      {
+ *          phoneNumber: '+55 12 3456 7777',
+ *          text: 'Phone Number'
+ *      },
+ *      {
+ *          id: 'id1',
+ *          text: 'First'
+ *      },
+ *      {
+ *          id: 'id2',
+ *          text: 'Second'
+ *      },
+ *      {
+ *          id: 'other',
+ *          text: 'Other'
+ *      }
+ *  ],
+ * });
+ * ```
  * @category Message
  */
-export declare function sendLocationMessage(params: ChatSendLocationMessageInput): Promise<ChatSendLocationMessageOutput>;
-export {};
+export declare function sendLocationMessage(chatId: any, options: LocationMessageOptions): Promise<SendMessageReturn>;

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

@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { z } from 'zod';
 import { SendMessageOptions, SendMessageReturn } from '..';
 export interface OrderItems {
     type: 'product' | 'custom';
@@ -29,41 +28,26 @@ export interface OrderMessageOptions extends SendMessageOptions {
     shipping?: number;
     offset?: number;
 }
-declare const chatSendPixKeyMessageSchema: z.ZodObject<{
-    chatId: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
-    params: z.ZodObject<{
-        keyType: z.ZodEnum<{
-            CNPJ: "CNPJ";
-            CPF: "CPF";
-            PHONE: "PHONE";
-            EMAIL: "EMAIL";
-            EVP: "EVP";
-        }>;
-        name: z.ZodString;
-        key: z.ZodString;
-        instructions: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
-    options: z.ZodOptional<z.ZodAny>;
-}, z.core.$strip>;
-export type ChatSendPixKeyMessageInput = z.infer<typeof chatSendPixKeyMessageSchema>;
-export type ChatSendPixKeyMessageOutput = SendMessageReturn;
 /**
- * Send a PIX key invoice message (Brazil Pix Key)
+ * Send a invoice message
  * To send (prices, tax, shipping or discount), for example: USD 12.90, send them without dots or commas, like: 12900
  *
  * @example
  * ```javascript
- * WPP.chat.sendPixKeyMessage({
- *   chatId: '[number]@c.us',
- *   params: {
+ * // Send PIX Key Message (Brazil Pix Key)
+ * WPP.chat.sendPixKeyMessage('[number]@c.us', {
  *     keyType: 'CNPJ',
  *     name: 'WPPCONNECT-TEAM',
  *     key: '33460516000178',
  *     instructions: 'Pay text for instructions here',
- *   }
  * });
+ *
  * ```
  * @category Message
  */
-export declare function sendPixKeyMessage(input: ChatSendPixKeyMessageInput): Promise<ChatSendPixKeyMessageOutput>;
-export {};
+export declare function sendPixKeyMessage(chatId: any, params: {
+    keyType: 'CNPJ' | 'CPF' | 'PHONE' | 'EMAIL' | 'EVP';
+    name: string;
+    key: string;
+    instructions?: string;
+}, options?: SendMessageOptions): Promise<SendMessageReturn>;

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

@@ -13,30 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { z } from 'zod';
-import { MsgModel } from '../../whatsapp';
-import { RawMessage, SendMessageReturn } from '..';
-declare const chatSendRawMessageSchema: z.ZodObject<{
-    chatId: z.ZodString;
-    rawMessage: z.ZodCustom<RawMessage, RawMessage>;
-    options: z.ZodOptional<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<MsgModel, MsgModel>]>>;
-        quotedMsgPayload: z.ZodOptional<z.ZodString>;
-        waitForAck: z.ZodOptional<z.ZodBoolean>;
-        delay: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type ChatSendRawMessageInput = z.infer<typeof chatSendRawMessageSchema>;
-export type ChatSendRawMessageOutput = SendMessageReturn;
+import { RawMessage, SendMessageOptions, SendMessageReturn } from '..';
 /**
  * Send a raw message
  *
  * @category Message
  */
-export declare function sendRawMessage(params: ChatSendRawMessageInput): Promise<ChatSendRawMessageOutput>;
-export {};
+export declare function sendRawMessage(chatId: any, rawMessage: RawMessage, options?: SendMessageOptions): Promise<SendMessageReturn>;

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

@@ -13,15 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { z } from 'zod';
-declare const chatSendReactionToMessageSchema: z.ZodObject<{
-    messageId: z.ZodString;
-    reaction: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<false>, z.ZodNull]>;
-}, z.core.$strip>;
-export type ChatSendReactionToMessageInput = z.infer<typeof chatSendReactionToMessageSchema>;
-export type ChatSendReactionToMessageOutput = {
-    sendMsgResult: any;
-};
+import { Stringable } from '../../types';
+import { MsgKey, MsgModel } from '../../whatsapp';
 /**
  * Send a reaction to a message
  *
@@ -30,13 +23,14 @@ export type ChatSendReactionToMessageOutput = {
  * @example
  * ```javascript
  * // to react a message
- * WPP.chat.sendReactionToMessage({ messageId: '[message_id]', reaction: '🤯' });
+ * WPP.chat.sendReactionToMessage('[message_id]', '🤯');
  *
  * // to remove
- * WPP.chat.sendReactionToMessage({ messageId: '[message_id]', reaction: false });
+ * WPP.chat.sendReactionToMessage('[message_id]', false);
  *
  * ```
  * @category Message
  */
-export declare function sendReactionToMessage(params: ChatSendReactionToMessageInput): Promise<ChatSendReactionToMessageOutput>;
-export {};
+export declare function sendReactionToMessage(messageId: string | MsgKey | MsgModel | Stringable, reaction: string | false | null): Promise<{
+    sendMsgResult: string;
+}>;

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

@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { z } from 'zod';
 import { SendMessageOptions, SendMessageReturn } from '..';
 export interface ScheduledCallMessageOptions extends SendMessageOptions {
     scheduledTimestampMs: number | string;
@@ -21,28 +20,18 @@ export interface ScheduledCallMessageOptions extends SendMessageOptions {
     title: string;
     description?: string;
 }
-declare const chatSendScheduledCallMessageSchema: z.ZodObject<{
-    chatId: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
-    options: z.ZodAny;
-}, z.core.$strip>;
-export type ChatSendScheduledCallMessageInput = z.infer<typeof chatSendScheduledCallMessageSchema>;
-export type ChatSendScheduledCallMessageOutput = SendMessageReturn;
 /**
  * Send a scheduled call message
  *
  * @example
  * ```javascript
- * WPP.chat.sendScheduledCallMessage({
- *   chatId: '[number]@c.us',
- *   options: {
- *     title: 'Title of event call',
- *     description: 'Description for Call',
- *     callType: 'voice',
- *     scheduledTimestampMs: 1696084222000
- *   }
+ * WPP.chat.sendScheduledCallMessage('[number]@c.us', {
+ *  title: "Title of event call"
+ *  description: 'Description for Call",
+ *  callType: 'voice'
+ *  scheduledTimestampMs: 1696084222000
  * });
  * ```
  * @category Message
  */
-export declare function sendScheduledCallMessage(params: ChatSendScheduledCallMessageInput): Promise<ChatSendScheduledCallMessageOutput>;
-export {};
+export declare function sendScheduledCallMessage(chatId: any, options: ScheduledCallMessageOptions): Promise<SendMessageReturn>;

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

@@ -13,25 +13,42 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { z } from 'zod';
 import { LinkPreviewOptions, MessageButtonsOptions, SendMessageOptions, SendMessageReturn } from '..';
 export type TextMessageOptions = SendMessageOptions & MessageButtonsOptions & LinkPreviewOptions;
-declare const chatSendTextMessageSchema: z.ZodObject<{
-    chatId: z.ZodAny;
-    content: z.ZodAny;
-    options: z.ZodOptional<z.ZodAny>;
-}, z.core.$strip>;
-export type ChatSendTextMessageInput = z.infer<typeof chatSendTextMessageSchema>;
-export type ChatSendTextMessageOutput = SendMessageReturn;
 /**
  * Send a text message
  *
  * @example
  * ```javascript
  * // Send a simple text message
- * WPP.chat.sendTextMessage({ chatId: '<chatId>', content: 'Hello new contact' });
+ * WPP.chat.sendTextMessage('[number]@c.us', 'Hello new contact');
+ *
+ * // With Buttons
+ * // Attention: The buttons are an alternative solution we found to make it work. There is no guarantee that they will continue functioning, or when they might stop: The only certainty is: They will stop, so use them responsibly.
+ * WPP.chat.sendTextMessage('[number]@c.us', 'Hello', {
+ *   useInteractiveMessage: true, // False for legacy
+ *   buttons: [
+ *     {
+ *       url: 'https://wppconnect.io/',
+ *       text: 'WPPConnect Site'
+ *     },
+ *     {
+ *       phoneNumber: '+55 11 22334455',
+ *       text: 'Call me'
+ *     },
+ *     {
+ *       id: 'your custom id 1',
+ *       text: 'Some text'
+ *     },
+ *     {
+ *       code: '789890',
+ *       text: 'Another text'
+ *     }
+ *   ],
+ *   title: 'Title text', // Optional
+ *   footer: 'Footer text' // Optional
+ * });
  * ```
  * @category Message
  */
-export declare function sendTextMessage(params: ChatSendTextMessageInput): Promise<ChatSendTextMessageOutput>;
-export {};
+export declare function sendTextMessage(chatId: any, content: any, options?: TextMessageOptions): Promise<SendMessageReturn>;

package/dist/chat/functions/sendVCardContactMessage.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,60 +13,35 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { z } from 'zod';
 import { Wid } from '../../whatsapp';
-import { SendMessageReturn } from '..';
+import { SendMessageOptions, SendMessageReturn } from '..';
 export interface VCardContact {
     id: string | Wid;
     name: string;
 }
-declare const chatSendVCardContactMessageSchema: z.ZodObject<{
-    chatId: z.ZodString;
-    contacts: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        name: z.ZodString;
-    }, z.core.$strip>>;
-    options: z.ZodOptional<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<Wid, 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 ChatSendVCardContactMessageInput = z.infer<typeof chatSendVCardContactMessageSchema>;
-export type ChatSendVCardContactMessageOutput = SendMessageReturn;
 /**
- * Send one or more contacts as a vCard message
- *
+ * Send a VCard as message
  * @example
  * ```javascript
- * // Send a single contact by ID (name resolved from contact store)
- * WPP.chat.sendVCardContactMessage({
- *   chatId: '[number]@c.us',
- *   contacts: ['[contact]@c.us'],
+ * // single contact
+ * WPP.chat.sendVCardContactMessage('[number]@c.us', {
+ *   id: '123456@c.us',
+ *   name: 'The Contact Name'
  * });
  *
- * // Send a single contact with a custom display name
- * WPP.chat.sendVCardContactMessage({
- *   chatId: '[number]@c.us',
- *   contacts: [{ id: '[contact]@c.us', name: 'John Doe' }],
- * });
+ * // multiple contacts
+ * WPP.chat.sendVCardContactMessage('[number]@c.us', [
+ *   {
+ *     id: '123456@c.us',
+ *     name: 'The Contact Name'
+ *   },
+ *   {
+ *     id: '456789@c.us',
+ *     name: 'Another Contact'
+ *   },
+ * ]);
  *
- * // Send multiple contacts at once
- * WPP.chat.sendVCardContactMessage({
- *   chatId: '[number]@c.us',
- *   contacts: [
- *     { id: '[contact1]@c.us', name: 'Alice' },
- *     { id: '[contact2]@c.us', name: 'Bob' },
- *   ],
- * });
  * ```
  * @category Message
  */
-export declare function sendVCardContactMessage(params: ChatSendVCardContactMessageInput): Promise<ChatSendVCardContactMessageOutput>;
-export {};
+export declare function sendVCardContactMessage(chatId: any, contacts: string | Wid | VCardContact | (string | Wid | VCardContact)[], options?: SendMessageOptions): Promise<SendMessageReturn>;

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

@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { z } from 'zod';
 export declare enum FilterChatListTypes {
     ALL = "all",
     CUSTOM = "custom",
@@ -28,16 +27,10 @@ export declare enum FilterChatListTypes {
     LABELS = "labels",
     ASSIGNED_TO_YOU = "assigned_to_you"
 }
-declare const chatSetChatListSchema: z.ZodObject<{
-    type: z.ZodEnum<typeof FilterChatListTypes>;
-    chatIds: z.ZodArray<z.ZodString>;
-}, z.core.$strip>;
-export type ChatSetChatListInput = z.infer<typeof chatSetChatListSchema>;
-export type ChatSetChatListOutput = {
+export declare function setChatList(type: FilterChatListTypes, ids?: string | string[]): Promise<{
     type: FilterChatListTypes;
     list?: string[];
-};
-export declare function setChatList(params: ChatSetChatListInput): Promise<ChatSetChatListOutput>;
+}>;
 /**
  * Custom Wrap function with the callback
  *
@@ -47,4 +40,3 @@ export declare function setChatList(params: ChatSetChatListInput): Promise<ChatS
  * I'm committing it this way to provide a quick solution.
  */
 export declare function wrapShouldAppearFunction<TFunc extends (...args: any[]) => any>(func: TFunc, callback: (func: TFunc, ...args: Parameters<TFunc>) => ReturnType<TFunc>): TFunc;
-export {};

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

@@ -13,15 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { z } from 'zod';
-declare const chatSetInputTextSchema: z.ZodObject<{
-    text: z.ZodString;
-    chatId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type ChatSetInputTextInput = z.infer<typeof chatSetInputTextSchema>;
-export type ChatSetInputTextOutput = {
+import { Wid } from '../../whatsapp';
+export declare function setInputText(text: string, chatId?: string | Wid): Promise<{
     text: string;
     timestamp: number;
-};
-export declare function setInputText(params: ChatSetInputTextInput): Promise<ChatSetInputTextOutput>;
-export {};
+}>;

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

@@ -13,14 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { z } from 'zod';
-import { NoteModel } from '../../whatsapp';
-declare const chatSetNotesSchema: z.ZodObject<{
-    chatId: z.ZodString;
-    content: z.ZodString;
-}, z.core.$strip>;
-export type ChatSetNotesInput = z.infer<typeof chatSetNotesSchema>;
-export type ChatSetNotesOutput = NoteModel | null;
+import { NoteModel, Wid } from '../../whatsapp';
 /**
  * Set notes for a contact
  * Only when are connected with business device
@@ -30,5 +23,4 @@ export type ChatSetNotesOutput = NoteModel | null;
  * ```
  * @category Chat
  */
-export declare function setNotes(params: ChatSetNotesInput): Promise<ChatSetNotesOutput>;
-export {};
+export declare function setNotes(chatId: string | Wid, content: string): Promise<NoteModel | null>;

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

@@ -13,32 +13,35 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { z } from 'zod';
 export interface StarMessageReturn {
     id: string;
     star: boolean;
 }
-declare const chatStarMessageSchema: z.ZodObject<{
-    ids: z.ZodArray<z.ZodString>;
-    star: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export type ChatStarMessageInput = z.infer<typeof chatStarMessageSchema>;
-export type ChatStarMessageOutput = StarMessageReturn | StarMessageReturn[];
 /**
- * Star/Unstar a message or messages
+ * Star/Unstar a message
  *
  * @example
  * ```javascript
  * // star a message
- * WPP.chat.starMessage({ ids: '<message id>' });
+ * WPP.chat.starMessage('<message id>');
  *
  * // unstar a message
- * WPP.chat.starMessage({ ids: '<message id>', star: false });
+ * WPP.chat.starMessage('<message id>', false);
+ * ```
+ * @category Message
+ */
+export declare function starMessage(id: string, star: boolean): Promise<StarMessageReturn>;
+/**
+ * Star/Unstar messages
  *
+ * @example
+ * ```javascript
  * // star messages
- * WPP.chat.starMessage({ ids: ['<message id>', '<message id>'] });
+ * WPP.chat.starMessage(['<message id>', '<message id>']);
+ *
+ * // unstar messages
+ * WPP.chat.starMessage(['<message id>', '<message id>'], false);
  * ```
  * @category Message
  */
-export declare function starMessage(params: ChatStarMessageInput): Promise<ChatStarMessageOutput>;
-export {};
+export declare function starMessage(ids: string[], star: boolean): Promise<StarMessageReturn[]>;

package/dist/chat/functions/unmute.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 chatUnmuteSchema: z.ZodObject<{
-    chatId: z.ZodString;
-}, z.core.$strip>;
-export type ChatUnmuteInput = z.infer<typeof chatUnmuteSchema>;
-export type ChatUnmuteOutput = any;
+import { Wid } from '../../whatsapp';
 /**
  * Unmute a chat
  *
@@ -29,5 +24,4 @@ export type ChatUnmuteOutput = any;
  *
  * @category Chat
  */
-export declare function unmute(params: ChatUnmuteInput): Promise<ChatUnmuteOutput>;
-export {};
+export declare function unmute(chatId: string | Wid): Promise<void>;