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

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

@@ -13,6 +13,7 @@
  * 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';
@@ -28,26 +29,41 @@ 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 invoice message
+ * Send a PIX key invoice message (Brazil Pix Key)
  * To send (prices, tax, shipping or discount), for example: USD 12.90, send them without dots or commas, like: 12900
  *
  * @example
  * ```javascript
- * // Send PIX Key Message (Brazil Pix Key)
- * WPP.chat.sendPixKeyMessage('[number]@c.us', {
+ * WPP.chat.sendPixKeyMessage({
+ *   chatId: '[number]@c.us',
+ *   params: {
  *     keyType: 'CNPJ',
  *     name: 'WPPCONNECT-TEAM',
  *     key: '33460516000178',
  *     instructions: 'Pay text for instructions here',
+ *   }
  * });
- *
  * ```
  * @category Message
  */
-export declare function sendPixKeyMessage(chatId: any, params: {
-    keyType: 'CNPJ' | 'CPF' | 'PHONE' | 'EMAIL' | 'EVP';
-    name: string;
-    key: string;
-    instructions?: string;
-}, options?: SendMessageOptions): Promise<SendMessageReturn>;
+export declare function sendPixKeyMessage(input: ChatSendPixKeyMessageInput): Promise<ChatSendPixKeyMessageOutput>;
+export {};

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

@@ -13,10 +13,30 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { RawMessage, SendMessageOptions, SendMessageReturn } from '..';
+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;
 /**
  * Send a raw message
  *
  * @category Message
  */
-export declare function sendRawMessage(chatId: any, rawMessage: RawMessage, options?: SendMessageOptions): Promise<SendMessageReturn>;
+export declare function sendRawMessage(params: ChatSendRawMessageInput): Promise<ChatSendRawMessageOutput>;
+export {};

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

@@ -13,8 +13,15 @@
  * 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 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;
+};
 /**
  * Send a reaction to a message
  *
@@ -23,14 +30,13 @@ import { MsgKey, MsgModel } from '../../whatsapp';
  * @example
  * ```javascript
  * // to react a message
- * WPP.chat.sendReactionToMessage('[message_id]', '🤯');
+ * WPP.chat.sendReactionToMessage({ messageId: '[message_id]', reaction: '🤯' });
  *
  * // to remove
- * WPP.chat.sendReactionToMessage('[message_id]', false);
+ * WPP.chat.sendReactionToMessage({ messageId: '[message_id]', reaction: false });
  *
  * ```
  * @category Message
  */
-export declare function sendReactionToMessage(messageId: string | MsgKey | MsgModel | Stringable, reaction: string | false | null): Promise<{
-    sendMsgResult: string;
-}>;
+export declare function sendReactionToMessage(params: ChatSendReactionToMessageInput): Promise<ChatSendReactionToMessageOutput>;
+export {};

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

@@ -13,6 +13,7 @@
  * 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;
