@phuquy2203/n8n-nodes-zl-sumo 2.0.15

package/dist/src/apis/getListBoard.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getListBoardFactory = void 0;
+const ZaloApiError_js_1 = require("../Errors/ZaloApiError.js");
+const index_js_1 = require("../models/index.js");
+const utils_js_1 = require("../utils.js");
+exports.getListBoardFactory = (0, utils_js_1.apiFactory)()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/list`);
+    /**
+     * Get list board items in a group
+     *
+     * @param options - The options for the request
+     * @param groupId - The ID of the group
+     *
+     * @throws {ZaloApiError}
+     *
+     */
+    return async function getListBoard(options, groupId) {
+        var _a, _b;
+        const requestParams = {
+            group_id: groupId,
+            board_type: 0,
+            page: (_a = options.page) !== null && _a !== void 0 ? _a : 1,
+            count: (_b = options.count) !== null && _b !== void 0 ? _b : 20,
+            last_id: 0,
+            last_type: 0,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(requestParams));
+        if (!encryptedParams)
+            throw new ZaloApiError_js_1.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response, (result) => {
+            const data = result.data;
+            data.items.forEach((item) => {
+                if (item.boardType != index_js_1.BoardType.Poll) {
+                    const detailData = item.data;
+                    if (typeof detailData.params === "string") {
+                        detailData.params = JSON.parse(detailData.params);
+                    }
+                }
+            });
+            return data;
+        });
+    };
+});

package/dist/src/apis/getListReminder.d.ts

@@ -0,0 +1,28 @@
+import type { ReminderGroup, ReminderUser } from "../models/index.js";
+import { ThreadType } from "../models/index.js";
+export type ListReminderOptions = {
+    /**
+     * Page number (default: 1)
+     */
+    page?: number;
+    /**
+     * Number of items to retrieve (default: 20)
+     */
+    count?: number;
+};
+export type ReminderListUser = ReminderUser;
+export type ReminderListGroup = ReminderGroup & {
+    groupId: string;
+    eventType: number;
+    responseMem: {
+        rejectMember: number;
+        myResp: number;
+        acceptMember: number;
+    };
+    repeatInfo: {
+        list_ts: unknown[];
+    };
+    repeatData: unknown[];
+};
+export type GetListReminderResponse = (ReminderListUser & ReminderListGroup)[];
+export declare const getListReminderFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (options: ListReminderOptions, threadId: string, type?: ThreadType) => Promise<GetListReminderResponse>;

package/dist/src/apis/getListReminder.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getListReminderFactory = void 0;
+const ZaloApiError_js_1 = require("../Errors/ZaloApiError.js");
+const index_js_1 = require("../models/index.js");
+const utils_js_1 = require("../utils.js");
+exports.getListReminderFactory = (0, utils_js_1.apiFactory)()((api, ctx, utils) => {
+    const serviceURL = {
+        [index_js_1.ThreadType.User]: utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/oneone/list`),
+        [index_js_1.ThreadType.Group]: utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/listReminder`),
+    };
+    /**
+     * Get list reminder
+     *
+     * @param options - The options for the request
+     * @param threadId - The ID of the thread
+     * @param type - The type of the thread (User or Group)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getListReminder(options, threadId, type = index_js_1.ThreadType.User) {
+        var _a, _b, _c, _d;
+        const requestParams = Object.assign({ objectData: JSON.stringify(type === index_js_1.ThreadType.User
+                ? {
+                    uid: threadId,
+                    board_type: 1,
+                    page: (_a = options.page) !== null && _a !== void 0 ? _a : 1,
+                    count: (_b = options.count) !== null && _b !== void 0 ? _b : 20,
+                    last_id: 0,
+                    last_type: 0,
+                }
+                : {
+                    group_id: threadId,
+                    board_type: 1,
+                    page: (_c = options.page) !== null && _c !== void 0 ? _c : 1,
+                    count: (_d = options.count) !== null && _d !== void 0 ? _d : 20,
+                    last_id: 0,
+                    last_type: 0,
+                }) }, (type === index_js_1.ThreadType.Group && { imei: ctx.imei }));
+        const encryptedParams = utils.encodeAES(JSON.stringify(requestParams));
+        if (!encryptedParams)
+            throw new ZaloApiError_js_1.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL[type], { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response, (result) => {
+            return JSON.parse(result.data);
+        });
+    };
+});

package/dist/src/apis/getMute.d.ts

@@ -0,0 +1,13 @@
+export type MuteEntriesInfo = {
+    id: string;
+    duration: number;
+    startTime: number;
+    systemTime: number;
+    currentTime: number;
+    muteMode: number;
+};
+export type GetMuteResponse = {
+    chatEntries: MuteEntriesInfo[];
+    groupChatEntries: MuteEntriesInfo[];
+};
+export declare const getMuteFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => () => Promise<GetMuteResponse>;

package/dist/src/apis/getMute.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMuteFactory = void 0;
+const ZaloApiError_js_1 = require("../Errors/ZaloApiError.js");
+const utils_js_1 = require("../utils.js");
+exports.getMuteFactory = (0, utils_js_1.apiFactory)()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/profile/getmute`);
+    /**
+     * Get mute
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getMute() {
+        const params = {
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError_js_1.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/src/apis/getOwnId.d.ts

@@ -0,0 +1 @@
+export declare const getOwnIdFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => () => string;

package/dist/src/apis/getOwnId.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOwnIdFactory = void 0;
+const utils_js_1 = require("../utils.js");
+exports.getOwnIdFactory = (0, utils_js_1.apiFactory)()((_, ctx) => {
+    return () => ctx.uid;
+});

package/dist/src/apis/getPendingGroupMembers.d.ts

@@ -0,0 +1,11 @@
+export type GetPendingGroupMembersUserInfo = {
+    uid: string;
+    dpn: string;
+    avatar: string;
+    user_submit: null;
+};
+export type GetPendingGroupMembersResponse = {
+    time: number;
+    users: GetPendingGroupMembersUserInfo[];
+};
+export declare const getPendingGroupMembersFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (groupId: string) => Promise<GetPendingGroupMembersResponse>;

package/dist/src/apis/getPendingGroupMembers.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPendingGroupMembersFactory = void 0;
+const ZaloApiError_js_1 = require("../Errors/ZaloApiError.js");
+const utils_js_1 = require("../utils.js");
+exports.getPendingGroupMembersFactory = (0, utils_js_1.apiFactory)()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/pending-mems/list`);
+    /**
+     * Get pending group members
+     *
+     * @param groupId - The id of the group to get the pending members
+     *
+     * @note Only the group leader and deputy group leader can view
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getPendingGroupMembers(groupId) {
+        const params = {
+            grid: groupId,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError_js_1.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/src/apis/getPinConversations.d.ts

@@ -0,0 +1,5 @@
+export type GetPinConversationsResponse = {
+    conversations: string[];
+    version: number;
+};
+export declare const getPinConversationsFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => () => Promise<GetPinConversationsResponse>;

package/dist/src/apis/getPinConversations.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPinConversationsFactory = void 0;
+const ZaloApiError_js_1 = require("../Errors/ZaloApiError.js");
+const utils_js_1 = require("../utils.js");
+exports.getPinConversationsFactory = (0, utils_js_1.apiFactory)()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.conversation[0]}/api/pinconvers/list`);
+    /**
+     * Get pin conversations
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getPinConversations() {
+        const params = {
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError_js_1.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/src/apis/getPollDetail.d.ts

@@ -0,0 +1,3 @@
+import type { PollDetail } from "../models/index.js";
+export type PollDetailResponse = PollDetail;
+export declare const getPollDetailFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (pollId: number) => Promise<PollDetail>;

package/dist/src/apis/getPollDetail.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPollDetailFactory = void 0;
+const ZaloApiError_js_1 = require("../Errors/ZaloApiError.js");
+const utils_js_1 = require("../utils.js");
+exports.getPollDetailFactory = (0, utils_js_1.apiFactory)()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/poll/detail`);
+    /**
+     * Get poll detail
+     *
+     * @param pollId Poll ID
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getPollDetail(pollId) {
+        if (!pollId)
+            throw new ZaloApiError_js_1.ZaloApiError("Missing poll id");
+        const params = {
+            poll_id: pollId,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError_js_1.ZaloApiError("Failed to encrypt message");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/src/apis/getProductCatalogList.d.ts

@@ -0,0 +1,20 @@
+import type { ProductCatalogItem } from "../models/index.js";
+export type GetProductCatalogListPayload = {
+    catalogId: string;
+    /**
+     * Number of items to retrieve (default: 100)
+     */
+    limit?: number;
+    versionCatalog?: number;
+    lastProductId?: string;
+    /**
+     * Page number (default: 0)
+     */
+    page?: number;
+};
+export type GetProductCatalogListResponse = {
+    items: ProductCatalogItem[];
+    version: number;
+    has_more: number;
+};
+export declare const getProductCatalogListFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (payload: GetProductCatalogListPayload) => Promise<GetProductCatalogListResponse>;

