@softtynet/zca-js 2.2.9 → 2.3.1

package/dist/apis/board/getPollDetail.js

@@ -0,0 +1,30 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const getPollDetailFactory = 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("Missing poll id");
+        const params = {
+            poll_id: pollId,
+            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,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/board/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/apis/board/getReminder.js

@@ -0,0 +1,25 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const getReminderFactory = 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("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/board/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/apis/board/getReminderResponses.js

@@ -0,0 +1,24 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const getReminderResponsesFactory = 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("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/board/lockPoll.d.ts

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

package/dist/apis/board/lockPoll.js

@@ -0,0 +1,28 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const lockPollFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/poll/end`);
+    /**
+     * Lock a poll, preventing further votes.
+     *
+     * @param pollId Poll id to lock
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function lockPoll(pollId) {
+        const params = {
+            poll_id: pollId,
+            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/board/removeReminder.d.ts

@@ -0,0 +1,3 @@
+import { ThreadType } from "../../models/index.js";
+export type RemoveReminderResponse = "" | number;
+export declare const removeReminderFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (reminderId: string, threadId: string, type?: ThreadType) => Promise<RemoveReminderResponse>;

package/dist/apis/board/removeReminder.js

@@ -0,0 +1,40 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { ThreadType } from "../../models/index.js";
+import { apiFactory } from "../../utils.js";
+export const removeReminderFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = {
+        [ThreadType.User]: utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/oneone/remove`),
+        [ThreadType.Group]: utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/topic/remove`),
+    };
+    /**
+     * Remove a reminder in a (user/group)
+     *
+     * @param reminderId Reminder ID to remove reminder from
+     * @param threadId (User/Group) ID to remove reminder from
+     * @param type Thread type (User or Group)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function removeReminder(reminderId, threadId, type = ThreadType.User) {
+        const params = type === ThreadType.User
+            ? {
+                uid: threadId,
+                reminderId: reminderId,
+            }
+            : {
+                grid: threadId,
+                topicId: reminderId,
+                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/board/sharePoll.d.ts

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

package/dist/apis/board/sharePoll.js

@@ -0,0 +1,28 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const sharePollFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/poll/share`);
+    /**
+     * Share a poll
+     *
+     * @param pollId poll id to share
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function sharePoll(pollId) {
+        const params = {
+            poll_id: pollId,
+            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/board/votePoll.d.ts

@@ -0,0 +1,5 @@
+import type { PollOptions } from "../../models/index.js";
+export type VotePollResponse = {
+    options: PollOptions[];
+};
+export declare const votePollFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (pollId: number, optionId: number | number[]) => Promise<VotePollResponse>;

package/dist/apis/board/votePoll.js

@@ -0,0 +1,29 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const votePollFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/poll/vote`);
+    /**
+     * Vote on a poll
+     *
+     * @param pollId The ID of the poll to vote on
+     * @param optionId The ID(s) of the option to vote on
+     *
+     * @throws ZaloApiError
+     */
+    return async function votePoll(pollId, optionId) {
+        if (!Array.isArray(optionId))
+            optionId = [optionId];
+        const params = {
+            poll_id: pollId,
+            option_ids: optionId, // unvote = empty array
+            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/business/addQuickMessage.d.ts

@@ -0,0 +1,11 @@
+import type { QuickMessage, AttachmentSource } from "../../models/index.js";
+export type AddQuickMessagePayload = {
+    keyword: string;
+    title: string;
+    media?: AttachmentSource;
+};
+export type AddQuickMessageResponse = {
+    item: QuickMessage;
+    version: number;
+};
+export declare const addQuickMessageFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (addPayload: AddQuickMessagePayload) => Promise<AddQuickMessageResponse>;

package/dist/apis/business/addQuickMessage.js

@@ -0,0 +1,60 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const addQuickMessageFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.quick_message[0]}/api/quickmessage/create`);
+    /**
+     * Add quick message
+     *
+     * @param addPayload - The payload containing data to add the quick message
+     *
+     * @note Zalo might throw an error with code 821 if you have reached the limit of quick messages.
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function addQuickMessage(addPayload) {
+        const isType = !addPayload.media ? 0 : 1;
+        const params = {
+            keyword: addPayload.keyword,
+            message: {
+                title: addPayload.title,
+                params: "",
+            },
+            type: isType,
+            imei: ctx.imei,
+        };
+        if (isType === 1) {
+            if (!addPayload.media)
+                throw new ZaloApiError("Media is required");
+            const uploadMedia = await api.uploadProductPhoto({
+                file: addPayload.media,
+            });
+            const photoId = uploadMedia.photoId;
+            const thumbUrl = uploadMedia.thumbUrl;
+            const normalUrl = uploadMedia.normalUrl;
+            const hdUrl = uploadMedia.hdUrl;
+            params.media = {
+                items: [
+                    {
+                        type: 0,
+                        photoId: photoId,
+                        title: "",
+                        width: "",
+                        height: "",
+                        previewThumb: thumbUrl,
+                        rawUrl: normalUrl || hdUrl,
+                        thumbUrl: thumbUrl,
+                        normalUrl: normalUrl || hdUrl,
+                        hdUrl: hdUrl || normalUrl,
+                    },
+                ],
+            };
+        }
+        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/business/createAutoReply.d.ts

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

package/dist/apis/business/createAutoReply.js

@@ -0,0 +1,37 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const createAutoReplyFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.auto_reply[0]}/api/autoreply/create`);
+    /**
+     * Create auto reply
+     *
+     * @param payload payload
+     *
+     * @note this API used for zBusiness
+     * @throws {ZaloApiError}
+     */
+    return async function createAutoReply(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,
+            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/business/createBankAccount.d.ts

@@ -0,0 +1,8 @@
+import type { BankAccount, BinBankCard } from "../../models/index.js";
+export type CreateBankAccountPayload = {
+    binBank: BinBankCard;
+    numAccBank: string;
+    nameAccBank: string;
+};
+export type CreateBankAccountResponse = BankAccount;
+export declare const createBankAccountFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (payload: CreateBankAccountPayload) => Promise<BankAccount>;

package/dist/apis/business/createBankAccount.js

@@ -0,0 +1,32 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory, normalizeHolderName } from "../../utils.js";
+export const createBankAccountFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.zimsg[0]}/api/transfer/create`);
+    /**
+     * Create bank account
+     *
+     * @param payload The payload containing the bank account information
+     *
+     * @throws {ZaloApiError} When something went wrong, with `error.code`
+     * - `-263` - Bank account already exists
+     * - `810` - Internal Zalo error, might be invalid input
+     */
+    return async function createBankAccount(payload) {
+        const params = {
+            bin: payload.binBank,
+            bank_number: payload.numAccBank,
+            holder_name: normalizeHolderName(payload.nameAccBank),
+            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/business/createCatalog.d.ts

@@ -0,0 +1,7 @@
+import type { CatalogItem } from "../../models/index.js";
+export type CreateCatalogResponse = {
+    item: CatalogItem;
+    version_ls_catalog: number;
+    version_catalog: number;
+};
+export declare const createCatalogFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (catalogName: string) => Promise<CreateCatalogResponse>;

package/dist/apis/business/createCatalog.js

@@ -0,0 +1,29 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const createCatalogFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.catalog[0]}/api/prodcatalog/catalog/create`);
+    /**
+     * Create catalog?
+     *
+     * @param catalogName catalog name
+     *
+     * @note this API is used for zBusiness
+     * @throws {ZaloApiError}
+     */
+    return async function createCatalog(catalogName) {
+        const params = {
+            catalog_name: catalogName,
+            catalog_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/business/createProductCatalog.d.ts

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

package/dist/apis/business/createProductCatalog.js

@@ -0,0 +1,50 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const createProductCatalogFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.catalog[0]}/api/prodcatalog/product/create`);
+    /**
+     * Create product catalog?
+     *
+     * @param payload payload
+     *
+     * @note this API is used for zBussiness - Maximum 5 media files are supported
+     * @throws {ZaloApiError}
+     */
+    return async function createProductCatalog(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({
+                    file: 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_name: payload.productName,
+            price: payload.price,
+            description: payload.description,
+            product_photos: productPhoto,
+            catalog_id: payload.catalogId,
+            currency_unit: "₫", // $
+            create_time: Date.now(),
+        };
+        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/business/deleteAutoReply.d.ts

@@ -0,0 +1,5 @@
+export type DeleteAutoReplyResponse = {
+    item: number;
+    version: number;
+};
+export declare const deleteAutoReplyFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (id: number) => Promise<DeleteAutoReplyResponse>;

package/dist/apis/business/deleteAutoReply.js

@@ -0,0 +1,29 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const deleteAutoReplyFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.auto_reply[0]}/api/autoreply/delete`);
+    /**
+     * Delete auto reply
+     *
+     * @param id id of auto reply
+     *
+     * @note this API used for zBusiness
+     * @throws {ZaloApiError}
+     */
+    return async function deleteAutoReply(id) {
+        const params = {
+            cliLang: ctx.language,
+            id: id,
+        };
+        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/business/deleteBankAccount.d.ts

@@ -0,0 +1,11 @@
+import type { BankAccount } from "../../models/index.js";
+export type DeleteBankAccountPayload = {
+    accountId: number;
+    isDefault: boolean;
+};
+export type DeleteBankAccountResponse = {
+    hasMore: boolean;
+    total: number;
+    myBanks: BankAccount[];
+};
+export declare const deleteBankAccountFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (payload: DeleteBankAccountPayload) => Promise<DeleteBankAccountResponse>;

package/dist/apis/business/deleteBankAccount.js

@@ -0,0 +1,32 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const deleteBankAccountFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.zimsg[0]}/api/transfer/delete`);
+    /**
+     * Delete bank account
+     *
+     * @param payload The payload containing the bank account information to delete
+     *
+     * @throws {ZaloApiError} When something went wrong, with `error.code`
+     * - `114` - Invalid params
+     * - `-265` - Bank account not exists
+     * - `810` Internal Zalo error, maybe you're trying to delete a default bank account
+     */
+    return async function deleteBankAccount(payload) {
+        const params = {
+            account_id: payload.accountId,
+            is_default: payload.isDefault,
+            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/business/deleteCatalog.d.ts

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

package/dist/apis/business/deleteCatalog.js

@@ -0,0 +1,28 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const deleteCatalogFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.catalog[0]}/api/prodcatalog/catalog/delete`);
+    /**
+     * Delete catalog?
+     *
+     * @param catalogId catalog id
+     *
+     * @note this API is used for zBusiness
+     * @throws {ZaloApiError}
+     */
+    return async function deleteCatalog(catalogId) {
+        const params = {
+            catalog_id: catalogId,
+        };
+        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/business/deleteProductCatalog.d.ts

@@ -0,0 +1,10 @@
+export type DeleteProductCatalogPayload = {
+    productIds: string | string[];
+    catalogId: string;
+};
+export type DeleteProductCatalogResponse = {
+    item: number[];
+    version_ls_catalog: number;
+    version_catalog: number;
+};
+export declare const deleteProductCatalogFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (payload: DeleteProductCatalogPayload) => Promise<DeleteProductCatalogResponse>;