lansenger-sdk-ts 1.0.0

package/dist/client.js

@@ -0,0 +1,712 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LansengerClient = void 0;
+const config_1 = require("./config");
+const auth_1 = require("./auth");
+const persistence_1 = require("./persistence");
+const http_1 = require("./http");
+const urlHelpers_1 = require("./urlHelpers");
+const constants_1 = require("./constants");
+const exceptions_1 = require("./exceptions");
+const models_1 = require("./models");
+const contacts_1 = require("./contacts");
+const departments_1 = require("./departments");
+const groups_1 = require("./groups");
+const oauth_1 = require("./oauth");
+const users_1 = require("./users");
+const streaming_1 = require("./streaming");
+const calendars_1 = require("./calendars");
+const todos_1 = require("./todos");
+const chats_1 = require("./chats");
+const accountMessages_1 = require("./accountMessages");
+const userMessages_1 = require("./userMessages");
+const groupMessages_1 = require("./groupMessages");
+const reminders_1 = require("./reminders");
+const media_1 = require("./media");
+const callbacks_1 = require("./callbacks");
+function _parseSendResponse(data, msgType = "", operation = "") {
+    const errCode = data.errCode ?? -1;
+    if (errCode !== 0) {
+        const msg = data.errMsg || "Unknown error";
+        return new models_1.SendMessageResult({ success: false, error: `API error (errCode=${errCode}): ${msg}`, msg_type: msgType, operation, retryable: true });
+    }
+    const d = data.data || {};
+    return new models_1.SendMessageResult({ success: true, message_id: d.msgId, msg_type: msgType, operation, raw_response: data });
+}
+class LansengerClient {
+    constructor(appId, appSecret, apiGatewayUrl = "https://open.e.lanxin.cn/open/apigw", passportUrl = "", httpTimeout = 30, storePath, encodingKey = "", callbackToken = "") {
+        this._fetchFn = undefined;
+        this._tokenManager = null;
+        this._store = null;
+        this._config = new config_1.LansengerConfig(appId, appSecret, apiGatewayUrl, passportUrl, httpTimeout, encodingKey, callbackToken);
+        if (storePath) {
+            this._store = new persistence_1.CredentialStore(storePath);
+        }
+    }
+    static fromEnv(storePath) {
+        const config = config_1.LansengerConfig.fromEnv();
+        return new LansengerClient(config.app_id, config.app_secret, config.api_gateway_url, config.passport_url, config.http_timeout, storePath, config.encoding_key, config.callback_token);
+    }
+    static fromConfig(config, storePath) {
+        return new LansengerClient(config.app_id, config.app_secret, config.api_gateway_url, config.passport_url, config.http_timeout, storePath, config.encoding_key, config.callback_token);
+    }
+    static fromStore(profile = "default", filePath) {
+        const store = new persistence_1.CredentialStore(filePath, profile);
+        const creds = store.loadCredentials();
+        if (!creds.app_id || !creds.app_secret)
+            throw new exceptions_1.LansengerConfigError("No credentials found in store profile");
+        return new LansengerClient(creds.app_id, creds.app_secret, creds.api_gateway_url, creds.passport_url, 30, filePath, creds.encoding_key, creds.callback_token);
+    }
+    get config() { return this._config; }
+    async _ensureInit() {
+        if (!this._fetchFn) {
+            const nodeFetch = await Promise.resolve().then(() => __importStar(require("node-fetch")));
+            this._fetchFn = nodeFetch.default;
+        }
+        if (!this._tokenManager) {
+            this._tokenManager = new auth_1.TokenManager(this._config, this._fetchFn, this._store);
+        }
+    }
+    async getToken() {
+        await this._ensureInit();
+        return this._tokenManager.getToken();
+    }
+    invalidateToken() {
+        if (this._tokenManager)
+            this._tokenManager.invalidate();
+    }
+    async healthCheck() {
+        try {
+            await this.getToken();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    _privateMsgUrl(token) {
+        return (0, urlHelpers_1.buildApiUrl)(this._config, "smart_bot", "private_message", token);
+    }
+    _groupMsgUrl(token) {
+        return (0, urlHelpers_1.buildApiUrl)(this._config, "smart_bot", "group_message", token);
+    }
+    async _sendPrivate(chatId, msgType, msgData) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        const url = this._privateMsgUrl(token);
+        const payload = { chatId, msgType, msgData };
+        const [data, httpErr] = await (0, http_1.doPost)(url, payload, this._fetchFn);
+        if (httpErr)
+            return new models_1.SendMessageResult({ success: false, error: httpErr, msg_type: msgType, operation: "private_message" });
+        return _parseSendResponse(data, msgType, "private_message");
+    }
+    async _sendGroup(groupId, msgType, msgData, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        const url = this._groupMsgUrl(token);
+        const payload = { groupId, msgType, msgData };
+        if (opts?.userToken)
+            payload.userToken = opts.userToken;
+        if (opts?.senderId)
+            payload.senderId = opts.senderId;
+        const [data, httpErr] = await (0, http_1.doPost)(url, payload, this._fetchFn);
+        if (httpErr)
+            return new models_1.SendMessageResult({ success: false, error: httpErr, msg_type: msgType, operation: "group_message", retryable: true });
+        return _parseSendResponse(data, msgType, "group_message");
+    }
+    async sendText(chatId, content, opts) {
+        const msgData = { text: content };
+        const isGroup = opts?.is_group || false;
+        if (opts?.reminder_all || opts?.reminder_user_ids) {
+            const reminder = {};
+            if (opts?.reminder_all)
+                reminder.reminderAll = true;
+            if (opts?.reminder_user_ids)
+                reminder.reminderUserIds = opts.reminder_user_ids;
+            msgData.reminder = reminder;
+        }
+        if (opts?.file_path) {
+            await this._ensureInit();
+            const token = await this._tokenManager.getToken();
+            const mediaResult = await (0, media_1.uploadMedia)(this._config, this._tokenManager, this._fetchFn, opts.file_path, opts.media_type || (0, constants_1.guessMediaType)(opts.file_path), opts.user_token || "");
+            if (!mediaResult.success)
+                return new models_1.SendMessageResult({ success: false, error: mediaResult.error });
+            msgData.mediaId = mediaResult.media_id;
+            if (opts.cover_image_path) {
+                const coverResult = await (0, media_1.uploadMedia)(this._config, this._tokenManager, this._fetchFn, opts.cover_image_path, constants_1.MEDIA_TYPE_IMAGE, opts.user_token || "");
+                if (!coverResult.success)
+                    return new models_1.SendMessageResult({ success: false, error: coverResult.error });
+                msgData.coverMediaId = coverResult.media_id;
+            }
+        }
+        if (isGroup)
+            return this._sendGroup(chatId, "text", msgData, { userToken: opts?.user_token || "", senderId: opts?.sender_id || "" });
+        return this._sendPrivate(chatId, "text", msgData);
+    }
+    async sendMarkdown(chatId, content, opts) {
+        const msgData = { formatText: content };
+        if (opts?.reminder_all || opts?.reminder_user_ids) {
+            const reminder = {};
+            if (opts?.reminder_all)
+                reminder.reminderAll = true;
+            if (opts?.reminder_user_ids)
+                reminder.reminderUserIds = opts.reminder_user_ids;
+            msgData.reminder = reminder;
+        }
+        const isGroup = opts?.is_group || false;
+        if (isGroup)
+            return this._sendGroup(chatId, "formatText", msgData, { userToken: opts?.user_token || "", senderId: opts?.sender_id || "" });
+        return this._sendPrivate(chatId, "formatText", msgData);
+    }
+    async sendFile(chatId, filePath, opts) {
+        await this._ensureInit();
+        const mediaType = opts?.media_type || (0, constants_1.guessMediaType)(filePath);
+        const uploadResult = await (0, media_1.uploadMedia)(this._config, this._tokenManager, this._fetchFn, filePath, mediaType, opts?.user_token || "");
+        if (!uploadResult.success)
+            return new models_1.SendMessageResult({ success: false, error: uploadResult.error });
+        const msgData = { mediaId: uploadResult.media_id };
+        if (opts?.caption)
+            msgData.text = opts.caption;
+        if (opts?.cover_image_path) {
+            const coverResult = await (0, media_1.uploadMedia)(this._config, this._tokenManager, this._fetchFn, opts.cover_image_path, constants_1.MEDIA_TYPE_IMAGE, opts?.user_token || "");
+            if (!coverResult.success)
+                return new models_1.SendMessageResult({ success: false, error: coverResult.error });
+            msgData.coverMediaId = coverResult.media_id;
+        }
+        const isGroup = opts?.is_group || false;
+        if (isGroup)
+            return this._sendGroup(chatId, "file", msgData, { userToken: opts?.user_token || "", senderId: opts?.sender_id || "" });
+        return this._sendPrivate(chatId, "file", msgData);
+    }
+    async sendImageUrl(chatId, imageUrl, opts) {
+        const msgData = { imageUrl };
+        if (opts?.caption)
+            msgData.text = opts.caption;
+        const isGroup = opts?.is_group || false;
+        if (isGroup)
+            return this._sendGroup(chatId, "image", msgData, { userToken: opts?.user_token || "", senderId: opts?.sender_id || "" });
+        return this._sendPrivate(chatId, "image", msgData);
+    }
+    async sendLinkCard(chatId, title, link, opts) {
+        const params = new models_1.LinkCardParams({ chat_id: chatId, title, link, description: opts?.description || "", icon_link: opts?.icon_link || "", pc_link: opts?.pc_link || "", pad_link: opts?.pad_link || "", from_name: opts?.from_name || "", from_icon_link: opts?.from_icon_link || "", is_group: opts?.is_group || false, user_token: opts?.user_token || "", sender_id: opts?.sender_id || "" });
+        return this.sendLinkCardWithParams(params);
+    }
+    async sendLinkCardWithParams(params) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        const url = params.is_group ? this._groupMsgUrl(token) : this._privateMsgUrl(token);
+        const payload = { msgType: "linkCard", msgData: params };
+        if (params.is_group) {
+            payload.groupId = params.chat_id;
+        }
+        else {
+            payload.chatId = params.chat_id;
+        }
+        if (params.user_token)
+            payload.userToken = params.user_token;
+        if (params.sender_id)
+            payload.senderId = params.sender_id;
+        const [data, httpErr] = await (0, http_1.doPost)(url, payload, this._fetchFn);
+        if (httpErr)
+            return new models_1.SendMessageResult({ success: false, error: httpErr, msg_type: "linkCard" });
+        return _parseSendResponse(data, "linkCard");
+    }
+    async sendAppArticles(chatId, articles, opts) {
+        const msgData = { articles };
+        const isGroup = opts?.is_group || false;
+        if (isGroup)
+            return this._sendGroup(chatId, "appArticles", msgData, { userToken: opts?.user_token || "", senderId: opts?.sender_id || "" });
+        return this._sendPrivate(chatId, "appArticles", msgData);
+    }
+    async sendAppCard(chatId, bodyTitle, opts) {
+        const params = new models_1.AppCardParams({
+            body_title: bodyTitle, chat_id: chatId,
+            head_title: opts?.head_title || "", body_sub_title: opts?.body_sub_title || "",
+            body_content: opts?.body_content || "", signature: opts?.signature || "",
+            fields: opts?.fields, links: opts?.links, card_link: opts?.card_link || "",
+            pc_card_link: opts?.pc_card_link || "", pad_card_link: opts?.pad_card_link || "",
+            is_dynamic: opts?.is_dynamic || false, head_status_info: opts?.head_status_info,
+            staff_id: opts?.staff_id || "", head_icon_url: opts?.head_icon_url || "",
+            is_group: opts?.is_group || false, user_token: opts?.user_token || "",
+            sender_id: opts?.sender_id || "",
+        });
+        return this.sendAppCardWithParams(params);
+    }
+    async sendAppCardWithParams(params) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        const url = params.is_group ? this._groupMsgUrl(token) : this._privateMsgUrl(token);
+        const payload = { msgType: "appCard", msgData: params };
+        if (params.is_group) {
+            payload.groupId = params.chat_id;
+        }
+        else {
+            payload.chatId = params.chat_id;
+        }
+        if (params.user_token)
+            payload.userToken = params.user_token;
+        if (params.sender_id)
+            payload.senderId = params.sender_id;
+        const [data, httpErr] = await (0, http_1.doPost)(url, payload, this._fetchFn);
+        if (httpErr)
+            return new models_1.SendMessageResult({ success: false, error: httpErr, msg_type: "appCard" });
+        return _parseSendResponse(data, "appCard");
+    }
+    async sendOacard(chatId, title, opts) {
+        const params = new models_1.OaCardParams({
+            chat_id: chatId, title, head: opts?.head || "", sub_title: opts?.sub_title || "",
+            staff_id: opts?.staff_id || "", fields: opts?.fields, link: opts?.link || "",
+            pc_link: opts?.pc_link || "", pad_link: opts?.pad_link || "",
+            card_action: opts?.card_action, is_group: opts?.is_group || false,
+            user_token: opts?.user_token || "", sender_id: opts?.sender_id || "",
+        });
+        return this.sendOacardWithParams(params);
+    }
+    async sendOacardWithParams(params) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        const url = params.is_group ? this._groupMsgUrl(token) : this._privateMsgUrl(token);
+        const payload = { msgType: "oacard", msgData: params };
+        if (params.is_group) {
+            payload.groupId = params.chat_id;
+        }
+        else {
+            payload.chatId = params.chat_id;
+        }
+        if (params.user_token)
+            payload.userToken = params.user_token;
+        if (params.sender_id)
+            payload.senderId = params.sender_id;
+        const [data, httpErr] = await (0, http_1.doPost)(url, payload, this._fetchFn);
+        if (httpErr)
+            return new models_1.SendMessageResult({ success: false, error: httpErr, msg_type: "oacard" });
+        return _parseSendResponse(data, "oacard");
+    }
+    async updateDynamicCard(msgId, opts) {
+        const params = new models_1.DynamicCardUpdateParams({
+            msg_id: msgId, head_status_info: opts?.head_status_info,
+            links: opts?.links, is_last_update: opts?.is_last_update || false,
+        });
+        return this.updateDynamicCardWithParams(params);
+    }
+    async updateDynamicCardWithParams(params) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        const url = (0, urlHelpers_1.buildApiUrl)(this._config, "message", "dynamic_update", token);
+        const payload = { msgId: params.msg_id };
+        if (params.head_status_info)
+            payload.headStatusInfo = params.head_status_info;
+        if (params.links)
+            payload.links = params.links;
+        payload.isLastUpdate = params.is_last_update;
+        const [data, httpErr] = await (0, http_1.doPost)(url, payload, this._fetchFn);
+        if (httpErr)
+            return new models_1.SendMessageResult({ success: false, error: httpErr, msg_type: "dynamic_update" });
+        return _parseSendResponse(data, "dynamic_update", "update_dynamic_card");
+    }
+    async revokeMessage(messageIds, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        const url = (0, urlHelpers_1.buildApiUrl)(this._config, "message", "revoke", token);
+        const payload = { msgIdList: messageIds, chatType: opts?.chat_type || "bot" };
+        if (opts?.sender_id)
+            payload.senderId = opts.sender_id;
+        const [data, httpErr] = await (0, http_1.doPost)(url, payload, this._fetchFn);
+        if (httpErr)
+            return new models_1.SendMessageResult({ success: false, error: httpErr, operation: "revoke_message" });
+        return _parseSendResponse(data, "", "revoke_message");
+    }
+    async queryGroups(opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        const pageOffset = opts?.page_offset || 1;
+        const pageSize = opts?.page_size || 100;
+        const url = (0, urlHelpers_1.buildApiUrl)(this._config, "groups", "fetch", token) + `&page_offset=${pageOffset}&page_size=${pageSize}`;
+        const [data, httpErr] = await (0, http_1.doGet)(url, this._fetchFn);
+        if (httpErr)
+            return new models_1.QueryGroupsResult({ success: false, error: httpErr });
+        const errCode = data.errCode ?? -1;
+        if (errCode !== 0) {
+            const msg = data.errMsg || "Unknown error";
+            return new models_1.QueryGroupsResult({ success: false, error: `API error (errCode=${errCode}): ${msg}` });
+        }
+        const d = data.data || {};
+        return new models_1.QueryGroupsResult({
+            success: true, total_group_ids: d.totalGroupIds || 0,
+            group_ids: d.groupIds || [], raw_response: data,
+        });
+    }
+    async sendReminderMsg(msgId, reminderTypes, userIdList) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, reminders_1.sendReminder)(this._config, token, msgId, reminderTypes, userIdList, { fetchFn: this._fetchFn });
+    }
+    async uploadMediaFile(filePath, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        const mediaType = opts?.media_type || (0, constants_1.guessMediaType)(filePath);
+        const result = await (0, media_1.uploadMedia)(this._config, this._tokenManager, this._fetchFn, filePath, mediaType, opts?.user_token || "");
+        if (!result.success)
+            return new models_1.SendMessageResult({ success: false, error: result.error });
+        return new models_1.SendMessageResult({ success: true, message_id: result.media_id, operation: "upload_media", raw_response: result.raw_response });
+    }
+    async uploadAppMediaFile(filePath, opts) {
+        await this._ensureInit();
+        const result = await (0, media_1.uploadAppMedia)(this._config, this._tokenManager, this._fetchFn, filePath, opts?.media_type || (0, constants_1.guessAppMediaType)(filePath), { width: opts?.width, height: opts?.height, duration: opts?.duration });
+        if (!result.success)
+            return new models_1.SendMessageResult({ success: false, error: result.error });
+        return new models_1.SendMessageResult({ success: true, message_id: result.media_id, operation: "upload_app_media", raw_response: result.raw_response });
+    }
+    async downloadMediaFile(mediaId) {
+        await this._ensureInit();
+        return (0, media_1.downloadMedia)(this._config, this._tokenManager, this._fetchFn, mediaId);
+    }
+    async downloadMediaToFile(mediaId, opts) {
+        await this._ensureInit();
+        return (0, media_1.downloadMediaToFile)(this._config, this._tokenManager, this._fetchFn, mediaId, opts?.target_path, opts?.media_type || "file");
+    }
+    async fetchMediaPathInfo(mediaId, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, media_1.fetchMediaPath)(this._config, token, mediaId, { user_token: opts?.user_token || "", fetchFn: this._fetchFn });
+    }
+    buildAuthorizeUrl(redirectUri, opts) {
+        return (0, oauth_1.buildAuthorizeUrl)(this._config, redirectUri, opts);
+    }
+    static parseAuthorizeCallback(queryString) {
+        return (0, oauth_1.parseAuthorizeCallback)(queryString);
+    }
+    static validateCallbackState(callbackState, expectedState) {
+        return (0, oauth_1.validateCallbackState)(callbackState, expectedState);
+    }
+    async exchangeCode(code, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, oauth_1.exchangeCodeForUserToken)(this._config, token, code, { redirect_uri: opts?.redirect_uri, fetchFn: this._fetchFn });
+    }
+    async refreshUserToken(refreshToken, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, oauth_1.refreshUserToken)(this._config, token, refreshToken, { scope: opts?.scope, fetchFn: this._fetchFn });
+    }
+    async fetchUserInfoByToken(userToken) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, users_1.fetchUserInfo)(this._config, token, userToken, { fetchFn: this._fetchFn });
+    }
+    async fetchStaffBasicInfo(staffId, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, contacts_1.fetchStaffBasicInfo)(this._config, token, staffId, { user_token: opts?.user_token || "", fetchFn: this._fetchFn });
+    }
+    async fetchStaffDetail(staffId, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, contacts_1.fetchStaffDetail)(this._config, token, staffId, { user_token: opts?.user_token || "", fetchFn: this._fetchFn });
+    }
+    async fetchDepartmentAncestors(staffId, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, contacts_1.fetchDepartmentAncestors)(this._config, token, staffId, { user_token: opts?.user_token || "", fetchFn: this._fetchFn });
+    }
+    async fetchStaffIdMapping(orgId, idType, idValue, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, contacts_1.fetchStaffIdMapping)(this._config, token, orgId, idType, idValue, { user_token: opts?.user_token || "", fetchFn: this._fetchFn });
+    }
+    async fetchOrgExtraFieldIds(orgId, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, contacts_1.fetchOrgExtraFieldIds)(this._config, token, orgId, { user_token: opts?.user_token || "", page: opts?.page, page_size: opts?.page_size, fetchFn: this._fetchFn });
+    }
+    async fetchOrgInfo(orgId, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, contacts_1.fetchOrgInfo)(this._config, token, orgId, { user_token: opts?.user_token || "", fetchFn: this._fetchFn });
+    }
+    async searchStaff(keyword, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, contacts_1.searchStaff)(this._config, token, keyword, { user_token: opts?.user_token || "", user_id: opts?.user_id || "", recursive: opts?.recursive, sector_ids: opts?.sector_ids, page: opts?.page, page_size: opts?.page_size, fetchFn: this._fetchFn });
+    }
+    async sendBotMessage(msgType, msgData, chatIds, departmentIds, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        if (opts?.is_group && chatIds && chatIds.length > 0) {
+            const results = [];
+            for (const gid of chatIds) {
+                results.push(await (0, groupMessages_1.sendGroupMessage)(this._config, token, gid, msgType, msgData, { user_token: opts?.user_token || "", fetchFn: this._fetchFn }));
+            }
+            const first = results[0];
+            return new models_1.BotMessageResult({ success: first.success, message_id: first.message_id, error: first.error, raw_response: first.raw_response });
+        }
+        const url = (0, urlHelpers_1.buildApiUrl)(this._config, "bot", "message_create", token, { userToken: opts?.user_token || "" });
+        const payload = { msgType, msgData };
+        if (chatIds)
+            payload.userIdList = chatIds;
+        if (departmentIds)
+            payload.departmentIdList = departmentIds;
+        if (opts?.entry_id)
+            payload.entryId = opts.entry_id;
+        const [data, httpErr] = await (0, http_1.doPost)(url, payload, this._fetchFn);
+        if (httpErr)
+            return new models_1.BotMessageResult({ success: false, error: httpErr });
+        const errCode = data.errCode ?? -1;
+        if (errCode !== 0) {
+            const msg = data.errMsg || "Unknown error";
+            return new models_1.BotMessageResult({ success: false, error: `API error (errCode=${errCode}): ${msg}` });
+        }
+        const d = data.data || {};
+        return new models_1.BotMessageResult({ success: true, message_id: d.msgId, invalid_staff: d.invalidStaff, invalid_department: d.invalidDepartment, raw_response: data });
+    }
+    async sendAccountMessage(msgType, msgData, chatIds, departmentIds, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, accountMessages_1.sendAccountMessage)(this._config, token, msgType, msgData, { chat_ids: chatIds, department_ids: departmentIds, account_id: opts?.account_id || "", entry_id: opts?.entry_id || "", attach: opts?.attach || "", user_token: opts?.user_token || "", fetchFn: this._fetchFn });
+    }
+    async sendUserMessage(receiverId, msgType, msgData, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, userMessages_1.sendUserMessage)(this._config, token, opts?.user_token || "", receiverId, msgType, msgData, { common: opts?.common, uuid: opts?.uuid, fetchFn: this._fetchFn });
+    }
+    async sendGroupMessage(groupId, msgType, msgData, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, groupMessages_1.sendGroupMessage)(this._config, token, groupId, msgType, msgData, { user_token: opts?.user_token || "", sender_id: opts?.sender_id || "", outlines: opts?.outlines || "", uuid: opts?.uuid || "", entry_id: opts?.entry_id || "", fetchFn: this._fetchFn });
+    }
+    async createStreamMessage(receiverId, receiverType, streamId) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, streaming_1.createStreamMessage)(this._config, token, receiverId, receiverType, streamId, { fetchFn: this._fetchFn });
+    }
+    async fetchStreamMessage(msgId) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, streaming_1.fetchStreamMessage)(this._config, token, msgId, { fetchFn: this._fetchFn });
+    }
+    async createGroup(name, orgId, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, groups_1.createGroup)(this._config, token, name, orgId, { ...opts, fetchFn: this._fetchFn });
+    }
+    async fetchGroupInfo(groupId, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, groups_1.fetchGroupInfo)(this._config, token, groupId, { user_token: opts?.user_token || "", fetchFn: this._fetchFn });
+    }
+    async fetchGroupMembers(groupId, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, groups_1.fetchGroupMembers)(this._config, token, groupId, { user_token: opts?.user_token || "", page_offset: opts?.page_offset, page_size: opts?.page_size, fetchFn: this._fetchFn });
+    }
+    async fetchGroupList(opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, groups_1.fetchGroupList)(this._config, token, { user_token: opts?.user_token || "", page_offset: opts?.page_offset, page_size: opts?.page_size, fetchFn: this._fetchFn });
+    }
+    async checkIsInGroup(groupId, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, groups_1.checkIsInGroup)(this._config, token, groupId, { user_token: opts?.user_token || "", staff_id: opts?.staff_id || "", fetchFn: this._fetchFn });
+    }
+    async updateGroupInfo(groupId, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, groups_1.updateGroupInfo)(this._config, token, groupId, { ...opts, fetchFn: this._fetchFn });
+    }
+    async updateGroupMembers(groupId, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, groups_1.updateGroupMembers)(this._config, token, groupId, { ...opts, fetchFn: this._fetchFn });
+    }
+    async dismissGroup(groupId, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, groups_1.dismissGroup)(this._config, token, groupId, { user_token: opts?.user_token || "", fetchFn: this._fetchFn });
+    }
+    async fetchDepartmentDetail(departmentId, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, departments_1.fetchDepartmentDetail)(this._config, token, departmentId, { user_token: opts?.user_token || "", tag_id: opts?.tag_id || "", fetchFn: this._fetchFn });
+    }
+    async fetchDepartmentChildren(departmentId, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, departments_1.fetchDepartmentChildren)(this._config, token, departmentId, { user_token: opts?.user_token || "", fetchFn: this._fetchFn });
+    }
+    async fetchDepartmentStaffs(departmentId, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, departments_1.fetchDepartmentStaffs)(this._config, token, departmentId, { user_token: opts?.user_token || "", page: opts?.page, page_size: opts?.page_size, fetchFn: this._fetchFn });
+    }
+    async createTodoTask(title, link, pcLink, executorIds, orgId, type = 1, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, todos_1.createTodoTask)(this._config, token, title, link, pcLink, executorIds, orgId, type, { ...opts, fetchFn: this._fetchFn });
+    }
+    async updateTodoTask(todotaskId, title, link, pcLink, orgId, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, todos_1.updateTodoTask)(this._config, token, todotaskId, title, link, pcLink, orgId, { ...opts, fetchFn: this._fetchFn });
+    }
+    async updateTodoTaskStatus(todotaskId, status, orgId, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, todos_1.updateTodoTaskStatus)(this._config, token, todotaskId, status, orgId, { ...opts, fetchFn: this._fetchFn });
+    }
+    async deleteTodoTask(todotaskId, orgId, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, todos_1.deleteTodoTask)(this._config, token, todotaskId, orgId, { ...opts, fetchFn: this._fetchFn });
+    }
+    async fetchTodoTaskList(orgId, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, todos_1.fetchTodoTaskList)(this._config, token, orgId, { ...opts, fetchFn: this._fetchFn });
+    }
+    async fetchTodoTaskBySourceId(sourceId, orgId, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, todos_1.fetchTodoTaskBySourceId)(this._config, token, sourceId, orgId, { ...opts, fetchFn: this._fetchFn });
+    }
+    async fetchTodoTaskById(todotaskId, orgId, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, todos_1.fetchTodoTaskById)(this._config, token, todotaskId, orgId, { ...opts, fetchFn: this._fetchFn });
+    }
+    async fetchTodoTaskStatusCounts(staffId, orgId, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, todos_1.fetchTodoTaskStatusCounts)(this._config, token, staffId, orgId, { ...opts, fetchFn: this._fetchFn });
+    }
+    async updateExecutorStatus(executorStatusList, orgId, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, todos_1.updateExecutorStatus)(this._config, token, executorStatusList, orgId, { ...opts, fetchFn: this._fetchFn });
+    }
+    async addExecutors(executorIds, orgId, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, todos_1.addExecutors)(this._config, token, executorIds, orgId, { ...opts, fetchFn: this._fetchFn });
+    }
+    async deleteExecutors(executorIds, orgId, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, todos_1.deleteExecutors)(this._config, token, executorIds, orgId, { ...opts, fetchFn: this._fetchFn });
+    }
+    async fetchExecutorList(todotaskId, orgId, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, todos_1.fetchExecutorList)(this._config, token, todotaskId, orgId, { ...opts, fetchFn: this._fetchFn });
+    }
+    async fetchPrimaryCalendar(opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, calendars_1.fetchPrimaryCalendar)(this._config, token, { user_token: opts?.user_token || "", user_id: opts?.user_id || "", fetchFn: this._fetchFn });
+    }
+    async createSchedule(calendarId, summary, startTime, endTime, attendees, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, calendars_1.createSchedule)(this._config, token, calendarId, summary, startTime, endTime, attendees, { ...opts, fetchFn: this._fetchFn });
+    }
+    async fetchSchedule(calendarId, scheduleId, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, calendars_1.fetchSchedule)(this._config, token, calendarId, scheduleId, { user_token: opts?.user_token || "", user_id: opts?.user_id || "", fetchFn: this._fetchFn });
+    }
+    async deleteSchedule(calendarId, scheduleId, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, calendars_1.deleteSchedule)(this._config, token, calendarId, scheduleId, { ...opts, fetchFn: this._fetchFn });
+    }
+    async updateSchedule(calendarId, scheduleId, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, calendars_1.updateSchedule)(this._config, token, calendarId, scheduleId, { ...opts, fetchFn: this._fetchFn });
+    }
+    async fetchScheduleList(calendarId, startTime, endTime, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, calendars_1.fetchScheduleList)(this._config, token, calendarId, startTime, endTime, { user_token: opts?.user_token || "", user_id: opts?.user_id || "", fetchFn: this._fetchFn });
+    }
+    async fetchScheduleAttendees(calendarId, scheduleId, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, calendars_1.fetchScheduleAttendees)(this._config, token, calendarId, scheduleId, { ...opts, fetchFn: this._fetchFn });
+    }
+    async addScheduleAttendees(calendarId, scheduleId, attendees, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, calendars_1.addScheduleAttendees)(this._config, token, calendarId, scheduleId, attendees, { ...opts, fetchFn: this._fetchFn });
+    }
+    async deleteScheduleAttendees(calendarId, scheduleId, attendees, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, calendars_1.deleteScheduleAttendees)(this._config, token, calendarId, scheduleId, attendees, { ...opts, fetchFn: this._fetchFn });
+    }
+    async updateScheduleAttendeeMeta(calendarId, scheduleId, opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, calendars_1.updateScheduleAttendeeMeta)(this._config, token, calendarId, scheduleId, { ...opts, fetchFn: this._fetchFn });
+    }
+    async fetchChatList(opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, chats_1.fetchChatList)(this._config, token, { ...opts, fetchFn: this._fetchFn });
+    }
+    async fetchChatMessages(opts) {
+        await this._ensureInit();
+        const token = await this._tokenManager.getToken();
+        return (0, chats_1.fetchChatMessages)(this._config, token, { ...opts, fetchFn: this._fetchFn });
+    }
+    static parseCallbackPayload(encryptedData, opts) {
+        return (0, callbacks_1.parseCallbackPayload)(encryptedData, { encodingKey: opts?.encoding_key || "", verifySignature: opts?.verify_signature || false, timestamp: opts?.timestamp || "", nonce: opts?.nonce || "", signature: opts?.signature || "", callbackToken: opts?.callback_token || "", knownAppId: opts?.known_app_id || "" });
+    }
+    parseCallback(encryptedData, opts) {
+        return (0, callbacks_1.parseCallbackPayload)(encryptedData, { encodingKey: this._config.encoding_key, verifySignature: opts?.verify_signature || false, timestamp: opts?.timestamp || "", nonce: opts?.nonce || "", signature: opts?.signature || "", callbackToken: this._config.callback_token, knownAppId: opts?.known_app_id || "" });
+    }
+    static verifyCallbackSignature(timestamp, nonce, signature, encodingKey, opts) {
+        return (0, callbacks_1.verifyCallbackSignature)(timestamp, nonce, signature, encodingKey, opts?.data_encrypt || "", opts?.callback_token || "");
+    }
+    verifyCallback(timestamp, nonce, signature, opts) {
+        return (0, callbacks_1.verifyCallbackSignature)(timestamp, nonce, signature, this._config.encoding_key, opts?.data_encrypt || "", this._config.callback_token);
+    }
+    static getCallbackEventTypes() {
+        return (0, callbacks_1.getCallbackEventTypes)();
+    }
+}
+exports.LansengerClient = LansengerClient;
+//# sourceMappingURL=client.js.map