@@ -20,18 +21,28 @@ 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('[number]@c.us', {
- *  title: "Title of event call"
- *  description: 'Description for Call",
- *  callType: 'voice'
- *  scheduledTimestampMs: 1696084222000
+ * WPP.chat.sendScheduledCallMessage({
+ *   chatId: '[number]@c.us',
+ *   options: {
+ *     title: 'Title of event call',
+ *     description: 'Description for Call',
+ *     callType: 'voice',
+ *     scheduledTimestampMs: 1696084222000
+ *   }
  * });
  * ```
  * @category Message
  */
-export declare function sendScheduledCallMessage(chatId: any, options: ScheduledCallMessageOptions): Promise<SendMessageReturn>;
+export declare function sendScheduledCallMessage(params: ChatSendScheduledCallMessageInput): Promise<ChatSendScheduledCallMessageOutput>;
+export {};

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

@@ -13,42 +13,25 @@
  * 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('[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
- * });
+ * WPP.chat.sendTextMessage({ chatId: '<chatId>', content: 'Hello new contact' });
  * ```
  * @category Message
  */
-export declare function sendTextMessage(chatId: any, content: any, options?: TextMessageOptions): Promise<SendMessageReturn>;
+export declare function sendTextMessage(params: ChatSendTextMessageInput): Promise<ChatSendTextMessageOutput>;
+export {};

package/dist/chat/functions/sendVCardContactMessage.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,35 +13,60 @@
  * 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 { 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 a VCard as message
+ * Send one or more contacts as a vCard message
+ *
  * @example
  * ```javascript
- * // single contact
- * WPP.chat.sendVCardContactMessage('[number]@c.us', {
- *   id: '123456@c.us',
- *   name: 'The Contact Name'
+ * // Send a single contact by ID (name resolved from contact store)
+ * WPP.chat.sendVCardContactMessage({
+ *   chatId: '[number]@c.us',
+ *   contacts: ['[contact]@c.us'],
  * });
  *
- * // multiple contacts
- * WPP.chat.sendVCardContactMessage('[number]@c.us', [
- *   {
- *     id: '123456@c.us',
- *     name: 'The Contact Name'
- *   },
- *   {
- *     id: '456789@c.us',
- *     name: 'Another Contact'
- *   },
- * ]);
+ * // Send a single contact with a custom display name
+ * WPP.chat.sendVCardContactMessage({
+ *   chatId: '[number]@c.us',
+ *   contacts: [{ id: '[contact]@c.us', name: 'John Doe' }],
+ * });
  *
+ * // 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(chatId: any, contacts: string | Wid | VCardContact | (string | Wid | VCardContact)[], options?: SendMessageOptions): Promise<SendMessageReturn>;
+export declare function sendVCardContactMessage(params: ChatSendVCardContactMessageInput): Promise<ChatSendVCardContactMessageOutput>;
+export {};

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

@@ -13,6 +13,7 @@
  * 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",
@@ -27,10 +28,16 @@ export declare enum FilterChatListTypes {
     LABELS = "labels",
     ASSIGNED_TO_YOU = "assigned_to_you"
 }
-export declare function setChatList(type: FilterChatListTypes, ids?: string | string[]): Promise<{
+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 = {
     type: FilterChatListTypes;
     list?: string[];
-}>;
+};
+export declare function setChatList(params: ChatSetChatListInput): Promise<ChatSetChatListOutput>;
 /**
  * Custom Wrap function with the callback
  *
@@ -40,3 +47,4 @@ export declare function setChatList(type: FilterChatListTypes, ids?: string | st
  * 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,8 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Wid } from '../../whatsapp';
-export declare function setInputText(text: string, chatId?: string | Wid): Promise<{
+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 = {
     text: string;
     timestamp: number;
-}>;
+};
+export declare function setInputText(params: ChatSetInputTextInput): Promise<ChatSetInputTextOutput>;
+export {};

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

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

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

@@ -13,35 +13,32 @@
  * 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
+ * Star/Unstar a message or messages
  *
  * @example
  * ```javascript
  * // star a message
- * WPP.chat.starMessage('<message id>');
+ * WPP.chat.starMessage({ ids: '<message id>' });
  *
  * // unstar a message
- * WPP.chat.starMessage('<message id>', false);
- * ```
- * @category Message
- */
-export declare function starMessage(id: string, star: boolean): Promise<StarMessageReturn>;
-/**
- * Star/Unstar messages
+ * WPP.chat.starMessage({ ids: '<message id>', star: false });
  *
- * @example
- * ```javascript
  * // star messages
- * WPP.chat.starMessage(['<message id>', '<message id>']);
- *
- * // unstar messages
- * WPP.chat.starMessage(['<message id>', '<message id>'], false);
+ * WPP.chat.starMessage({ ids: ['<message id>', '<message id>'] });
  * ```
  * @category Message
  */
-export declare function starMessage(ids: string[], star: boolean): Promise<StarMessageReturn[]>;
+export declare function starMessage(params: ChatStarMessageInput): Promise<ChatStarMessageOutput>;
+export {};

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

package/dist/chat/types.d.ts

@@ -13,109 +13,21 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { z } from 'zod';
 import { ModelPropertiesContructor, MsgKey, MsgModel, SendMsgResultObject, Wid } from '../whatsapp';
 export type { SendMsgResultObject };
-export interface SendMessageOptions {
-    /**
-     * Create a new chat to a new contact
-     *
-     * @deprecated This option is no longer used. Chats are automatically created when sending messages.
-     * @default false
-     *
-     * @example
-     * ```javascript
-     * WPP.chat.sendTextMessage('[number]@c.us', 'Hello new contact', {
-     *   createChat: true
-     * });
-     * ```
-     */
-    createChat?: boolean;
-    /**
-     * Automatic detect and add the mentioned contacts with @[number]
-     *
-     * @default true
-     *
-     * @example
-     * ```javascript
-     * WPP.chat.sendTextMessage('[number]@c.us', 'Hello @123 and @456', {
-     *   detectMentioned: true
-     * });
-     * ```
-     */
-    detectMentioned?: boolean;
-    /**
-     * Automatically mark chat is read after send a message
-     *
-     * @default true
-     *
-     * @example
-     * ```javascript
-     * WPP.chat.sendTextMessage('[number]@c.us', 'Replying your message', {
-     *   markIsRead: true
-     * });
-     * ```
-     */
-    markIsRead?: boolean;
-    /**
-     *
-     */
-    messageId?: string | MsgKey;
-    /**
-     * Define a mentioned list for a message
-     * This option work better with a message with mension
-     *
-     * @example
-     * ```javascript
-     * WPP.chat.sendTextMessage('[number]@c.us', 'Hello @123 and @456', {
-     *   mentionedList: ['123@c.us', '456@c.us']
-     * })
-     * ```
-     */
-    mentionedList?: (string | Wid)[];
-    /**
-     * Quote a message, like a reply message
-     *
-     * @example
-     * ```javascript
-     * WPP.chat.sendTextMessage('[number]@c.us', 'This is a reply', {
-     *   quotedMsg: 'true_[number]@c.us_3EB0F435D95D32C4C638'
-     * })
-     * ```
-     */
-    quotedMsg?: string | MsgKey | MsgModel;
-    /**
-     * Quote a message using a previously saved payload.
-     * The payload must be the JSON string representation of a raw message.
-     * Raw messages can be obtained when using {@link getMessageById} or {@link getMessages}
-     * When provided it has priority over {@link quotedMsg}.
-     */
-    quotedMsgPayload?: string;
-    /**
-     * Wait for send while the ACK of message is SENT(1)
-     *
-     * @default true
-     *
-     * @example
-     * ```javascript
-     * WPP.chat.sendTextMessage('[number]@c.us', 'Wait for sent', {
-     *   waitForAck: true
-     * })
-     * ```
-     */
-    waitForAck?: boolean;
-    /**
-     * Delay some time (in ms) before sending message
-     * While delaying, Typing Status is used to look like a human interaction
-     * @default 0
-     * @example
-     * ```javascript
-     * WPP.chat.sendTextMessage('[number]@c.us', 'Delay with typing', {
-     *   delay: 4000
-     * })
-     * ```
-     */
-    delay?: number;
-}
+export declare const sendMessageOptionsSchema: 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>;
+export type SendMessageOptions = z.infer<typeof sendMessageOptionsSchema>;
 export interface SendMessageReturn {
     id: string;
     from?: string;

package/dist/community/functions/addSubgroups.d.ts

@@ -1,5 +1,5 @@
 /*!
- * Copyright 2023 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,21 +13,31 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Wid } from '../../whatsapp';
+import { z } from 'zod';
+declare const communityAddSubgroupsSchema: z.ZodObject<{
+    communityId: z.ZodString;
+    subgroupIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type CommunityAddSubgroupsInput = z.infer<typeof communityAddSubgroupsSchema>;
+export type CommunityAddSubgroupsOutput = {
+    failedGroups: {
+        error: string;
+        jid: string;
+    }[];
+    linkedGroupJids: string[];
+};
 /**
- * Add groups do community
+ * Add groups to a community
  *
  * @example
  * ```javascript
- * await WPP.community.addSubgroups('123456@g.us', ['123456@g.us', '123456@g.us']);
+ * await WPP.community.addSubgroups({
+ *   communityId: '123456@g.us',
+ *   subgroupIds: ['[groupId1]', '[groupId2]'],
+ * });
  * ```
  *
  * @category Community
  */
-export declare function addSubgroups(parentGroupId: string | Wid, subgroupIds: (string | Wid) | (string | Wid)[]): Promise<{
-    failedGroups: {
-        error: string;
-        jid: string;
-    }[];
-    linkedGroupJids: string[];
-}>;
+export declare function addSubgroups(params: CommunityAddSubgroupsInput): Promise<CommunityAddSubgroupsOutput>;
+export {};