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

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

@@ -13,28 +13,20 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { z } from 'zod';
-import { ChatModel } from '../../whatsapp';
-declare const chatListSchema: z.ZodObject<{
-    options: z.ZodOptional<z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        count: z.ZodOptional<z.ZodNumber>;
-        direction: z.ZodOptional<z.ZodEnum<{
-            after: "after";
-            before: "before";
-        }>>;
-        onlyCommunities: z.ZodOptional<z.ZodBoolean>;
-        onlyGroups: z.ZodOptional<z.ZodBoolean>;
-        onlyNewsletter: z.ZodOptional<z.ZodBoolean>;
-        onlyUsers: z.ZodOptional<z.ZodBoolean>;
-        onlyWithUnreadMessage: z.ZodOptional<z.ZodBoolean>;
-        onlyArchived: z.ZodOptional<z.ZodBoolean>;
-        withLabels: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        ignoreGroupMetadata: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type ChatListInput = z.infer<typeof chatListSchema>;
-export type ChatListOutput = ChatModel[];
+import { ChatModel, Wid } from '../../whatsapp';
+export interface ChatListOptions {
+    id?: Wid;
+    count?: number;
+    direction?: 'after' | 'before';
+    onlyCommunities?: boolean;
+    onlyGroups?: boolean;
+    onlyNewsletter?: boolean;
+    onlyUsers?: boolean;
+    onlyWithUnreadMessage?: boolean;
+    onlyArchived?: boolean;
+    withLabels?: string[];
+    ignoreGroupMetadata?: boolean;
+}
 /**
  * Return a list of chats
  *
@@ -44,31 +36,39 @@ export type ChatListOutput = ChatModel[];
  * const chats = await WPP.chat.list();
  *
  * // Some chats
- * const chats = await WPP.chat.list({ options: { count: 20 } });
+ * const chats = WPP.chat.list({count: 20});
  *
  * // 20 chats before specific chat
- * const chats = await WPP.chat.list({ options: { count: 20, direction: 'before', id: '[number]@c.us' } });
+ * const chats = WPP.chat.list({count: 20, direction: 'before', id: '[number]@c.us'});
  *
  * // Only users chats
- * const chats = await WPP.chat.list({ options: { onlyUsers: true } });
+ * const chats = await WPP.chat.list({onlyUsers: true});
  *
  * // Only groups chats
- * const chats = await WPP.chat.list({ options: { onlyGroups: true } });
+ * const chats = await WPP.chat.list({onlyGroups: true});
  *
  * // Only communities chats
- * const chats = await WPP.chat.list({ options: { onlyCommunities: true } });
+ * const chats = await WPP.chat.list({onlyCommunities: true});
  *
  * // Only Newsletter
- * const chats = await WPP.chat.list({ options: { onlyNewsletter: true } });
+ * const chats = await WPP.chat.list({onlyNewsletter: true});
  *
- * // Only with label text
- * const chats = await WPP.chat.list({ options: { withLabels: ['Test'] } });
+ * // Only with label Text
+ * const chats = await WPP.chat.list({withLabels: ['Test']});
+ *
+ * // Only with label id
+ * const chats = await WPP.chat.list({withLabels: ['1']});
+ *
+ * // Only with label with one of text or id
+ * const chats = await WPP.chat.list({withLabels: ['Alfa','5']});
  *
  * // Only archived chats
- * const chats = await WPP.chat.list({ options: { onlyArchived: true } });
+ * const chats = await WPP.chat.list({onlyArchived: true});
+ *
+ * // Ignore group metadata search
+ * const chats = await WPP.chat.list({ignoreGroupMetadata: true})
  * ```
  *
  * @category Chat
  */
-export declare function list(params?: ChatListInput): Promise<ChatListOutput>;
-export {};
+export declare function list(options?: ChatListOptions): Promise<ChatModel[]>;

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

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

package/dist/chat/functions/markIsPaused.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 chatMarkIsPausedSchema: z.ZodObject<{
-    chatId: z.ZodString;
-}, z.core.$strip>;
-export type ChatMarkIsPausedInput = z.infer<typeof chatMarkIsPausedSchema>;
-export type ChatMarkIsPausedOutput = void;
+import { Wid } from '../../whatsapp';
 /**
  * Mark a chat is paused state
  *
@@ -29,5 +24,4 @@ export type ChatMarkIsPausedOutput = void;
  * ```
  * @category Chat
  */
-export declare function markIsPaused(params: ChatMarkIsPausedInput): Promise<ChatMarkIsPausedOutput>;
-export {};
+export declare function markIsPaused(chatId: string | Wid): Promise<void>;

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

@@ -13,14 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { z } from 'zod';
-declare const chatMarkIsReadSchema: z.ZodObject<{
-    chatId: z.ZodString;
-}, z.core.$strip>;
-export type ChatMarkIsReadInput = z.infer<typeof chatMarkIsReadSchema>;
-export type ChatMarkIsReadOutput = {
-    unreadCount: number;
-};
+import { Wid } from '../../whatsapp';
 /**
  * Mark a chat as read and send SEEN event
  *
@@ -31,5 +24,7 @@ export type ChatMarkIsReadOutput = {
  * ```
  * @category Chat
  */
-export declare function markIsRead(params: ChatMarkIsReadInput): Promise<ChatMarkIsReadOutput>;
-export {};
+export declare function markIsRead(chatId: string | Wid): Promise<{
+    wid: Wid;
+    unreadCount: number;
+}>;

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

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

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

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

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

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

@@ -13,18 +13,7 @@
  * 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)
