zalo-toolkit 1.0.0

package/dist/apis/undo.js

@@ -0,0 +1,42 @@
+import { ZaloApiError } from '../Errors/ZaloApiError.js';
+import { ThreadType } from '../models/index.js';
+import { apiFactory } from '../utils.js';
+export const undoFactory = apiFactory()((api, ctx, utils) => {
+    const URLType = {
+        [ThreadType.User]: utils.makeURL(`${api.zpwServiceMap.chat[0]}/api/message/undo`),
+        [ThreadType.Group]: utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/undomsg`),
+    };
+    /**
+     * Undo a message
+     *
+     * @param payload Undo payload containing message ID and client message ID
+     * @param threadId group or user id
+     * @param type Message type (User or Group), default is User
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function undo(payload, threadId, type = ThreadType.User) {
+        const params = {
+            msgId: payload.msgId,
+            clientId: Date.now(),
+            cliMsgIdUndo: payload.cliMsgId,
+        };
+        if (type == ThreadType.Group) {
+            params['grid'] = threadId;
+            params['visibility'] = 0;
+            params['imei'] = ctx.imei;
+        }
+        else
+            params['toid'] = threadId;
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError('Failed to encrypt message');
+        const response = await utils.request(URLType[type], {
+            method: 'POST',
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/undoFriendRequest.d.ts

@@ -0,0 +1,2 @@
+export type UndoFriendRequestResponse = '';
+export declare const undoFriendRequestFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").ZaloAPI) => (friendId: string) => Promise<"">;

package/dist/apis/undoFriendRequest.js

@@ -0,0 +1,27 @@
+import { ZaloApiError } from '../Errors/ZaloApiError.js';
+import { apiFactory } from '../utils.js';
+export const undoFriendRequestFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/undo`);
+    /**
+     * Undo send a friend request to a user.
+     *
+     * @param options
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function undoFriendRequest(friendId) {
+        const params = {
+            fid: friendId,
+        };
+        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/updateActiveStatus.d.ts

@@ -0,0 +1,4 @@
+export type UpdateActiveStatusResponse = {
+    status: boolean;
+};
+export declare const updateActiveStatusFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").ZaloAPI) => (active: boolean) => Promise<UpdateActiveStatusResponse>;

package/dist/apis/updateActiveStatus.js

@@ -0,0 +1,27 @@
+import { ZaloApiError } from '../Errors/ZaloApiError.js';
+import { apiFactory } from '../utils.js';
+export const updateActiveStatusFactory = apiFactory()((api, ctx, utils) => {
+    const pingURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/profile/ping`);
+    const deactiveURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/profile/deactive`);
+    /**
+     * Update active status?
+     *
+     * @param active
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function updateActiveStatus(active) {
+        const params = {
+            status: active ? 1 : 0,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError('Failed to encrypt params');
+        const targetURL = active ? pingURL : deactiveURL;
+        const response = await utils.request(utils.makeURL(targetURL, { params: encryptedParams }), {
+            method: 'GET',
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/updateAutoDeleteChat.d.ts

@@ -0,0 +1,9 @@
+import { ThreadType } from '../models/index.js';
+export declare enum ChatTTL {
+    NO_DELETE = 0,
+    ONE_DAY = 86400000,
+    SEVEN_DAYS = 604800000,
+    FOURTEEN_DAYS = 1209600000
+}
+export type UpdateAutoDeleteChatResponse = '';
+export declare const updateAutoDeleteChatFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").ZaloAPI) => (ttl: ChatTTL, threadId: string, type?: ThreadType) => Promise<"">;

package/dist/apis/updateAutoDeleteChat.js

@@ -0,0 +1,40 @@
+import { ZaloApiError } from '../Errors/ZaloApiError.js';
+import { ThreadType } from '../models/index.js';
+import { apiFactory } from '../utils.js';
+export var ChatTTL;
+(function (ChatTTL) {
+    ChatTTL[ChatTTL["NO_DELETE"] = 0] = "NO_DELETE";
+    ChatTTL[ChatTTL["ONE_DAY"] = 86400000] = "ONE_DAY";
+    ChatTTL[ChatTTL["SEVEN_DAYS"] = 604800000] = "SEVEN_DAYS";
+    ChatTTL[ChatTTL["FOURTEEN_DAYS"] = 1209600000] = "FOURTEEN_DAYS";
+})(ChatTTL || (ChatTTL = {}));
+export const updateAutoDeleteChatFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.conversation[0]}/api/conv/autodelete/updateConvers`);
+    /**
+     * Auto delete chat
+     *
+     * @param ttl The time to live of the chat
+     * @param threadId The thread ID to auto delete chat
+     * @param type Type of thread (User or Group)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function updateAutoDeleteChat(ttl, threadId, type = ThreadType.User) {
+        const params = {
+            threadId: threadId,
+            isGroup: type === ThreadType.Group ? 1 : 0,
+            ttl: ttl,
+            clientLang: ctx.language,
+        };
+        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/updateAutoReply.d.ts

@@ -0,0 +1,15 @@
+import type { AutoReplyItem, AutoReplyScope } from '../models/index.js';
+export type UpdateAutoReplyPayload = {
+    id: number;
+    content: string;
+    isEnable: boolean;
+    startTime: number;
+    endTime: number;
+    scope: AutoReplyScope;
+    uids?: string | string[];
+};
+export type UpdateAutoReplyResponse = {
+    item: AutoReplyItem;
+    version: number;
+};
+export declare const updateAutoReplyFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").ZaloAPI) => (payload: UpdateAutoReplyPayload) => Promise<UpdateAutoReplyResponse>;

package/dist/apis/updateAutoReply.js

@@ -0,0 +1,38 @@
+import { ZaloApiError } from '../Errors/ZaloApiError.js';
+import { apiFactory } from '../utils.js';
+export const updateAutoReplyFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.auto_reply[0]}/api/autoreply/update`);
+    /**
+     * Update auto reply
+     *
+     * @param payload payload
+     *
+     * @note this API used for zBusiness
+     * @throws {ZaloApiError}
+     */
+    return async function updateAutoReply(payload) {
+        const uids = Array.isArray(payload.uids) ? payload.uids : [payload.uids];
+        const resultUids = payload.scope === 2 || payload.scope === 3 ? uids : [];
+        const params = {
+            cliLang: ctx.language,
+            id: payload.id,
+            enable: payload.isEnable,
+            content: payload.content,
+            startTime: payload.startTime,
+            endTime: payload.endTime,
+            recurrence: ['RRULE:FREQ=DAILY;'],
+            scope: payload.scope,
+            uids: resultUids,
+        };
+        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/updateCatalog.d.ts

@@ -0,0 +1,11 @@
+import type { CatalogItem } from '../models/index.js';
+export type UpdateCatalogPayload = {
+    catalogId: string;
+    catalogName: string;
+};
+export type UpdateCatalogResponse = {
+    item: CatalogItem;
+    version_ls_catalog: number;
+    version_catalog: number;
+};
+export declare const updateCatalogFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").ZaloAPI) => (payload: UpdateCatalogPayload) => Promise<UpdateCatalogResponse>;

package/dist/apis/updateCatalog.js

@@ -0,0 +1,30 @@
+import { ZaloApiError } from '../Errors/ZaloApiError.js';
+import { apiFactory } from '../utils.js';
+export const updateCatalogFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.catalog[0]}/api/prodcatalog/catalog/update`);
+    /**
+     * Update catalog?
+     *
+     * @param payload payload
+     *
+     * @note this API is used for zBusiness
+     * @throws {ZaloApiError}
+     */
+    return async function updateCatalog(payload) {
+        const params = {
+            catalog_id: payload.catalogId,
+            catalog_name: payload.catalogName,
+            catalog_photo: '', // "" is defaut don't upload photo
+        };
+        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/updateGroupSettings.d.ts

@@ -0,0 +1,40 @@
+export type UpdateGroupSettingsOptions = {
+    /**
+     * Disallow group members to change the group name and avatar
+     */
+    blockName?: boolean;
+    /**
+     * Highlight messages from owner/admins
+     */
+    signAdminMsg?: boolean;
+    /**
+     * Don't pin messages, notes, and polls to the top of a conversation
+     */
+    setTopicOnly?: boolean;
+    /**
+     * Allow new members to read most recent messages
+     */
+    enableMsgHistory?: boolean;
+    /**
+     * Membership approval
+     */
+    joinAppr?: boolean;
+    /**
+     * Disallow group members to create notes & reminders
+     */
+    lockCreatePost?: boolean;
+    /**
+     * Disallow group members to create polls
+     */
+    lockCreatePoll?: boolean;
+    /**
+     * Disallow group members to send messages
+     */
+    lockSendMsg?: boolean;
+    /**
+     * Disallow group members to view full member list (community only)
+     */
+    lockViewMember?: boolean;
+};
+export type UpdateGroupSettingsResponse = '';
+export declare const updateGroupSettingsFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").ZaloAPI) => (options: UpdateGroupSettingsOptions, groupId: string) => Promise<"">;

package/dist/apis/updateGroupSettings.js

@@ -0,0 +1,43 @@
+import { ZaloApiError } from '../Errors/ZaloApiError.js';
+import { apiFactory } from '../utils.js';
+export const updateGroupSettingsFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/setting/update`);
+    /**
+     * Update group settings
+     *
+     * @param options Options
+     * @param groupId Group ID
+     *
+     * @note Zalo might throw an error with code 166 if you don't have enough permissions to change the settings.
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function updateGroupSettings(options, groupId) {
+        const params = {
+            blockName: options.blockName ? 1 : 0,
+            signAdminMsg: options.signAdminMsg ? 1 : 0,
+            // addMemberOnly: 0, // very tricky, any idea?
+            setTopicOnly: options.setTopicOnly ? 1 : 0,
+            enableMsgHistory: options.enableMsgHistory ? 1 : 0,
+            joinAppr: options.joinAppr ? 1 : 0,
+            lockCreatePost: options.lockCreatePost ? 1 : 0,
+            lockCreatePoll: options.lockCreatePoll ? 1 : 0,
+            lockSendMsg: options.lockSendMsg ? 1 : 0,
+            lockViewMember: options.lockViewMember ? 1 : 0,
+            // default values for not implemented options
+            bannFeature: 0,
+            dirtyMedia: 0,
+            banDuration: 0,
+            blocked_members: [],
+            grid: groupId,
+            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/updateHiddenConversPin.d.ts

@@ -0,0 +1,2 @@
+export type UpdateHiddenConversPinResponse = '';
+export declare const updateHiddenConversPinFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").ZaloAPI) => (pin: string) => Promise<"">;

package/dist/apis/updateHiddenConversPin.js

@@ -0,0 +1,30 @@
+import { ZaloApiError } from '../Errors/ZaloApiError.js';
+import { apiFactory, encryptPin } from '../utils.js';
+export const updateHiddenConversPinFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.conversation[0]}/api/hiddenconvers/update-pin`);
+    const pinRegex = /^\d{4}$/;
+    /**
+     * Update hidden conversation pin
+     *
+     * @param pin The pin to update (must be a 4-digit number between 0000-9999)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function updateHiddenConversPin(pin) {
+        if (!pinRegex.test(pin)) {
+            throw new ZaloApiError('Pin must be a 4-digit number between 0000-9999');
+        }
+        const encryptedPin = encryptPin(pin);
+        const params = {
+            new_pin: encryptedPin,
+            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/updateLabels.d.ts

@@ -0,0 +1,15 @@
+import type { LabelData } from '../models/index.js';
+export type UpdateLabelsPayload = {
+    labelData: LabelData[];
+    version: number;
+};
+export type UpdateLabelsResponse = {
+    labelData: LabelData[];
+    version: number;
+    lastUpdateTime: number;
+};
+export declare const updateLabelsFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").ZaloAPI) => (payload: UpdateLabelsPayload) => Promise<{
+    labelData: any;
+    version: number;
+    lastUpdateTime: number;
+}>;

package/dist/apis/updateLabels.js

@@ -0,0 +1,34 @@
+import { ZaloApiError } from '../Errors/ZaloApiError.js';
+import { apiFactory } from '../utils.js';
+export const updateLabelsFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.label[0]}/api/convlabel/update`);
+    /**
+     * Update labels
+     *
+     * @param label label data
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function updateLabels(payload) {
+        const params = {
+            labelData: JSON.stringify(payload.labelData),
+            version: payload.version,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError('Failed to encrypt message');
+        const response = await utils.request(serviceURL, {
+            method: 'POST',
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        const unFormatted = (await utils.resolve(response));
+        return {
+            labelData: JSON.parse(unFormatted.labelData),
+            version: unFormatted.version,
+            lastUpdateTime: unFormatted.lastUpdateTime,
+        };
+    };
+});

package/dist/apis/updateLang.d.ts

@@ -0,0 +1,6 @@
+export declare enum UpdateLangAvailableLanguages {
+    VI = "VI",
+    EN = "EN"
+}
+export type UpdateLangResponse = '';
+export declare const updateLangFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").ZaloAPI) => (language?: UpdateLangAvailableLanguages) => Promise<"">;

package/dist/apis/updateLang.js

@@ -0,0 +1,30 @@
+import { ZaloApiError } from '../Errors/ZaloApiError.js';
+import { apiFactory } from '../utils.js';
+export var UpdateLangAvailableLanguages;
+(function (UpdateLangAvailableLanguages) {
+    UpdateLangAvailableLanguages["VI"] = "VI";
+    UpdateLangAvailableLanguages["EN"] = "EN";
+})(UpdateLangAvailableLanguages || (UpdateLangAvailableLanguages = {}));
+export const updateLangFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/profile/updatelang`);
+    /**
+     * Update language?
+     *
+     * @param language language to update (VI, EN)
+     *
+     * @note Calling this API alone will not update the user's language.
+     * @throws {ZaloApiError}
+     */
+    return async function updateLang(language = UpdateLangAvailableLanguages.VI) {
+        const params = {
+            language: language,
+        };
+        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/updateProductCatalog.d.ts

@@ -0,0 +1,25 @@
+import type { ProductCatalogItem } from '../models/index.js';
+export type UpdateProductCatalogPayload = {
+    catalogId: string;
+    productId: string;
+    productName: string;
+    price: string;
+    description: string;
+    createTime: number;
+    /**
+     * Upto 5 media files are allowed, will be ignored if product_photos is provided
+     */
+    files?: string[];
+    /**
+     * List of product photo URLs, upto 5
+     *
+     * You can manually get the URL using `uploadProductPhoto` api
+     */
+    product_photos?: string[];
+};
+export type UpdateProductCatalogResponse = {
+    item: ProductCatalogItem;
+    version_ls_catalog: number;
+    version_catalog: number;
+};
+export declare const updateProductCatalogFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").ZaloAPI) => (payload: UpdateProductCatalogPayload) => Promise<UpdateProductCatalogResponse>;

package/dist/apis/updateProductCatalog.js

@@ -0,0 +1,51 @@
+import { ZaloApiError } from '../Errors/ZaloApiError.js';
+import { apiFactory } from '../utils.js';
+export const updateProductCatalogFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.catalog[0]}/api/prodcatalog/product/update`);
+    /**
+     * Update product catalog?
+     *
+     * @param payload payload
+     *
+     * @note this API is used for zBusiness - Maximum 5 media files are supported
+     * @throws {ZaloApiError}
+     */
+    return async function updateProductCatalog(payload) {
+        const productPhoto = payload.product_photos || [];
+        if (payload.files && payload.files.length == 0) {
+            if (payload.files.length > 5) {
+                throw new ZaloApiError('Maximum 5 media files are allowed');
+            }
+            for (const mediaFile of payload.files) {
+                const uploadMedia = await api.uploadProductPhoto({
+                    url: mediaFile,
+                });
+                const url = uploadMedia.normalUrl || uploadMedia.hdUrl;
+                productPhoto.push(url);
+            }
+        }
+        if (productPhoto.length > 5) {
+            throw new ZaloApiError('Maximum 5 media files are allowed');
+        }
+        const params = {
+            product_id: payload.productId,
+            product_name: payload.productName,
+            price: payload.price,
+            description: payload.description,
+            product_photos: productPhoto,
+            catalog_id: payload.catalogId,
+            currency_unit: '₫',
+            create_time: payload.createTime,
+        };
+        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/updateProfile.d.ts

@@ -0,0 +1,20 @@
+import type { BusinessCategory, Gender } from '../models/index.js';
+export type UpdateProfilePayload = {
+    profile: {
+        name: string;
+        /**
+         * Date of birth in the format YYYY-MM-DD
+         */
+        dob: `${string}-${string}-${string}`;
+        gender: Gender;
+    };
+    biz?: Partial<{
+        cate: BusinessCategory;
+        description: string;
+        address: string;
+        website: string;
+        email: string;
+    }>;
+};
+export type UpdateProfileResponse = '';
+export declare const updateProfileFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").ZaloAPI) => (payload: UpdateProfilePayload) => Promise<"">;

package/dist/apis/updateProfile.js

@@ -0,0 +1,43 @@
+import { ZaloApiError } from '../Errors/ZaloApiError.js';
+import { apiFactory } from '../utils.js';
+export const updateProfileFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/profile/update`);
+    /**
+     * Change account setting information
+     *
+     * @param payload payload
+     *
+     * @note If your account is a Business Account, include the biz.cate field; otherwise the category will be removed.
+     * You may leave the other biz fields empty if you don’t want to change them.
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function updateProfile(payload) {
+        var _a, _b, _c, _d, _e;
+        const params = {
+            profile: JSON.stringify({
+                name: payload.profile.name,
+                dob: payload.profile.dob,
+                gender: payload.profile.gender,
+            }),
+            biz: JSON.stringify({
+                desc: (_a = payload.biz) === null || _a === void 0 ? void 0 : _a.description,
+                cate: (_b = payload.biz) === null || _b === void 0 ? void 0 : _b.cate,
+                addr: (_c = payload.biz) === null || _c === void 0 ? void 0 : _c.address,
+                website: (_d = payload.biz) === null || _d === void 0 ? void 0 : _d.website,
+                email: (_e = payload.biz) === null || _e === void 0 ? void 0 : _e.email,
+            }),
+            language: ctx.language,
+        };
+        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/updateQuickMessage.d.ts

@@ -0,0 +1,11 @@
+import type { QuickMessage } from '../models/index.js';
+export type UpdateQuickMessagePayload = {
+    keyword: string;
+    title: string;
+    media?: string;
+};
+export type UpdateQuickMessageResponse = {
+    item: QuickMessage;
+    version: number;
+};
+export declare const updateQuickMessageFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").ZaloAPI) => (updatePayload: UpdateQuickMessagePayload, itemId: number) => Promise<UpdateQuickMessageResponse>;