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

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

@@ -13,7 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Wid } from '../../whatsapp';
+import { z } from 'zod';
+declare const chatMarkIsRecordingSchema: z.ZodObject<{
+    chatId: z.ZodString;
+    duration: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ChatMarkIsRecordingInput = z.infer<typeof chatMarkIsRecordingSchema>;
+export type ChatMarkIsRecordingOutput = void;
 /**
  * Mark a chat to recording state
  * and keep sending "is recording"
@@ -28,4 +34,5 @@ import { Wid } from '../../whatsapp';
  * ```
  * @category Chat
  */
-export declare function markIsRecording(chatId: string | Wid, duration?: number): Promise<void>;
+export declare function markIsRecording(params: ChatMarkIsRecordingInput): Promise<ChatMarkIsRecordingOutput>;
+export {};

package/dist/chat/functions/markIsUnread.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 chatMarkIsUnreadSchema: z.ZodObject<{
+    chatId: z.ZodString;
+}, z.core.$strip>;
+export type ChatMarkIsUnreadInput = z.infer<typeof chatMarkIsUnreadSchema>;
+export type ChatMarkIsUnreadOutput = void;
 /**
  * Mark a chat as unread
  *
@@ -24,6 +29,5 @@ import { Wid } from '../../whatsapp';
  * ```
  * @category Chat
  */
-export declare function markIsUnread(chatId: string | Wid): Promise<{
-    wid: Wid;
-}>;
+export declare function markIsUnread(params: ChatMarkIsUnreadInput): Promise<ChatMarkIsUnreadOutput>;
+export {};

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

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

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

@@ -13,7 +13,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { z } from 'zod';
 import { Wid } from '../../whatsapp';
+declare const chatMuteSchema: z.ZodObject<{
+    chatId: z.ZodString;
+    time: z.ZodAny;
+}, z.core.$strip>;
+export type ChatMuteInput = z.infer<typeof chatMuteSchema>;
+export type ChatMuteOutput = {
+    wid: Wid;
+    expiration: number;
+    isMuted: boolean;
+};
 /**
  * Mute a chat, you can use duration or expiration
  * For expiration, use unix timestamp (seconds only)
@@ -34,12 +45,5 @@ import { Wid } from '../../whatsapp';
  *
  * @category Chat
  */
-export declare function mute(chatId: string | Wid, time: {
-    expiration: number | Date;
-} | {
-    duration: number;
-}): Promise<{
-    wid: Wid;
-    expiration: number;
-    isMuted: boolean;
-}>;
+export declare function mute(params: ChatMuteInput): Promise<ChatMuteOutput>;
+export {};

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

@@ -13,17 +13,25 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Wid } from '../../whatsapp';
+import { z } from 'zod';
+declare const chatOpenChatAtSchema: z.ZodObject<{
+    chatId: z.ZodString;
+    messageId: z.ZodString;
+    chatEntryPoint: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ChatOpenChatAtInput = z.infer<typeof chatOpenChatAtSchema>;
+export type ChatOpenChatAtOutput = boolean;
 /**
  * Open the chat in the WhatsApp interface in a specific message
  *
  * @example
  * ```javascript
- * await WPP.chat.openChatAt('[number]@c.us', <message_id>);
+ * await WPP.chat.openChatAt({ chatId: '[number]@c.us', messageId: '<message_id>' });
  * ```
  *
  * @argument chatEntryPoint Optional chat entry point: "Chatlist" for any existing chat in the left panel, undefined for any other case.
  *
  * @category Chat
  */
-export declare function openChatAt(chatId: string | Wid, messageId: string, chatEntryPoint?: string | undefined): Promise<boolean>;
+export declare function openChatAt(params: ChatOpenChatAtInput): Promise<ChatOpenChatAtOutput>;
+export {};

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

@@ -13,7 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Wid } from '../../whatsapp';
+import { z } from 'zod';
+declare const chatOpenChatBottomSchema: z.ZodObject<{
+    chatId: z.ZodString;
+    chatEntryPoint: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ChatOpenChatBottomInput = z.infer<typeof chatOpenChatBottomSchema>;
+export type ChatOpenChatBottomOutput = boolean;
 /**
  * Open the chat in the WhatsApp interface in bottom position
  *
@@ -26,4 +32,5 @@ import { Wid } from '../../whatsapp';
  *
  * @category Chat
  */
-export declare function openChatBottom(chatId: string | Wid, chatEntryPoint?: string | undefined): Promise<boolean>;
+export declare function openChatBottom(params: ChatOpenChatBottomInput): Promise<ChatOpenChatBottomOutput>;
+export {};

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

@@ -13,7 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Wid } from '../../whatsapp';
+import { z } from 'zod';
+declare const chatOpenChatFromUnreadSchema: z.ZodObject<{
+    chatId: z.ZodString;
+    chatEntryPoint: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ChatOpenChatFromUnreadInput = z.infer<typeof chatOpenChatFromUnreadSchema>;
+export type ChatOpenChatFromUnreadOutput = boolean;
 /**
  * Open the chat in the WhatsApp interface from first unread message
  *
@@ -26,4 +32,5 @@ import { Wid } from '../../whatsapp';
  *
  * @category Chat
  */
-export declare function openChatFromUnread(chatId: string | Wid, chatEntryPoint?: string | undefined): Promise<boolean>;
+export declare function openChatFromUnread(params: ChatOpenChatFromUnreadInput): Promise<ChatOpenChatFromUnreadOutput>;
+export {};

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

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

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

@@ -13,8 +13,20 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { MsgKey, MsgModel } from '../../whatsapp';
+import { z } from 'zod';
+import { MsgModel } from '../../whatsapp';
 import { PinExpiryDurationOption, SendMsgResult } from '../../whatsapp/enums';
+declare const chatPinMsgSchema: z.ZodObject<{
+    msgId: z.ZodString;
+    pin: z.ZodOptional<z.ZodBoolean>;
+    duration: z.ZodOptional<z.ZodDefault<z.ZodEnum<typeof PinExpiryDurationOption>>>;
+}, z.core.$strip>;
+export type ChatPinMsgInput = z.infer<typeof chatPinMsgSchema>;
+export type ChatPinMsgOutput = {
+    message: MsgModel;
+    pinned: boolean;
+    result: SendMsgResult;
+};
 /**
  * Pin a message in chat
  *
@@ -47,11 +59,7 @@ import { PinExpiryDurationOption, SendMsgResult } from '../../whatsapp/enums';
  * ```
  * @category Chat
  */
-export declare function pinMsg(msgId: string | MsgKey, pin?: boolean, duration?: number | PinExpiryDurationOption): Promise<{
-    message: MsgModel;
-    pinned: boolean;
-    result: SendMsgResult;
-}>;
+export declare function pinMsg(params: ChatPinMsgInput): Promise<ChatPinMsgOutput>;
 /**
  * Unpin a message in chat
  *
@@ -67,8 +75,5 @@ export declare function pinMsg(msgId: string | MsgKey, pin?: boolean, duration?:
  * ```
  * @category Chat
  */
-export declare function unpinMsg(msgId: string | MsgKey): Promise<{
-    message: MsgModel;
-    pinned: boolean;
-    result: SendMsgResult;
-}>;
+export declare function unpinMsg(msgId: string): Promise<ChatPinMsgOutput>;
+export {};

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

@@ -13,14 +13,39 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { AudioMessageOptions } from './sendFileMessage';
+import { z } from 'zod';
+declare const chatPrepareAudioWaveformSchema: z.ZodObject<{
+    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>;
+        type: z.ZodLiteral<"audio">;
+        caption: z.ZodOptional<z.ZodString>;
+        footer: z.ZodOptional<z.ZodString>;
+        filename: z.ZodOptional<z.ZodString>;
+        mimetype: z.ZodOptional<z.ZodString>;
+        isPtt: z.ZodOptional<z.ZodBoolean>;
+        isViewOnce: z.ZodOptional<z.ZodBoolean>;
+        waveform: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    file: z.ZodCustom<File, File>;
+}, z.core.$strip>;
+export type ChatPrepareAudioWaveformInput = z.infer<typeof chatPrepareAudioWaveformSchema>;
+export type ChatPrepareAudioWaveformOutput = undefined | {
+    duration: number;
+    waveform: Uint8Array;
+};
 /**
  * Prepare waveform form message audio file
  *
  * @category Message
  * @internal
  */
-export declare function prepareAudioWaveform(options: AudioMessageOptions, file: File): Promise<undefined | {
-    duration: number;
-    waveform: Uint8Array;
-}>;
+export declare function prepareAudioWaveform(params: ChatPrepareAudioWaveformInput): Promise<ChatPrepareAudioWaveformOutput>;
+export {};

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

@@ -13,41 +13,41 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { z } from 'zod';
 import { RawMessage } from '..';
-export interface LinkPreviewOptions {
-    /**
-     * Send text message with link preview
-     *
-     * @default true
-     *
-     * @example
-     * ```javascript
-     * // Automatic detection
-     * WPP.chat.sendTextMessage('[number]@c.us', 'See https://www.youtube.com/watch?v=v1PBptSDIh8');
-     *
-     * // Overriding the title and description
-     * WPP.chat.sendTextMessage('[number]@c.us', 'See https://www.youtube.com/watch?v=v1PBptSDIh8', {
-     *   linkPreview: {
-     *     title: 'Another text',
-     *     description: 'Another description'
-     *   }
-     * });
-     * ```
-     */
-    linkPreview?: boolean | {
-        title?: string;
-        description?: string;
-        canonicalUrl?: string;
-        matchedText?: string;
-        richPreviewType?: number;
-        thumbnail?: string;
-        doNotPlayInline: boolean;
-    };
-}
+export declare const linkPreviewOptionsSchema: 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>;
+export type LinkPreviewOptions = z.infer<typeof linkPreviewOptionsSchema>;
+declare const chatPrepareLinkPreviewSchema: z.ZodObject<{
+    message: z.ZodCustom<RawMessage, RawMessage>;
+    options: 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.core.$strip>;
+export type ChatPrepareLinkPreviewInput = z.infer<typeof chatPrepareLinkPreviewSchema>;
+export type ChatPrepareLinkPreviewOutput = RawMessage;
 /**
  * Prepare a message for link preview
  *
  * @category Message
  * @internal
  */
-export declare function prepareLinkPreview<T extends RawMessage>(message: T, options: LinkPreviewOptions): Promise<T>;
+export declare function prepareLinkPreview(params: ChatPrepareLinkPreviewInput): Promise<ChatPrepareLinkPreviewOutput>;
+export {};

package/dist/chat/functions/prepareMessageButtons.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 { RawMessage } from '..';
 export type MessageButtonsTypes = {
     id: string;
@@ -41,10 +42,49 @@ export interface MessageButtonsOptions {
      */
     footer?: string;
 }
+export declare const messageButtonsOptionsSchema: z.ZodObject<{
+    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>;
+declare const chatPrepareMessageButtonsSchema: z.ZodObject<{
+    message: z.ZodCustom<RawMessage, RawMessage>;
+    options: z.ZodObject<{
+        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 ChatPrepareMessageButtonsInput = z.infer<typeof chatPrepareMessageButtonsSchema>;
 /**
  * Prepare a message for buttons
  *
  * @category Message
  * @internal
  */
-export declare function prepareMessageButtons<T extends RawMessage>(message: T, options: MessageButtonsOptions): T;
+export declare function prepareMessageButtons<T extends RawMessage>(params: ChatPrepareMessageButtonsInput): T;
+export {};

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

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

package/dist/chat/functions/replyToButtonMessage.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 interface ButtonReplyOptions {
     /**
      * The index of the button to reply to (0-based)
@@ -41,4 +42,14 @@ export interface ButtonReplyOptions {
  * ```
  * @category Message
  */
-export declare function replyToButtonMessage(chatId: any, messageId: string, options: ButtonReplyOptions): Promise<any>;
+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 {};

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

@@ -13,16 +13,23 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { SendMessageOptions, SendMessageReturn } from '..';
+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;
 /**
  * Request the real phone number for a LID chat ([number]@lid)
  *
  * @example
  * ```javascript
  * // Request
- * WPP.chat.requestPhoneNumber('[number]@lid');
+ * WPP.chat.requestPhoneNumber({ chatId: '[number]@lid' });
  * ```
  *
  * @category Message
  */
-export declare function requestPhoneNumber(chatId: any, options?: SendMessageOptions): Promise<SendMessageReturn>;
+export declare function requestPhoneNumber(params: ChatRequestPhoneNumberInput): Promise<ChatRequestPhoneNumberOutput>;
+export {};

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 { Wid } from '../../whatsapp';
+import { z } from 'zod';
 import { SendMessageOptions, SendMessageReturn } from '..';
 export interface CatalogMessageOptions extends SendMessageOptions {
     jpegThumbnail?: string;
@@ -21,23 +21,45 @@ 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(
- *  '[number]@c.us',
- *  '[number]@c.us',
- * {
- *   title: 'My Catalog',
- *   description: 'This is my catalog',
- *   textMessage: 'Check out my catalog',
- *   jpegThumbnail: 'data:image/jpeg;base64,...'
- * }
- * );
+ * 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,...'
+ *   }
+ * });
  * ```
  *
  * @category Message
  */
-export declare function sendCatalogMessage(chatToSend: string | Wid, chatFromCatalog: string | Wid, opts: CatalogMessageOptions): Promise<SendMessageReturn>;
+export declare function sendCatalogMessage(params: ChatSendCatalogMessageInput): Promise<ChatSendCatalogMessageOutput>;
+export {};