package/dist/src/apis/getProductCatalogList.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProductCatalogListFactory = void 0;
+const ZaloApiError_js_1 = require("../Errors/ZaloApiError.js");
+const utils_js_1 = require("../utils.js");
+exports.getProductCatalogListFactory = (0, utils_js_1.apiFactory)()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.catalog[0]}/api/prodcatalog/product/list`);
+    /**
+     * Get product catalog list?
+     *
+     * @param payload payload
+     *
+     * @note this API is used for zBusiness
+     * @throws {ZaloApiError}
+     */
+    return async function getProductCatalogList(payload) {
+        var _a, _b, _c, _d;
+        const params = {
+            catalog_id: payload.catalogId,
+            limit: (_a = payload.limit) !== null && _a !== void 0 ? _a : 100,
+            version_catalog: (_b = payload.versionCatalog) !== null && _b !== void 0 ? _b : 0,
+            last_product_id: (_c = payload.lastProductId) !== null && _c !== void 0 ? _c : -1,
+            page: (_d = payload.page) !== null && _d !== void 0 ? _d : 0,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError_js_1.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/src/apis/getQR.d.ts

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

package/dist/src/apis/getQR.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getQRFactory = void 0;
+const ZaloApiError_js_1 = require("../Errors/ZaloApiError.js");
+const utils_js_1 = require("../utils.js");
+exports.getQRFactory = (0, utils_js_1.apiFactory)()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/mget-qr`);
+    /**
+     * Get QR code for users
+     *
+     * @param userId User ID or list of user IDs
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getQR(userId) {
+        if (typeof userId == "string")
+            userId = [userId];
+        const params = {
+            fids: userId,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError_js_1.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/src/apis/getQuickMessageList.d.ts

@@ -0,0 +1,7 @@
+import type { QuickMessage } from "../models/index.js";
+export type GetQuickMessageListResponse = {
+    cursor: number;
+    version: number;
+    items: QuickMessage[];
+};
+export declare const getQuickMessageListFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => () => Promise<GetQuickMessageListResponse>;

package/dist/src/apis/getQuickMessageList.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getQuickMessageListFactory = void 0;
+const ZaloApiError_js_1 = require("../Errors/ZaloApiError.js");
+const utils_js_1 = require("../utils.js");
+exports.getQuickMessageListFactory = (0, utils_js_1.apiFactory)()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.quick_message[0]}/api/quickmessage/list`);
+    /**
+     * Get quick message list
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getQuickMessageList() {
+        const params = {
+            version: 0,
+            lang: 0,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError_js_1.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/src/apis/getRelatedFriendGroup.d.ts

@@ -0,0 +1,6 @@
+export type GetRelatedFriendGroupResponse = {
+    groupRelateds: {
+        [friendId: string]: string[];
+    };
+};
+export declare const getRelatedFriendGroupFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (friendId: string | string[]) => Promise<GetRelatedFriendGroupResponse>;

package/dist/src/apis/getRelatedFriendGroup.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRelatedFriendGroupFactory = void 0;
+const ZaloApiError_js_1 = require("../Errors/ZaloApiError.js");
+const utils_js_1 = require("../utils.js");
+exports.getRelatedFriendGroupFactory = (0, utils_js_1.apiFactory)()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/group/related`);
+    /**
+     * Get related friend group
+     *
+     * @param friendId friend ids
+     *
+     * @note this API is used for zBusiness
+     * @throws {ZaloApiError}
+     */
+    return async function getRelatedFriendGroup(friendId) {
+        const friendIds = Array.isArray(friendId) ? friendId : [friendId];
+        const params = {
+            friend_ids: JSON.stringify(friendIds),
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError_js_1.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/src/apis/getReminder.d.ts

@@ -0,0 +1,3 @@
+import type { ReminderGroup } from "../models/index.js";
+export type GetReminderResponse = ReminderGroup;
+export declare const getReminderFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (reminderId: string) => Promise<ReminderGroup>;

package/dist/src/apis/getReminder.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReminderFactory = void 0;
+const ZaloApiError_js_1 = require("../Errors/ZaloApiError.js");
+const utils_js_1 = require("../utils.js");
+exports.getReminderFactory = (0, utils_js_1.apiFactory)()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/topic/getReminder`);
+    /**
+     * Get reminder details from a group
+     *
+     * @param reminderId Reminder ID
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getReminder(reminderId) {
+        const params = {
+            eventId: reminderId,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError_js_1.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/src/apis/getReminderResponses.d.ts

@@ -0,0 +1,5 @@
+export type GetReminderResponsesResponse = {
+    rejectMember: string[];
+    acceptMember: string[];
+};
+export declare const getReminderResponsesFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (reminderId: string) => Promise<GetReminderResponsesResponse>;

package/dist/src/apis/getReminderResponses.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReminderResponsesFactory = void 0;
+const ZaloApiError_js_1 = require("../Errors/ZaloApiError.js");
+const utils_js_1 = require("../utils.js");
+exports.getReminderResponsesFactory = (0, utils_js_1.apiFactory)()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/topic/listResponseEvent`);
+    /**
+     * Get reminder responses
+     *
+     * @param reminderId reminder id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getReminderResponses(reminderId) {
+        const params = {
+            eventId: reminderId,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError_js_1.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/src/apis/getSentFriendRequest.d.ts

@@ -0,0 +1,18 @@
+import type { ZBusinessPackage } from "../models/ZBusiness.js";
+export type SentFriendRequestInfo = {
+    userId: string;
+    zaloName: string;
+    displayName: string;
+    avatar: string;
+    globalId: string;
+    bizPkg: ZBusinessPackage;
+    fReqInfo: {
+        message: string;
+        src: number;
+        time: number;
+    };
+};
+export type GetSentFriendRequestResponse = {
+    [userId: string]: SentFriendRequestInfo;
+};
+export declare const getSentFriendRequestFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => () => Promise<GetSentFriendRequestResponse>;

package/dist/src/apis/getSentFriendRequest.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSentFriendRequestFactory = void 0;
+const ZaloApiError_js_1 = require("../Errors/ZaloApiError.js");
+const utils_js_1 = require("../utils.js");
+exports.getSentFriendRequestFactory = (0, utils_js_1.apiFactory)()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/requested/list`);
+    /**
+     * Get friend requested
+     *
+     * @note Zalo might throw an error with code 112 if you have no friend requests.
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getSentFriendRequest() {
+        const params = {
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError_js_1.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/src/apis/getSettings.d.ts

@@ -0,0 +1,3 @@
+import type { UserSetting } from "../models/index.js";
+export type GetSettingsResponse = UserSetting;
+export declare const getSettingsFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => () => Promise<UserSetting>;

package/dist/src/apis/getSettings.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSettingsFactory = void 0;
+const ZaloApiError_js_1 = require("../Errors/ZaloApiError.js");
+const utils_js_1 = require("../utils.js");
+exports.getSettingsFactory = (0, utils_js_1.apiFactory)()((_api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`https://wpa.chat.zalo.me/api/setting/me`);
+    /**
+     * Get my account settings
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getSettings() {
+        const params = {};
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError_js_1.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/src/apis/getStickers.d.ts

@@ -0,0 +1 @@
+export declare const getStickersFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (keyword: string) => Promise<number[]>;