@ohos-ports/zca-js 2.2.0-beta.1

package/dist/apis/unblockUser.js

@@ -0,0 +1,28 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const unblockUserFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/unblock`);
+    /**
+     * Unblock a User
+     *
+     * @param userId The ID of the User to unblock
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function unblockUser(userId) {
+        const params = {
+            fid: userId,
+            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/undo.d.ts

@@ -0,0 +1,9 @@
+import { ThreadType } from "../models/index.js";
+export type UndoPayload = {
+    msgId: string | number;
+    cliMsgId: string | number;
+};
+export type UndoResponse = {
+    status: number;
+};
+export declare const undoFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (payload: UndoPayload, threadId: string, type?: ThreadType) => Promise<UndoResponse>;

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").API) => (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").API) => (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/updateArchivedChatList.d.ts

@@ -0,0 +1,10 @@
+import type { ThreadType } from "../models/Enum.js";
+export type UpdateArchivedChatListTarget = {
+    id: string;
+    type: ThreadType;
+};
+export type UpdateArchivedChatListResponse = {
+    needResync: boolean;
+    version: number;
+};
+export declare const updateArchivedChatListFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (isArchived: boolean, conversations: UpdateArchivedChatListTarget | UpdateArchivedChatListTarget[]) => Promise<UpdateArchivedChatListResponse>;

package/dist/apis/updateArchivedChatList.js

@@ -0,0 +1,34 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const updateArchivedChatListFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.label[0]}/api/archivedchat/update`);
+    /**
+     * Archive conversations
+     *
+     * @param isArchived - true to archive, false to unarchive
+     * @param conversations - List of conversations to archive/unarchive
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function updateArchivedChatList(isArchived, conversations) {
+        if (!Array.isArray(conversations)) {
+            conversations = [conversations];
+        }
+        const params = {
+            actionType: isArchived ? 0 : 1,
+            ids: conversations,
+            imei: ctx.imei,
+            version: Date.now(),
+        };
+        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/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").API) => (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").API) => (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/updateBankAccount.d.ts

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

package/dist/apis/updateBankAccount.js

@@ -0,0 +1,31 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory, normalizeHolderName } from "../utils.js";
+export const updateBankAccountFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.zimsg[0]}/api/transfer/update`);
+    /**
+     * Update bank account
+     *
+     * @param payload The payload containing the bank account information to update
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function updateBankAccount(payload) {
+        const params = {
+            account_id: payload.accountId,
+            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/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").API) => (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").API) => (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").API) => (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").API) => (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").API) => (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 { AttachmentSource, 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?: AttachmentSource[];
+    /**
+     * 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").API) => (payload: UpdateProductCatalogPayload) => Promise<UpdateProductCatalogResponse>;