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

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

@@ -13,30 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { z } from 'zod';
-import { MsgKey, MsgModel, Wid } from '../../whatsapp';
-import { RawMessage } from '..';
-declare const chatPrepareRawMessageSchema: z.ZodObject<{
-    chat: z.ZodAny;
-    message: z.ZodAny;
-    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<MsgKey, 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<MsgKey, 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 ChatPrepareRawMessageInput = z.infer<typeof chatPrepareRawMessageSchema>;
-export type ChatPrepareRawMessageOutput = any;
+import { ChatModel } from '../../whatsapp';
+import { RawMessage, SendMessageOptions } from '..';
 /**
  * Prepare a raw message
  * @category Message
  * @internal
  */
-export declare function prepareRawMessage<T extends RawMessage>(params: ChatPrepareRawMessageInput): Promise<T>;
-export {};
+export declare function prepareRawMessage<T extends RawMessage>(chat: ChatModel, message: T, options?: SendMessageOptions): Promise<T>;

package/dist/chat/functions/replyToButtonMessage.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 interface ButtonReplyOptions {
     /**
      * The index of the button to reply to (0-based)
@@ -42,14 +41,4 @@ export interface ButtonReplyOptions {
  * ```
  * @category Message
  */
-declare const chatReplyToButtonMessageSchema: z.ZodObject<{
-    chatId: z.ZodString;
-    messageId: z.ZodString;
-    options: z.ZodObject<{
-        buttonIndex: z.ZodNumber;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export type ChatReplyToButtonMessageInput = z.infer<typeof chatReplyToButtonMessageSchema>;
-export type ChatReplyToButtonMessageOutput = any;
-export declare function replyToButtonMessage(params: ChatReplyToButtonMessageInput): Promise<ChatReplyToButtonMessageOutput>;
-export {};
+export declare function replyToButtonMessage(chatId: any, messageId: string, options: ButtonReplyOptions): Promise<any>;

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

@@ -13,23 +13,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { z } from 'zod';
-import { SendMessageReturn } from '..';
-declare const chatRequestPhoneNumberSchema: z.ZodObject<{
-    chatId: z.ZodString;
-}, z.core.$strip>;
-export type ChatRequestPhoneNumberInput = z.infer<typeof chatRequestPhoneNumberSchema>;
-export type ChatRequestPhoneNumberOutput = SendMessageReturn;
+import { SendMessageOptions, SendMessageReturn } from '..';
 /**
  * Request the real phone number for a LID chat ([number]@lid)
  *
  * @example
  * ```javascript
  * // Request
- * WPP.chat.requestPhoneNumber({ chatId: '[number]@lid' });
+ * WPP.chat.requestPhoneNumber('[number]@lid');
  * ```
  *
  * @category Message
  */
-export declare function requestPhoneNumber(params: ChatRequestPhoneNumberInput): Promise<ChatRequestPhoneNumberOutput>;
-export {};
+export declare function requestPhoneNumber(chatId: any, options?: SendMessageOptions): Promise<SendMessageReturn>;

package/dist/chat/functions/sendCatalogMessage.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 { SendMessageOptions, SendMessageReturn } from '..';
 export interface CatalogMessageOptions extends SendMessageOptions {
     jpegThumbnail?: string;
@@ -21,45 +21,23 @@ export interface CatalogMessageOptions extends SendMessageOptions {
     description?: string;
     textMessage?: string;
 }
-declare const chatSendCatalogMessageSchema: z.ZodObject<{
-    toChatId: z.ZodString;
-    fromChatId: z.ZodString;
-    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<import("../../whatsapp").MsgModel, import("../../whatsapp").MsgModel>]>>;
-        quotedMsgPayload: z.ZodOptional<z.ZodString>;
-        waitForAck: z.ZodOptional<z.ZodBoolean>;
-        delay: z.ZodOptional<z.ZodNumber>;
-        jpegThumbnail: z.ZodOptional<z.ZodString>;
-        title: z.ZodOptional<z.ZodString>;
-        description: z.ZodOptional<z.ZodString>;
-        textMessage: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type ChatSendCatalogMessageInput = z.infer<typeof chatSendCatalogMessageSchema>;
-export type ChatSendCatalogMessageOutput = SendMessageReturn;
 /**
  * Send catalog message
  *
  * @example
  * ```javascript
- * WPP.chat.sendCatalogMessage({
- *   toChatId: '[number]@c.us',
- *   fromChatId: '[number]@c.us',
- *   options: {
- *     title: 'My Catalog',
- *     description: 'This is my catalog',
- *     textMessage: 'Check out my catalog',
- *     jpegThumbnail: 'data:image/jpeg;base64,...'
- *   }
- * });
+ * WPP.chat.sendCatalogMessage(
+ *  '[number]@c.us',
+ *  '[number]@c.us',
+ * {
+ *   title: 'My Catalog',
+ *   description: 'This is my catalog',
+ *   textMessage: 'Check out my catalog',
+ *   jpegThumbnail: 'data:image/jpeg;base64,...'
+ * }
+ * );
  * ```
  *
  * @category Message
  */
-export declare function sendCatalogMessage(params: ChatSendCatalogMessageInput): Promise<ChatSendCatalogMessageOutput>;
-export {};
+export declare function sendCatalogMessage(chatToSend: string | Wid, chatFromCatalog: string | Wid, opts: CatalogMessageOptions): Promise<SendMessageReturn>;

package/dist/chat/functions/sendChargeMessage.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';
@@ -35,40 +34,6 @@ export interface OrderMessageOptions extends SendMessageOptions {
     };
     payment_instruction?: string;
 }
-declare const chatSendChargeMessageSchema: z.ZodObject<{
-    chatId: z.ZodString;
-    items: z.ZodArray<z.ZodAny>;
-    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<import("../../whatsapp").MsgModel, import("../../whatsapp").MsgModel>]>>;
-        quotedMsgPayload: z.ZodOptional<z.ZodString>;
-        waitForAck: z.ZodOptional<z.ZodBoolean>;
-        delay: z.ZodOptional<z.ZodNumber>;
-        notes: z.ZodOptional<z.ZodString>;
-        discount: z.ZodOptional<z.ZodNumber>;
-        tax: z.ZodOptional<z.ZodNumber>;
-        shipping: z.ZodOptional<z.ZodNumber>;
-        offset: z.ZodOptional<z.ZodNumber>;
-        pix: z.ZodOptional<z.ZodObject<{
-            keyType: z.ZodEnum<{
-                CNPJ: "CNPJ";
-                CPF: "CPF";
-                PHONE: "PHONE";
-                EMAIL: "EMAIL";
-                EVP: "EVP";
-            }>;
-            name: z.ZodString;
-            key: z.ZodString;
-        }, z.core.$strip>>;
-        payment_instruction: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type ChatSendChargeMessageInput = z.infer<typeof chatSendChargeMessageSchema>;
-export type ChatSendChargeMessageOutput = SendMessageReturn;
 /**
  * Send a order message
  * To send (prices, tax, shipping or discount), for example: USD 12.90, send them without dots or commas, like: 12900
@@ -76,43 +41,38 @@ export type ChatSendChargeMessageOutput = SendMessageReturn;
  * @example
  * ```javascript
  * // Send charge with a product
- * WPP.chat.sendChargeMessage({
- *   chatId: '[number]@c.us',
- *   items: [
- *     { type: 'product', id: '67689897878', qnt: 2 },
- *     { type: 'product', id: '37878774457', qnt: 1 },
- *   ]
- * });
+ * WPP.chat.sendChargeMessage('[number]@c.us', [
+ *   { type: 'product', id: '67689897878', qnt: 2 },
+ *   { type: 'product', id: '37878774457', qnt: 1 },
+ * ]
  *
  * // Send charge with a custom item
- * WPP.chat.sendChargeMessage({
- *   chatId: '[number]@c.us',
- *   items: [{ type: 'custom', name: 'Item de cost test', price: 120000, qnt: 2 }]
- * });
+ * WPP.chat.sendChargeMessage('[number]@c.us', [
+ *   { type: 'custom', name: 'Item de cost test', price: 120000, qnt: 2 },
+ * ]
  *
  * // Send charge with custom options
- * WPP.chat.sendChargeMessage({
- *   chatId: '[number]@c.us',
- *   items: [
- *     { type: 'product', id: '37878774457', qnt: 1 },
- *     { type: 'custom', name: 'Item de cost test', price: 120000, qnt: 2 },
- *   ],
- *   options: { tax: 10000, shipping: 4000, discount: 10000 }
- * });
+ * WPP.chat.sendChargeMessage('[number]@c.us', [
+ *   { type: 'product', id: '37878774457', qnt: 1 },
+ *   { type: 'custom', name: 'Item de cost test', price: 120000, qnt: 2 },
+ * ],
+ * { tax: 10000, shipping: 4000, discount: 10000 }
  *
  * // Send charge with Pix data (auto generate copy-paste pix code)
- * WPP.chat.sendChargeMessage({
- *   chatId: '[number]@c.us',
- *   items: [{ type: 'custom', name: 'Item de cost test', price: 120000, qnt: 2 }],
- *   options: {
- *     tax: 10000,
- *     shipping: 4000,
- *     discount: 10000,
- *     pix: { keyType: 'CPF', key: '00555095999', name: 'Name of seller' },
- *   }
+ * WPP.chat.sendChargeMessage('[number]@c.us', [
+ *   { type: 'custom', name: 'Item de cost test', price: 120000, qnt: 2 },
+ * ],
+ * {
+ *   tax: 10000,
+ *   shipping: 4000,
+ *   discount: 10000,
+ *   pix: {
+ *     keyType: 'CPF',
+ *     key: '00555095999',
+ *     name: 'Name of seller',
+ *   },
  * });
  * ```
  * @category Message
  */
-export declare function sendChargeMessage(params: ChatSendChargeMessageInput): Promise<ChatSendChargeMessageOutput>;
-export {};
+export declare function sendChargeMessage(chatId: any, items: OrderItems[], options?: OrderMessageOptions): Promise<SendMessageReturn>;

package/dist/chat/functions/sendCreatePollMessage.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 { SendMessageOptions, SendMessageReturn } from '..';
 export interface PoolMessageOptions extends SendMessageOptions {
     selectableCount?: number;
 }
-declare const chatSendCreatePollMessageSchema: z.ZodObject<{
-    chatId: z.ZodString;
-    name: z.ZodString;
-    choices: z.ZodArray<z.ZodString>;
-    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<import("../../whatsapp").MsgModel, import("../../whatsapp").MsgModel>]>>;
-        quotedMsgPayload: z.ZodOptional<z.ZodString>;
-        waitForAck: z.ZodOptional<z.ZodBoolean>;
-        delay: z.ZodOptional<z.ZodNumber>;
-        selectableCount: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type ChatSendCreatePollMessageInput = z.infer<typeof chatSendCreatePollMessageSchema>;
-export type ChatSendCreatePollMessageOutput = SendMessageReturn;
 /**
  * Send a create poll message
  *
@@ -45,22 +25,25 @@ export type ChatSendCreatePollMessageOutput = SendMessageReturn;
  * @example
  * ```javascript
  * // Single pool
- * WPP.chat.sendCreatePollMessage({
- *   chatId: '[number]@g.us',
- *   name: 'A poll name',
- *   choices: ['Option 1', 'Option 2', 'Option 3']
- * });
- *
- * // With selectable count
- * WPP.chat.sendCreatePollMessage({
- *   chatId: '[number]@g.us',
- *   name: 'A poll name',
- *   choices: ['Option 1', 'Option 2', 'Option 3'],
- *   options: { selectableCount: 1 }
- * });
+ * WPP.chat.sendCreatePollMessage(
+ *  '[number]@g.us',
+ *  'A poll name',
+ *  ['Option 1', 'Option 2', 'Option 3']
+ * );
+ * ```
+ * // Selectable Count
+ * ```javascript
+ * // Single pool
+ * WPP.chat.sendCreatePollMessage(
+ *  '[number]@g.us',
+ *  'A poll name',
+ *  ['Option 1', 'Option 2', 'Option 3'],
+ *  {
+ *    selectableCount: 1,
+ *  }
+ * );
  * ```
  *
  * @category Message
  */
-export declare function sendCreatePollMessage(params: ChatSendCreatePollMessageInput): Promise<ChatSendCreatePollMessageOutput>;
-export {};
+export declare function sendCreatePollMessage(chatId: any, name: string, choices: string[], options?: PoolMessageOptions): Promise<SendMessageReturn>;

package/dist/chat/functions/sendEventMessage.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 EventMessageOptions extends SendMessageOptions {
     callType?: 'video' | 'voice';
@@ -27,78 +26,39 @@ export interface EventMessageOptions extends SendMessageOptions {
         name: string;
     };
 }
-declare const chatSendEventMessageSchema: z.ZodObject<{
-    chatId: z.ZodString;
-    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<import("../../whatsapp").MsgModel, import("../../whatsapp").MsgModel>]>>;
-        quotedMsgPayload: z.ZodOptional<z.ZodString>;
-        waitForAck: z.ZodOptional<z.ZodBoolean>;
-        delay: z.ZodOptional<z.ZodNumber>;
-        callType: z.ZodOptional<z.ZodEnum<{
-            video: "video";
-            voice: "voice";
-        }>>;
-        name: z.ZodString;
-        description: z.ZodOptional<z.ZodString>;
-        startTime: z.ZodNumber;
-        endTime: z.ZodOptional<z.ZodNumber>;
-        location: z.ZodOptional<z.ZodObject<{
-            degreesLatitude: z.ZodNumber;
-            degreesLongitude: z.ZodNumber;
-            name: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type ChatSendEventMessageInput = z.infer<typeof chatSendEventMessageSchema>;
-export type ChatSendEventMessageOutput = SendMessageReturn;
 /**
  * Send a Event Message
  *
  * @example
  * ```javascript
- * // Simple with start time and end
- * WPP.chat.sendEventMessage({
- *   chatId: '[number]@c.us',
- *   options: {
- *     name: 'Title of event',
- *     description: 'Description of your event',
- *     startTime: 1729551600,
- *     endTime: 1729551900
- *   }
+ * // Simple com start time and end
+ * WPP.chat.sendEventMessage('[number]@c.us', {
+ *  name: "Title of event"
+ *  description: 'Description of your event',
+ *  startTime: 1729551600
+ *  endTime: 1729551900
  * });
  *
  * // Event with location
- * WPP.chat.sendEventMessage({
- *   chatId: '[number]@c.us',
- *   options: {
- *     name: 'Title of event',
- *     description: 'Description of your event',
- *     startTime: 1729551600,
- *     location: {
- *       degreesLatitude: -22.9518551,
- *       degreesLongitude: -43.2108338,
- *       name: 'Cristo Redentor - RJ',
- *     }
- *   }
+ * WPP.chat.sendEventMessage('[number]@c.us', {
+ *  name: "Title of event"
+ *  description: 'Description of your event',
+ *  startTime: 1729551600
+ *  location: {
+ *   degreesLatitude: -22.9518551,
+ *   degreesLongitude: -43.2108338,
+ *   name: 'Cristo Redentor - RJ',
+ *  }
  * });
  *
- * // Event with link for call (voice or video)
- * WPP.chat.sendEventMessage({
- *   chatId: '[number]@c.us',
- *   options: {
- *     name: 'Title of event',
- *     callType: 'voice',
- *     description: 'Description of your event',
- *     startTime: 1729551600
- *   }
+ * // Event with link for call (use voice or video)
+ * WPP.chat.sendEventMessage('[number]@c.us', {
+ *  name: "Title of event"
+ *  callType: 'voice',
+ *  description: 'Description of your event',
+ *  startTime: 1729551600
  * });
  * ```
  * @category Message
  */
-export declare function sendEventMessage(params: ChatSendEventMessageInput): Promise<ChatSendEventMessageOutput>;
-export {};
+export declare function sendEventMessage(chatId: any, options: EventMessageOptions): Promise<SendMessageReturn>;

package/dist/chat/functions/sendFileMessage.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 { SendMessageOptions, SendMessageReturn } from '..';
 import { MessageButtonsOptions } from '.';
 export interface FileMessageOptions extends SendMessageOptions {
@@ -196,12 +196,4 @@ export interface VideoMessageOptions extends FileMessageOptions, MessageButtonsO
  * @category Message
  * @return  {SendMessageReturn} The result
  */
-declare const chatSendFileMessageSchema: z.ZodObject<{
-    chatId: z.ZodAny;
-    content: z.ZodAny;
-    options: z.ZodAny;
-}, z.core.$strip>;
-export type ChatSendFileMessageInput = z.infer<typeof chatSendFileMessageSchema>;
-export type ChatSendFileMessageOutput = SendMessageReturn;
-export declare function sendFileMessage(params: ChatSendFileMessageInput): Promise<ChatSendFileMessageOutput>;
-export {};
+export declare function sendFileMessage(chatId: string | Wid, content: string | Blob | File, options: AutoDetectMessageOptions | AudioMessageOptions | DocumentMessageOptions | ImageMessageOptions | VideoMessageOptions | StickerMessageOptions): Promise<SendMessageReturn>;

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

@@ -13,67 +13,44 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { z } from 'zod';
+import { Wid } from '../../whatsapp';
 import { SendMessageOptions, SendMessageReturn } from '..';
-export interface GroupInviteMessageOptions extends SendMessageOptions {
+export interface GroupInviteMessage extends SendMessageOptions {
     jpegThumbnail?: string;
     inviteCode: string;
     inviteCodeExpiration?: number;
-    groupId: string;
+    groupId: string | Wid;
     groupName?: string;
     caption?: string;
 }
-declare const chatSendGroupInviteMessageSchema: z.ZodObject<{
-    chatId: 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>;
-        jpegThumbnail: z.ZodOptional<z.ZodString>;
-        inviteCode: z.ZodString;
-        inviteCodeExpiration: z.ZodOptional<z.ZodNumber>;
-        groupId: z.ZodString;
-        groupName: z.ZodOptional<z.ZodString>;
-        caption: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export type ChatSendGroupInviteMessageInput = z.infer<typeof chatSendGroupInviteMessageSchema>;
-export type ChatSendGroupInviteMessageOutput = SendMessageReturn;
 /**
  * Send a group invite message
  *
  * @example
  * ```javascript
- * WPP.chat.sendGroupInviteMessage({
- *   chatId: '[number]@c.us',
- *   options: {
- *     inviteCode: '123',
- *     groupId: '789@g.us'
- *   }
- * });
+ * WPP.chat.sendGroupInviteMessage(
+ *  '[number]@c.us',
+ *  {
+ *    inviteCode: '123',
+ *    groupId: '789@g.us'
+ *  }
+ * );
  *
  * // After a invite
- * const result = await WPP.group.addParticipants({ groupId: '789@g.us', participantsIds: ['123@c.us'] });
+ * const result = await WPP.group.addParticipants('789@g.us', '123@c.us');
  * const participant = result['123@c.us'];
  * if (participant.invite_code) {
- *   WPP.chat.sendGroupInviteMessage({
- *     chatId: '123@c.us',
- *     options: {
+ *   WPP.chat.sendGroupInviteMessage(
+ *     '123@c.us',
+ *     {
  *       inviteCode: participant.invite_code,
  *       inviteCodeExpiration: participant.invite_code_exp,
  *       groupId: '789@g.us'
  *     }
- *   });
+ *   );
  * }
  * ```
  *
  * @category Message
  */
-export declare function sendGroupInviteMessage(params: ChatSendGroupInviteMessageInput): Promise<ChatSendGroupInviteMessageOutput>;
-export {};
+export declare function sendGroupInviteMessage(chatId: any, options: GroupInviteMessage): Promise<SendMessageReturn>;

package/dist/chat/functions/sendListMessage.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 ListMessageOptions extends SendMessageOptions {
     buttonText: string;
@@ -29,62 +28,30 @@ export interface ListMessageOptions extends SendMessageOptions {
         }>;
     }>;
 }
-declare const chatSendListMessageSchema: z.ZodObject<{
-    chatId: 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>;
-        buttonText: z.ZodString;
-        description: z.ZodString;
-        title: z.ZodOptional<z.ZodString>;
-        footer: z.ZodOptional<z.ZodString>;
-        sections: z.ZodArray<z.ZodObject<{
-            title: z.ZodString;
-            rows: z.ZodArray<z.ZodObject<{
-                rowId: z.ZodString;
-                title: z.ZodString;
-                description: z.ZodString;
-            }, z.core.$strip>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export type ChatSendListMessageInput = z.infer<typeof chatSendListMessageSchema>;
-export type ChatSendListMessageOutput = SendMessageReturn;
 /**
  * Send a list message
  *
  * @example
  * ```javascript
- * WPP.chat.sendListMessage({
- *   chatId: '[number]@c.us',
- *   options: {
- *     buttonText: 'Click Me!',
- *     description: "Hello it's list message",
- *     title: 'Hello user',
- *     footer: 'Click and choose one',
- *     sections: [{
- *       title: 'Section 1',
- *       rows: [{
- *         rowId: 'rowid1',
- *         title: 'Row 1',
- *         description: "Hello it's description 1",
- *       },{
- *         rowId: 'rowid2',
- *         title: 'Row 2',
- *         description: "Hello it's description 2",
- *       }]
+ * WPP.chat.sendListMessage('[number]@c.us', {
+ *   buttonText: 'Click Me!', //required
+ *   description: "Hello it's list message", //required
+ *   title: 'Hello user', //optional
+ *   footer: 'Click and choose one', //optional
+ *   sections: [{
+ *     title: 'Section 1',
+ *     rows: [{
+ *       rowId: 'rowid1',
+ *       title: 'Row 1',
+ *       description: "Hello it's description 1",
+ *     },{
+ *       rowId: 'rowid2',
+ *       title: 'Row 2',
+ *       description: "Hello it's description 2",
  *     }]
- *   }
+ *   }]
  * });
  * ```
  * @category Message
  */
-export declare function sendListMessage(params: ChatSendListMessageInput): Promise<ChatSendListMessageOutput>;
-export {};
+export declare function sendListMessage(chatId: any, options: ListMessageOptions): Promise<SendMessageReturn>;