@@ -45,5 +34,12 @@ export type ChatMuteOutput = {
  *
  * @category Chat
  */
-export declare function mute(params: ChatMuteInput): Promise<ChatMuteOutput>;
-export {};
+export declare function mute(chatId: string | Wid, time: {
+    expiration: number | Date;
+} | {
+    duration: number;
+}): Promise<{
+    wid: Wid;
+    expiration: number;
+    isMuted: boolean;
+}>;

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

@@ -13,25 +13,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-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;
+import { Wid } from '../../whatsapp';
 /**
  * Open the chat in the WhatsApp interface in a specific message
  *
  * @example
  * ```javascript
- * await WPP.chat.openChatAt({ chatId: '[number]@c.us', messageId: '<message_id>' });
+ * await WPP.chat.openChatAt('[number]@c.us', <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(params: ChatOpenChatAtInput): Promise<ChatOpenChatAtOutput>;
-export {};
+export declare function openChatAt(chatId: string | Wid, messageId: string, chatEntryPoint?: string | undefined): Promise<boolean>;

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

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

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

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

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

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

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

@@ -13,20 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { z } from 'zod';
-import { MsgModel } from '../../whatsapp';
+import { MsgKey, 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
  *
@@ -59,7 +47,11 @@ export type ChatPinMsgOutput = {
  * ```
  * @category Chat
  */
-export declare function pinMsg(params: ChatPinMsgInput): Promise<ChatPinMsgOutput>;
+export declare function pinMsg(msgId: string | MsgKey, pin?: boolean, duration?: number | PinExpiryDurationOption): Promise<{
+    message: MsgModel;
+    pinned: boolean;
+    result: SendMsgResult;
+}>;
 /**
  * Unpin a message in chat
  *
@@ -75,5 +67,8 @@ export declare function pinMsg(params: ChatPinMsgInput): Promise<ChatPinMsgOutpu
  * ```
  * @category Chat
  */
-export declare function unpinMsg(msgId: string): Promise<ChatPinMsgOutput>;
-export {};
+export declare function unpinMsg(msgId: string | MsgKey): Promise<{
+    message: MsgModel;
+    pinned: boolean;
+    result: SendMsgResult;
+}>;

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

@@ -13,39 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-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;
-};
+import type { AudioMessageOptions } from './sendFileMessage';
 /**
  * Prepare waveform form message audio file
  *
  * @category Message
  * @internal
  */
-export declare function prepareAudioWaveform(params: ChatPrepareAudioWaveformInput): Promise<ChatPrepareAudioWaveformOutput>;
-export {};
+export declare function prepareAudioWaveform(options: AudioMessageOptions, file: File): Promise<undefined | {
+    duration: number;
+    waveform: Uint8Array;
+}>;

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 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;
+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;
+    };
+}
 /**
  * Prepare a message for link preview
  *
  * @category Message
  * @internal
  */
-export declare function prepareLinkPreview(params: ChatPrepareLinkPreviewInput): Promise<ChatPrepareLinkPreviewOutput>;
-export {};
+export declare function prepareLinkPreview<T extends RawMessage>(message: T, options: LinkPreviewOptions): Promise<T>;

package/dist/chat/functions/prepareMessageButtons.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 { RawMessage } from '..';
 export type MessageButtonsTypes = {
     id: string;
@@ -42,49 +41,10 @@ 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>(params: ChatPrepareMessageButtonsInput): T;
-export {};
+export declare function prepareMessageButtons<T extends RawMessage>(message: T, options: MessageButtonsOptions): T;