@trungdlp/zca-js 1.0.0

package/dist/apis/removeUnreadMark.d.ts

@@ -0,0 +1,8 @@
+import { ThreadType } from "../models/index.js";
+export type RemoveUnreadMarkResponse = {
+    data: {
+        updateId: number;
+    };
+    status: number;
+};
+export declare const removeUnreadMarkFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (threadId: string, type?: ThreadType) => Promise<RemoveUnreadMarkResponse>;

package/dist/apis/removeUnreadMark.js

@@ -0,0 +1,50 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { ThreadType } from "../models/index.js";
+import { apiFactory } from "../utils.js";
+export const removeUnreadMarkFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.conversation[0]}/api/conv/removeUnreadMark`);
+    /**
+     * Remove unread mark from conversation
+     *
+     * @param threadId Thread ID
+     * @param type Thread type (User/Group)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function removeUnreadMark(threadId, type = ThreadType.User) {
+        const timestamp = Date.now();
+        const isGroup = type === ThreadType.Group;
+        const requestParams = {
+            param: JSON.stringify({
+                [isGroup ? "convsGroup" : "convsUser"]: [threadId],
+                [isGroup ? "convsUser" : "convsGroup"]: [],
+                [isGroup ? "convsGroupData" : "convsUserData"]: [
+                    {
+                        id: threadId,
+                        ts: timestamp,
+                    },
+                ],
+                [isGroup ? "convsUserData" : "convsGroupData"]: [],
+            }),
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(requestParams));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response, (result) => {
+            const data = result.data;
+            if (typeof data.data === "string") {
+                return {
+                    data: JSON.parse(data.data),
+                    status: data.status,
+                };
+            }
+            return result.data;
+        });
+    };
+});

package/dist/apis/removeUserFromGroup.d.ts

@@ -0,0 +1,4 @@
+export type RemoveUserFromGroupResponse = {
+    errorMembers: string[];
+};
+export declare const removeUserFromGroupFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (memberId: string | string[], groupId: string) => Promise<RemoveUserFromGroupResponse>;

package/dist/apis/removeUserFromGroup.js

@@ -0,0 +1,34 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const removeUserFromGroupFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/kickout`);
+    /**
+     * Remove user from existing group
+     *
+     * @param memberId User ID or list of user IDs to remove
+     * @param groupId Group ID
+     *
+     * @note Zalo might throw an error with code 165 if the user is not in the group, 166 if you don't have enough permissions or is not in the group
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function removeUserFromGroup(memberId, groupId) {
+        if (!Array.isArray(memberId))
+            memberId = [memberId];
+        const params = {
+            grid: groupId,
+            members: memberId,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/resetHiddenConversPin.d.ts

@@ -0,0 +1,2 @@
+export type ResetHiddenConversPinResponse = "";
+export declare const resetHiddenConversPinFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => () => Promise<"">;

package/dist/apis/resetHiddenConversPin.js

@@ -0,0 +1,20 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const resetHiddenConversPinFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.conversation[0]}/api/hiddenconvers/reset`);
+    /**
+     * Reset hidden conversation pin
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function resetHiddenConversPin() {
+        const params = {};
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/reuseAvatar.d.ts

@@ -0,0 +1,2 @@
+export type ReuseAvatarResponse = null;
+export declare const reuseAvatarFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (photoId: string) => Promise<null>;

package/dist/apis/reuseAvatar.js

@@ -0,0 +1,26 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const reuseAvatarFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/reuse-avatar`);
+    /**
+     * Reuse avatar
+     *
+     * @param photoId photo id from getAvatarList api
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function reuseAvatar(photoId) {
+        const params = {
+            photoId: photoId,
+            isPostSocial: 0,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/reviewPendingMemberRequest.d.ts

@@ -0,0 +1,14 @@
+export type ReviewPendingMemberRequestPayload = {
+    members: string | string[];
+    isApprove: boolean;
+};
+export declare enum ReviewPendingMemberRequestStatus {
+    SUCCESS = 0,
+    NOT_IN_PENDING_LIST = 170,
+    ALREADY_IN_GROUP = 178,
+    INSUFFICIENT_PERMISSION = 166
+}
+export type ReviewPendingMemberRequestResponse = {
+    [memberId: string]: ReviewPendingMemberRequestStatus;
+};
+export declare const reviewPendingMemberRequestFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (payload: ReviewPendingMemberRequestPayload, groupId: string) => Promise<ReviewPendingMemberRequestResponse>;

package/dist/apis/reviewPendingMemberRequest.js

@@ -0,0 +1,38 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export var ReviewPendingMemberRequestStatus;
+(function (ReviewPendingMemberRequestStatus) {
+    ReviewPendingMemberRequestStatus[ReviewPendingMemberRequestStatus["SUCCESS"] = 0] = "SUCCESS";
+    ReviewPendingMemberRequestStatus[ReviewPendingMemberRequestStatus["NOT_IN_PENDING_LIST"] = 170] = "NOT_IN_PENDING_LIST";
+    ReviewPendingMemberRequestStatus[ReviewPendingMemberRequestStatus["ALREADY_IN_GROUP"] = 178] = "ALREADY_IN_GROUP";
+    ReviewPendingMemberRequestStatus[ReviewPendingMemberRequestStatus["INSUFFICIENT_PERMISSION"] = 166] = "INSUFFICIENT_PERMISSION";
+})(ReviewPendingMemberRequestStatus || (ReviewPendingMemberRequestStatus = {}));
+export const reviewPendingMemberRequestFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/pending-mems/review`);
+    /**
+     * Review pending member(s) request
+     *
+     * @param payload - The payload containing data to review the pending member(s) request
+     * @param groupId - The id of the group to review the pending member(s) request
+     *
+     * @note Only the group leader and deputy group leader can review
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function reviewPendingMemberRequest(payload, groupId) {
+        if (!Array.isArray(payload.members))
+            payload.members = [payload.members];
+        const params = {
+            grid: groupId,
+            members: payload.members,
+            isApprove: payload.isApprove ? 1 : 0, // 1: approve, 0: reject
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/sendBankCard.d.ts

@@ -0,0 +1,9 @@
+import type { BinBankCard } from "../models/index.js";
+import { ThreadType } from "../models/index.js";
+export type SendBankCardPayload = {
+    binBank: BinBankCard;
+    numAccBank: string;
+    nameAccBank?: string;
+};
+export type SendBankCardResponse = "";
+export declare const sendBankCardFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (payload: SendBankCardPayload, threadId: string, type?: ThreadType) => Promise<"">;

package/dist/apis/sendBankCard.js

@@ -0,0 +1,37 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { ThreadType } from "../models/index.js";
+import { apiFactory } from "../utils.js";
+export const sendBankCardFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.zimsg[0]}/api/transfer/card`);
+    /**
+     * Send bank card
+     *
+     * @param payload The payload containing the bank card information
+     * @param threadId The ID of the thread to send the bank card to
+     * @param type The type of thread to send the bank card to
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function sendBankCard(payload, threadId, type = ThreadType.User) {
+        var _a;
+        const params = {
+            binBank: payload.binBank,
+            numAccBank: payload.numAccBank,
+            nameAccBank: ((_a = payload.nameAccBank) === null || _a === void 0 ? void 0 : _a.toUpperCase()) || "---",
+            cliMsgId: Date.now().toString(),
+            tsMsg: Date.now(),
+            destUid: threadId,
+            destType: type === ThreadType.Group ? 1 : 0,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/sendCard.d.ts

@@ -0,0 +1,10 @@
+import { ThreadType } from "../models/index.js";
+export type SendCardOptions = {
+    userId: string;
+    phoneNumber?: string;
+    ttl?: number;
+};
+export type SendCardResponse = {
+    msgId: number;
+};
+export declare const sendCardFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (options: SendCardOptions, threadId: string, type?: ThreadType) => Promise<SendCardResponse>;

package/dist/apis/sendCard.js

@@ -0,0 +1,59 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { ThreadType } from "../models/index.js";
+import { apiFactory } from "../utils.js";
+export const sendCardFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = {
+        [ThreadType.User]: utils.makeURL(`${api.zpwServiceMap.file[0]}/api/message/forward`),
+        [ThreadType.Group]: utils.makeURL(`${api.zpwServiceMap.file[0]}/api/group/forward`),
+    };
+    /**
+     * Send a card to a User - Group
+     *
+     * @param userId Unique ID for Card
+     * @param phoneNumber Optional phone number for sending card to a User
+     * @param ttl Time to live in milliseconds (default: 0)
+     * @param threadId ID of the conversation
+     * @param type Message type (User or GroupMessage)
+     *
+     * @throws {ZaloApiError}
+     *
+     */
+    return async function sendCard(options, threadId, type = ThreadType.User) {
+        var _a;
+        const data = await api.getQR(options.userId);
+        const QRCodeURL = data[options.userId];
+        const clientId = Date.now().toString();
+        const params = {
+            ttl: (_a = options.ttl) !== null && _a !== void 0 ? _a : 0,
+            msgType: 6,
+            clientId: clientId,
+            msgInfo: {
+                contactUid: options.userId,
+                qrCodeUrl: QRCodeURL,
+            },
+        };
+        if (options.phoneNumber) {
+            params.msgInfo.phone = options.phoneNumber;
+        }
+        if (type == ThreadType.Group) {
+            params.visibility = 0;
+            params.grid = threadId;
+        }
+        else {
+            params.toId = threadId;
+            params.imei = ctx.imei;
+        }
+        const msgInfoStringified = JSON.stringify(params.msgInfo);
+        params.msgInfo = msgInfoStringified;
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL[type], {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/sendDeliveredEvent.d.ts

@@ -0,0 +1,16 @@
+import { ThreadType } from "../models/index.js";
+export type SendDeliveredEventResponse = "" | {
+    status: number;
+};
+export type SendDeliveredEventMessageParams = {
+    msgId: string;
+    cliMsgId: string;
+    uidFrom: string;
+    idTo: string;
+    msgType: string;
+    st: number;
+    at: number;
+    cmd: number;
+    ts: string | number;
+};
+export declare const sendDeliveredEventFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (isSeen: boolean, messages: SendDeliveredEventMessageParams | SendDeliveredEventMessageParams[], type?: ThreadType) => Promise<SendDeliveredEventResponse>;

package/dist/apis/sendDeliveredEvent.js

@@ -0,0 +1,55 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { MAX_MESSAGES_PER_SEND } from "../context.js";
+import { ThreadType } from "../models/index.js";
+import { apiFactory } from "../utils.js";
+export const sendDeliveredEventFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = {
+        [ThreadType.User]: utils.makeURL(`${api.zpwServiceMap.chat[0]}/api/message/deliveredv2`),
+        [ThreadType.Group]: utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/deliveredv2`),
+    };
+    /**
+     * Send message delivered event
+     *
+     * @param isSeen Whether the message is seen or not
+     * @param messages List of messages to send delivered event
+     * @param type Messages type (User or Group), defaults to User
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function sendDeliveredEvent(isSeen, messages, type = ThreadType.User) {
+        if (!messages)
+            throw new ZaloApiError("messages are missing or not in a valid array format.");
+        if (!Array.isArray(messages))
+            messages = [messages];
+        if (messages.length === 0 || messages.length > MAX_MESSAGES_PER_SEND)
+            throw new ZaloApiError("messages must contain between 1 and 50 messages.");
+        // 27/02/2025
+        // This can send messages from multiple groups, but to prevent potential issues,
+        // we will restrict it to sending messages only within the same group.
+        const idTo = messages[0].idTo;
+        if (type === ThreadType.Group && !messages.every((msg) => msg.idTo === idTo))
+            throw new ZaloApiError("All messages must have the same idTo for Group thread");
+        const msgInfos = Object.assign({ seen: isSeen ? 1 : 0, data: messages.map((msg) => ({
+                cmi: msg.cliMsgId,
+                gmi: msg.msgId,
+                si: msg.uidFrom,
+                di: msg.idTo === ctx.uid ? "0" : msg.idTo,
+                mt: msg.msgType,
+                st: msg.st || 0 === msg.st ? 0 : -1,
+                at: msg.at || 0 === msg.at ? 0 : -1,
+                cmd: msg.cmd || 0 === msg.cmd ? 0 : -1,
+                ts: parseInt(`${msg.ts}`) || 0 === parseInt(`${msg.ts}`) ? 0 : -1,
+            })) }, (type === ThreadType.User ? {} : { grid: idTo }));
+        const params = Object.assign({ msgInfos: JSON.stringify(msgInfos) }, (type === ThreadType.User ? {} : { imei: ctx.imei }));
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL[type], {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/sendFriendRequest.d.ts

@@ -0,0 +1,2 @@
+export type SendFriendRequestResponse = "";
+export declare const sendFriendRequestFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (msg: string, userId: string) => Promise<"">;

package/dist/apis/sendFriendRequest.js

@@ -0,0 +1,39 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const sendFriendRequestFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/sendreq`);
+    /**
+     * Send a friend request to a user.
+     *
+     * @param msg message sent with friend request
+     * @param userId User ID to send friend request to
+     *
+     * @note Zalo might throw an error with code 225 if the user is already friends with you,
+     *          215 if the user might have blocked you,
+     *          222 if user has already sent you a friend request, your request will be treated as acceptance instead.
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function sendFriendRequest(msg, userId) {
+        const params = {
+            toid: userId,
+            msg: msg,
+            reqsrc: 30,
+            imei: ctx.imei,
+            language: ctx.language,
+            srcParams: JSON.stringify({
+                uidTo: userId,
+            }),
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/sendLink.d.ts

@@ -0,0 +1,10 @@
+import { ThreadType } from "../models/index.js";
+export type SendLinkOptions = {
+    msg?: string;
+    link: string;
+    ttl?: number;
+};
+export type SendLinkResponse = {
+    msgId: string;
+};
+export declare const sendLinkFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (options: SendLinkOptions, threadId: string, type?: ThreadType) => Promise<SendLinkResponse>;

package/dist/apis/sendLink.js

@@ -0,0 +1,61 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { ThreadType } from "../models/index.js";
+import { apiFactory } from "../utils.js";
+export const sendLinkFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = {
+        [ThreadType.User]: utils.makeURL(`${api.zpwServiceMap.chat[0]}/api/message/link`, {
+            nretry: 0,
+        }),
+        [ThreadType.Group]: utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/sendlink`, {
+            nretry: 0,
+        }),
+    };
+    /**
+     * Send link
+     *
+     * @param options Link and ttl
+     * @param threadId Thread ID
+     * @param type Thread type
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function sendLink(options, threadId, type = ThreadType.User) {
+        var _a;
+        const res = await api.parseLink(options.link);
+        const params = {
+            msg: options.msg && options.msg.trim()
+                ? options.msg.includes(options.link)
+                    ? options.msg
+                    : options.msg + " " + options.link
+                : options.link,
+            href: res.data.href,
+            src: res.data.src,
+            title: res.data.title,
+            desc: res.data.desc,
+            thumb: res.data.thumb,
+            type: 2, // 0
+            media: JSON.stringify(res.data.media),
+            ttl: (_a = options.ttl) !== null && _a !== void 0 ? _a : 0,
+            clientId: Date.now(),
+        };
+        if (type == ThreadType.Group) {
+            params.grid = threadId;
+            params.imei = ctx.imei;
+            // params.mentionInfo = "[]"; @TODO: implement this
+        }
+        else {
+            params.toId = threadId;
+            params.mentionInfo = "";
+        }
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL[type], {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/sendMessage.d.ts

@@ -0,0 +1,99 @@
+import { ThreadType, type TMessage, type AttachmentSource } from "../models/index.js";
+export type SendMessageResult = {
+    msgId: number;
+};
+export type SendMessageResponse = {
+    message: SendMessageResult | null;
+    attachment: SendMessageResult[];
+};
+export type SendMessageQuote = {
+    content: TMessage["content"];
+    msgType: TMessage["msgType"];
+    propertyExt: TMessage["propertyExt"];
+    uidFrom: TMessage["uidFrom"];
+    msgId: TMessage["msgId"];
+    cliMsgId: TMessage["cliMsgId"];
+    ts: TMessage["ts"];
+    ttl: TMessage["ttl"];
+};
+export declare enum TextStyle {
+    Bold = "b",
+    Italic = "i",
+    Underline = "u",
+    StrikeThrough = "s",
+    Red = "c_db342e",
+    Orange = "c_f27806",
+    Yellow = "c_f7b503",
+    Green = "c_15a85f",
+    Small = "f_13",
+    Big = "f_18",
+    UnorderedList = "lst_1",
+    OrderedList = "lst_2",
+    Indent = "ind_$"
+}
+export type Style = {
+    start: number;
+    len: number;
+    st: Exclude<TextStyle, TextStyle.Indent>;
+} | {
+    start: number;
+    len: number;
+    st: TextStyle.Indent;
+    /**
+     * Number of spaces used for indentation.
+     */
+    indentSize?: number;
+};
+export declare enum Urgency {
+    Default = 0,
+    Important = 1,
+    Urgent = 2
+}
+export type Mention = {
+    /**
+     * mention position
+     */
+    pos: number;
+    /**
+     * id of the mentioned user
+     */
+    uid: string;
+    /**
+     * length of the mention
+     */
+    len: number;
+};
+export type MessageContent = {
+    /**
+     * Text content of the message
+     */
+    msg: string;
+    /**
+     * Text styles
+     */
+    styles?: Style[];
+    /**
+     * Urgency of the message
+     */
+    urgency?: Urgency;
+    /**
+     * Quoted message (optional)
+     */
+    quote?: SendMessageQuote;
+    /**
+     * Mentions in the message (optional)
+     */
+    mentions?: Mention[];
+    /**
+     * Attachments in the message (optional)
+     */
+    attachments?: AttachmentSource | AttachmentSource[];
+    /**
+     * Time to live in milliseconds
+     */
+    ttl?: number;
+};
+export declare const sendMessageFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (message: MessageContent | string, threadId: string, type?: ThreadType) => Promise<{
+    message: SendMessageResult | null;
+    attachment: SendMessageResult[];
+}>;