@larksuiteoapi/node-sdk 1.23.0 → 1.24.0-beta.0

package/lib/index.js

@@ -22,6 +22,8 @@ var identity = require('lodash.identity');
 var pickBy = require('lodash.pickby');
 var fs = require('fs');
 var merge = require('lodash.merge');
+var qs = require('querystring');
+var WebSocket = require('ws');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -33,6 +35,8 @@ var identity__default = /*#__PURE__*/_interopDefaultLegacy(identity);
 var pickBy__default = /*#__PURE__*/_interopDefaultLegacy(pickBy);
 var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
 var merge__default = /*#__PURE__*/_interopDefaultLegacy(merge);
+var qs__default = /*#__PURE__*/_interopDefaultLegacy(qs);
+var WebSocket__default = /*#__PURE__*/_interopDefaultLegacy(WebSocket);
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -57161,10 +57165,11 @@ class EventDispatcher {
         });
         return this;
     }
-    invoke(data) {
+    invoke(data, params) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            if (!((_a = this.requestHandle) === null || _a === void 0 ? void 0 : _a.checkIsEventValidated(data))) {
+            const needCheck = get__default["default"](params, 'needCheck', true);
+            if (needCheck && !((_a = this.requestHandle) === null || _a === void 0 ? void 0 : _a.checkIsEventValidated(data))) {
                 this.logger.warn('verification failed event');
                 return undefined;
             }
@@ -57457,12 +57462,1109 @@ var messageCard = /*#__PURE__*/Object.freeze({
     defaultCard: defaultCard
 });
 
+// @ts-nocheck
+/*eslint-disable block-scoped-var, id-length, no-control-regex, no-magic-numbers, no-prototype-builtins, no-redeclare, no-shadow, no-var, sort-vars*/
+const $protobuf = require("protobufjs/minimal");
+
+$protobuf.util.Long = undefined;
+$protobuf.configure();
+
+// Common aliases
+const $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.util;
+
+// Exported root namespace
+const $root = $protobuf.roots["default"] || ($protobuf.roots["default"] = {});
+
+const pbbp2 = $root.pbbp2 = (() => {
+    /**
+     * Namespace pbbp2.
+     * @exports pbbp2
+     * @namespace
+     */
+    const pbbp2 = {};
+
+    pbbp2.Header = (function() {
+
+        /**
+         * Properties of a Header.
+         * @memberof pbbp2
+         * @interface IHeader
+         * @property {string} key Header key
+         * @property {string} value Header value
+         */
+
+        /**
+         * Constructs a new Header.
+         * @memberof pbbp2
+         * @classdesc Represents a Header.
+         * @implements IHeader
+         * @constructor
+         * @param {pbbp2.IHeader=} [properties] Properties to set
+         */
+        function Header(properties) {
+            if (properties)
+                for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                    if (properties[keys[i]] != null)
+                        this[keys[i]] = properties[keys[i]];
+        }
+
+        /**
+         * Header key.
+         * @member {string} key
+         * @memberof pbbp2.Header
+         * @instance
+         */
+        Header.prototype.key = "";
+
+        /**
+         * Header value.
+         * @member {string} value
+         * @memberof pbbp2.Header
+         * @instance
+         */
+        Header.prototype.value = "";
+
+        /**
+         * Creates a new Header instance using the specified properties.
+         * @function create
+         * @memberof pbbp2.Header
+         * @static
+         * @param {pbbp2.IHeader=} [properties] Properties to set
+         * @returns {pbbp2.Header} Header instance
+         */
+        Header.create = function create(properties) {
+            return new Header(properties);
+        };
+
+        /**
+         * Encodes the specified Header message. Does not implicitly {@link pbbp2.Header.verify|verify} messages.
+         * @function encode
+         * @memberof pbbp2.Header
+         * @static
+         * @param {pbbp2.IHeader} message Header message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        Header.encode = function encode(message, writer) {
+            if (!writer)
+                writer = $Writer.create();
+            writer.uint32(/* id 1, wireType 2 =*/10).string(message.key);
+            writer.uint32(/* id 2, wireType 2 =*/18).string(message.value);
+            return writer;
+        };
+
+        /**
+         * Encodes the specified Header message, length delimited. Does not implicitly {@link pbbp2.Header.verify|verify} messages.
+         * @function encodeDelimited
+         * @memberof pbbp2.Header
+         * @static
+         * @param {pbbp2.IHeader} message Header message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        Header.encodeDelimited = function encodeDelimited(message, writer) {
+            return this.encode(message, writer).ldelim();
+        };
+
+        /**
+         * Decodes a Header message from the specified reader or buffer.
+         * @function decode
+         * @memberof pbbp2.Header
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @param {number} [length] Message length if known beforehand
+         * @returns {pbbp2.Header} Header
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        Header.decode = function decode(reader, length) {
+            if (!(reader instanceof $Reader))
+                reader = $Reader.create(reader);
+            let end = length === undefined ? reader.len : reader.pos + length, message = new $root.pbbp2.Header();
+            while (reader.pos < end) {
+                let tag = reader.uint32();
+                switch (tag >>> 3) {
+                case 1: {
+                        message.key = reader.string();
+                        break;
+                    }
+                case 2: {
+                        message.value = reader.string();
+                        break;
+                    }
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+                }
+            }
+            if (!message.hasOwnProperty("key"))
+                throw $util.ProtocolError("missing required 'key'", { instance: message });
+            if (!message.hasOwnProperty("value"))
+                throw $util.ProtocolError("missing required 'value'", { instance: message });
+            return message;
+        };
+
+        /**
+         * Decodes a Header message from the specified reader or buffer, length delimited.
+         * @function decodeDelimited
+         * @memberof pbbp2.Header
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @returns {pbbp2.Header} Header
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        Header.decodeDelimited = function decodeDelimited(reader) {
+            if (!(reader instanceof $Reader))
+                reader = new $Reader(reader);
+            return this.decode(reader, reader.uint32());
+        };
+
+        /**
+         * Verifies a Header message.
+         * @function verify
+         * @memberof pbbp2.Header
+         * @static
+         * @param {Object.<string,*>} message Plain object to verify
+         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+         */
+        Header.verify = function verify(message) {
+            if (typeof message !== "object" || message === null)
+                return "object expected";
+            if (!$util.isString(message.key))
+                return "key: string expected";
+            if (!$util.isString(message.value))
+                return "value: string expected";
+            return null;
+        };
+
+        /**
+         * Creates a Header message from a plain object. Also converts values to their respective internal types.
+         * @function fromObject
+         * @memberof pbbp2.Header
+         * @static
+         * @param {Object.<string,*>} object Plain object
+         * @returns {pbbp2.Header} Header
+         */
+        Header.fromObject = function fromObject(object) {
+            if (object instanceof $root.pbbp2.Header)
+                return object;
+            let message = new $root.pbbp2.Header();
+            if (object.key != null)
+                message.key = String(object.key);
+            if (object.value != null)
+                message.value = String(object.value);
+            return message;
+        };
+
+        /**
+         * Creates a plain object from a Header message. Also converts values to other types if specified.
+         * @function toObject
+         * @memberof pbbp2.Header
+         * @static
+         * @param {pbbp2.Header} message Header
+         * @param {$protobuf.IConversionOptions} [options] Conversion options
+         * @returns {Object.<string,*>} Plain object
+         */
+        Header.toObject = function toObject(message, options) {
+            if (!options)
+                options = {};
+            let object = {};
+            if (options.defaults) {
+                object.key = "";
+                object.value = "";
+            }
+            if (message.key != null && message.hasOwnProperty("key"))
+                object.key = message.key;
+            if (message.value != null && message.hasOwnProperty("value"))
+                object.value = message.value;
+            return object;
+        };
+
+        /**
+         * Converts this Header to JSON.
+         * @function toJSON
+         * @memberof pbbp2.Header
+         * @instance
+         * @returns {Object.<string,*>} JSON object
+         */
+        Header.prototype.toJSON = function toJSON() {
+            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+        };
+
+        /**
+         * Gets the default type url for Header
+         * @function getTypeUrl
+         * @memberof pbbp2.Header
+         * @static
+         * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+         * @returns {string} The default type url
+         */
+        Header.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+            if (typeUrlPrefix === undefined) {
+                typeUrlPrefix = "type.googleapis.com";
+            }
+            return typeUrlPrefix + "/pbbp2.Header";
+        };
+
+        return Header;
+    })();
+
+    pbbp2.Frame = (function() {
+
+        /**
+         * Properties of a Frame.
+         * @memberof pbbp2
+         * @interface IFrame
+         * @property {number} SeqID Frame SeqID
+         * @property {number} LogID Frame LogID
+         * @property {number} service Frame service
+         * @property {number} method Frame method
+         * @property {Array.<pbbp2.IHeader>|null} [headers] Frame headers
+         * @property {string|null} [payloadEncoding] Frame payloadEncoding
+         * @property {string|null} [payloadType] Frame payloadType
+         * @property {Uint8Array|null} [payload] Frame payload
+         * @property {string|null} [LogIDNew] Frame LogIDNew
+         */
+
+        /**
+         * Constructs a new Frame.
+         * @memberof pbbp2
+         * @classdesc Represents a Frame.
+         * @implements IFrame
+         * @constructor
+         * @param {pbbp2.IFrame=} [properties] Properties to set
+         */
+        function Frame(properties) {
+            this.headers = [];
+            if (properties)
+                for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                    if (properties[keys[i]] != null)
+                        this[keys[i]] = properties[keys[i]];
+        }
+
+        /**
+         * Frame SeqID.
+         * @member {number} SeqID
+         * @memberof pbbp2.Frame
+         * @instance
+         */
+        Frame.prototype.SeqID = $util.Long ? $util.Long.fromBits(0,0,true) : 0;
+
+        /**
+         * Frame LogID.
+         * @member {number} LogID
+         * @memberof pbbp2.Frame
+         * @instance
+         */
+        Frame.prototype.LogID = $util.Long ? $util.Long.fromBits(0,0,true) : 0;
+
+        /**
+         * Frame service.
+         * @member {number} service
+         * @memberof pbbp2.Frame
+         * @instance
+         */
+        Frame.prototype.service = 0;
+
+        /**
+         * Frame method.
+         * @member {number} method
+         * @memberof pbbp2.Frame
+         * @instance
+         */
+        Frame.prototype.method = 0;
+
+        /**
+         * Frame headers.
+         * @member {Array.<pbbp2.IHeader>} headers
+         * @memberof pbbp2.Frame
+         * @instance
+         */
+        Frame.prototype.headers = $util.emptyArray;
+
+        /**
+         * Frame payloadEncoding.
+         * @member {string} payloadEncoding
+         * @memberof pbbp2.Frame
+         * @instance
+         */
+        Frame.prototype.payloadEncoding = "";
+
+        /**
+         * Frame payloadType.
+         * @member {string} payloadType
+         * @memberof pbbp2.Frame
+         * @instance
+         */
+        Frame.prototype.payloadType = "";
+
+        /**
+         * Frame payload.
+         * @member {Uint8Array} payload
+         * @memberof pbbp2.Frame
+         * @instance
+         */
+        Frame.prototype.payload = $util.newBuffer([]);
+
+        /**
+         * Frame LogIDNew.
+         * @member {string} LogIDNew
+         * @memberof pbbp2.Frame
+         * @instance
+         */
+        Frame.prototype.LogIDNew = "";
+
+        /**
+         * Creates a new Frame instance using the specified properties.
+         * @function create
+         * @memberof pbbp2.Frame
+         * @static
+         * @param {pbbp2.IFrame=} [properties] Properties to set
+         * @returns {pbbp2.Frame} Frame instance
+         */
+        Frame.create = function create(properties) {
+            return new Frame(properties);
+        };
+
+        /**
+         * Encodes the specified Frame message. Does not implicitly {@link pbbp2.Frame.verify|verify} messages.
+         * @function encode
+         * @memberof pbbp2.Frame
+         * @static
+         * @param {pbbp2.IFrame} message Frame message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        Frame.encode = function encode(message, writer) {
+            if (!writer)
+                writer = $Writer.create();
+            writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.SeqID);
+            writer.uint32(/* id 2, wireType 0 =*/16).uint64(message.LogID);
+            writer.uint32(/* id 3, wireType 0 =*/24).int32(message.service);
+            writer.uint32(/* id 4, wireType 0 =*/32).int32(message.method);
+            if (message.headers != null && message.headers.length)
+                for (let i = 0; i < message.headers.length; ++i)
+                    $root.pbbp2.Header.encode(message.headers[i], writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim();
+            if (message.payloadEncoding != null && Object.hasOwnProperty.call(message, "payloadEncoding"))
+                writer.uint32(/* id 6, wireType 2 =*/50).string(message.payloadEncoding);
+            if (message.payloadType != null && Object.hasOwnProperty.call(message, "payloadType"))
+                writer.uint32(/* id 7, wireType 2 =*/58).string(message.payloadType);
+            if (message.payload != null && Object.hasOwnProperty.call(message, "payload"))
+                writer.uint32(/* id 8, wireType 2 =*/66).bytes(message.payload);
+            if (message.LogIDNew != null && Object.hasOwnProperty.call(message, "LogIDNew"))
+                writer.uint32(/* id 9, wireType 2 =*/74).string(message.LogIDNew);
+            return writer;
+        };
+
+        /**
+         * Encodes the specified Frame message, length delimited. Does not implicitly {@link pbbp2.Frame.verify|verify} messages.
+         * @function encodeDelimited
+         * @memberof pbbp2.Frame
+         * @static
+         * @param {pbbp2.IFrame} message Frame message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        Frame.encodeDelimited = function encodeDelimited(message, writer) {
+            return this.encode(message, writer).ldelim();
+        };
+
+        /**
+         * Decodes a Frame message from the specified reader or buffer.
+         * @function decode
+         * @memberof pbbp2.Frame
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @param {number} [length] Message length if known beforehand
+         * @returns {pbbp2.Frame} Frame
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        Frame.decode = function decode(reader, length) {
+            if (!(reader instanceof $Reader))
+                reader = $Reader.create(reader);
+            let end = length === undefined ? reader.len : reader.pos + length, message = new $root.pbbp2.Frame();
+            while (reader.pos < end) {
+                let tag = reader.uint32();
+                switch (tag >>> 3) {
+                case 1: {
+                        message.SeqID = reader.uint64();
+                        break;
+                    }
+                case 2: {
+                        message.LogID = reader.uint64();
+                        break;
+                    }
+                case 3: {
+                        message.service = reader.int32();
+                        break;
+                    }
+                case 4: {
+                        message.method = reader.int32();
+                        break;
+                    }
+                case 5: {
+                        if (!(message.headers && message.headers.length))
+                            message.headers = [];
+                        message.headers.push($root.pbbp2.Header.decode(reader, reader.uint32()));
+                        break;
+                    }
+                case 6: {
+                        message.payloadEncoding = reader.string();
+                        break;
+                    }
+                case 7: {
+                        message.payloadType = reader.string();
+                        break;
+                    }
+                case 8: {
+                        message.payload = reader.bytes();
+                        break;
+                    }
+                case 9: {
+                        message.LogIDNew = reader.string();
+                        break;
+                    }
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+                }
+            }
+            if (!message.hasOwnProperty("SeqID"))
+                throw $util.ProtocolError("missing required 'SeqID'", { instance: message });
+            if (!message.hasOwnProperty("LogID"))
+                throw $util.ProtocolError("missing required 'LogID'", { instance: message });
+            if (!message.hasOwnProperty("service"))
+                throw $util.ProtocolError("missing required 'service'", { instance: message });
+            if (!message.hasOwnProperty("method"))
+                throw $util.ProtocolError("missing required 'method'", { instance: message });
+            return message;
+        };
+
+        /**
+         * Decodes a Frame message from the specified reader or buffer, length delimited.
+         * @function decodeDelimited
+         * @memberof pbbp2.Frame
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @returns {pbbp2.Frame} Frame
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        Frame.decodeDelimited = function decodeDelimited(reader) {
+            if (!(reader instanceof $Reader))
+                reader = new $Reader(reader);
+            return this.decode(reader, reader.uint32());
+        };
+
+        /**
+         * Verifies a Frame message.
+         * @function verify
+         * @memberof pbbp2.Frame
+         * @static
+         * @param {Object.<string,*>} message Plain object to verify
+         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+         */
+        Frame.verify = function verify(message) {
+            if (typeof message !== "object" || message === null)
+                return "object expected";
+            if (!$util.isInteger(message.SeqID) && !(message.SeqID && $util.isInteger(message.SeqID.low) && $util.isInteger(message.SeqID.high)))
+                return "SeqID: integer|Long expected";
+            if (!$util.isInteger(message.LogID) && !(message.LogID && $util.isInteger(message.LogID.low) && $util.isInteger(message.LogID.high)))
+                return "LogID: integer|Long expected";
+            if (!$util.isInteger(message.service))
+                return "service: integer expected";
+            if (!$util.isInteger(message.method))
+                return "method: integer expected";
+            if (message.headers != null && message.hasOwnProperty("headers")) {
+                if (!Array.isArray(message.headers))
+                    return "headers: array expected";
+                for (let i = 0; i < message.headers.length; ++i) {
+                    let error = $root.pbbp2.Header.verify(message.headers[i]);
+                    if (error)
+                        return "headers." + error;
+                }
+            }
+            if (message.payloadEncoding != null && message.hasOwnProperty("payloadEncoding"))
+                if (!$util.isString(message.payloadEncoding))
+                    return "payloadEncoding: string expected";
+            if (message.payloadType != null && message.hasOwnProperty("payloadType"))
+                if (!$util.isString(message.payloadType))
+                    return "payloadType: string expected";
+            if (message.payload != null && message.hasOwnProperty("payload"))
+                if (!(message.payload && typeof message.payload.length === "number" || $util.isString(message.payload)))
+                    return "payload: buffer expected";
+            if (message.LogIDNew != null && message.hasOwnProperty("LogIDNew"))
+                if (!$util.isString(message.LogIDNew))
+                    return "LogIDNew: string expected";
+            return null;
+        };
+
+        /**
+         * Creates a Frame message from a plain object. Also converts values to their respective internal types.
+         * @function fromObject
+         * @memberof pbbp2.Frame
+         * @static
+         * @param {Object.<string,*>} object Plain object
+         * @returns {pbbp2.Frame} Frame
+         */
+        Frame.fromObject = function fromObject(object) {
+            if (object instanceof $root.pbbp2.Frame)
+                return object;
+            let message = new $root.pbbp2.Frame();
+            if (object.SeqID != null)
+                if ($util.Long)
+                    (message.SeqID = $util.Long.fromValue(object.SeqID)).unsigned = true;
+                else if (typeof object.SeqID === "string")
+                    message.SeqID = parseInt(object.SeqID, 10);
+                else if (typeof object.SeqID === "number")
+                    message.SeqID = object.SeqID;
+                else if (typeof object.SeqID === "object")
+                    message.SeqID = new $util.LongBits(object.SeqID.low >>> 0, object.SeqID.high >>> 0).toNumber(true);
+            if (object.LogID != null)
+                if ($util.Long)
+                    (message.LogID = $util.Long.fromValue(object.LogID)).unsigned = true;
+                else if (typeof object.LogID === "string")
+                    message.LogID = parseInt(object.LogID, 10);
+                else if (typeof object.LogID === "number")
+                    message.LogID = object.LogID;
+                else if (typeof object.LogID === "object")
+                    message.LogID = new $util.LongBits(object.LogID.low >>> 0, object.LogID.high >>> 0).toNumber(true);
+            if (object.service != null)
+                message.service = object.service | 0;
+            if (object.method != null)
+                message.method = object.method | 0;
+            if (object.headers) {
+                if (!Array.isArray(object.headers))
+                    throw TypeError(".pbbp2.Frame.headers: array expected");
+                message.headers = [];
+                for (let i = 0; i < object.headers.length; ++i) {
+                    if (typeof object.headers[i] !== "object")
+                        throw TypeError(".pbbp2.Frame.headers: object expected");
+                    message.headers[i] = $root.pbbp2.Header.fromObject(object.headers[i]);
+                }
+            }
+            if (object.payloadEncoding != null)
+                message.payloadEncoding = String(object.payloadEncoding);
+            if (object.payloadType != null)
+                message.payloadType = String(object.payloadType);
+            if (object.payload != null)
+                if (typeof object.payload === "string")
+                    $util.base64.decode(object.payload, message.payload = $util.newBuffer($util.base64.length(object.payload)), 0);
+                else if (object.payload.length >= 0)
+                    message.payload = object.payload;
+            if (object.LogIDNew != null)
+                message.LogIDNew = String(object.LogIDNew);
+            return message;
+        };
+
+        /**
+         * Creates a plain object from a Frame message. Also converts values to other types if specified.
+         * @function toObject
+         * @memberof pbbp2.Frame
+         * @static
+         * @param {pbbp2.Frame} message Frame
+         * @param {$protobuf.IConversionOptions} [options] Conversion options
+         * @returns {Object.<string,*>} Plain object
+         */
+        Frame.toObject = function toObject(message, options) {
+            if (!options)
+                options = {};
+            let object = {};
+            if (options.arrays || options.defaults)
+                object.headers = [];
+            if (options.defaults) {
+                if ($util.Long) {
+                    let long = new $util.Long(0, 0, true);
+                    object.SeqID = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
+                } else
+                    object.SeqID = options.longs === String ? "0" : 0;
+                if ($util.Long) {
+                    let long = new $util.Long(0, 0, true);
+                    object.LogID = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
+                } else
+                    object.LogID = options.longs === String ? "0" : 0;
+                object.service = 0;
+                object.method = 0;
+                object.payloadEncoding = "";
+                object.payloadType = "";
+                if (options.bytes === String)
+                    object.payload = "";
+                else {
+                    object.payload = [];
+                    if (options.bytes !== Array)
+                        object.payload = $util.newBuffer(object.payload);
+                }
+                object.LogIDNew = "";
+            }
+            if (message.SeqID != null && message.hasOwnProperty("SeqID"))
+                if (typeof message.SeqID === "number")
+                    object.SeqID = options.longs === String ? String(message.SeqID) : message.SeqID;
+                else
+                    object.SeqID = options.longs === String ? $util.Long.prototype.toString.call(message.SeqID) : options.longs === Number ? new $util.LongBits(message.SeqID.low >>> 0, message.SeqID.high >>> 0).toNumber(true) : message.SeqID;
+            if (message.LogID != null && message.hasOwnProperty("LogID"))
+                if (typeof message.LogID === "number")
+                    object.LogID = options.longs === String ? String(message.LogID) : message.LogID;
+                else
+                    object.LogID = options.longs === String ? $util.Long.prototype.toString.call(message.LogID) : options.longs === Number ? new $util.LongBits(message.LogID.low >>> 0, message.LogID.high >>> 0).toNumber(true) : message.LogID;
+            if (message.service != null && message.hasOwnProperty("service"))
+                object.service = message.service;
+            if (message.method != null && message.hasOwnProperty("method"))
+                object.method = message.method;
+            if (message.headers && message.headers.length) {
+                object.headers = [];
+                for (let j = 0; j < message.headers.length; ++j)
+                    object.headers[j] = $root.pbbp2.Header.toObject(message.headers[j], options);
+            }
+            if (message.payloadEncoding != null && message.hasOwnProperty("payloadEncoding"))
+                object.payloadEncoding = message.payloadEncoding;
+            if (message.payloadType != null && message.hasOwnProperty("payloadType"))
+                object.payloadType = message.payloadType;
+            if (message.payload != null && message.hasOwnProperty("payload"))
+                object.payload = options.bytes === String ? $util.base64.encode(message.payload, 0, message.payload.length) : options.bytes === Array ? Array.prototype.slice.call(message.payload) : message.payload;
+            if (message.LogIDNew != null && message.hasOwnProperty("LogIDNew"))
+                object.LogIDNew = message.LogIDNew;
+            return object;
+        };
+
+        /**
+         * Converts this Frame to JSON.
+         * @function toJSON
+         * @memberof pbbp2.Frame
+         * @instance
+         * @returns {Object.<string,*>} JSON object
+         */
+        Frame.prototype.toJSON = function toJSON() {
+            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+        };
+
+        /**
+         * Gets the default type url for Frame
+         * @function getTypeUrl
+         * @memberof pbbp2.Frame
+         * @static
+         * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+         * @returns {string} The default type url
+         */
+        Frame.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+            if (typeUrlPrefix === undefined) {
+                typeUrlPrefix = "type.googleapis.com";
+            }
+            return typeUrlPrefix + "/pbbp2.Frame";
+        };
+
+        return Frame;
+    })();
+
+    return pbbp2;
+})();
+
+const decode = (buffer) => {
+    return pbbp2.Frame.decode(buffer);
+};
+
+class WSConfig {
+    constructor() {
+        this.client = {
+            appId: '',
+            appSecret: '',
+            domain: exports.Domain.Feishu,
+        };
+        this.ws = {
+            connectUrl: '',
+            pingInterval: 120,
+            reconnectCount: -1,
+            reconnectInterval: 120,
+            reconnectNonce: 30,
+            deviceId: '',
+            serviceId: '',
+            autoReconnect: true
+        };
+        this.wsInstance = null;
+    }
+    updateClient(clientConfig) {
+        Object.assign(this.client, clientConfig);
+    }
+    updateWs(WSConfig) {
+        Object.assign(this.ws, WSConfig);
+    }
+    getClient(key) {
+        if (key === undefined) {
+            return this.client;
+        }
+        return this.client[key];
+    }
+    getWS(key) {
+        if (key === undefined) {
+            return this.ws;
+        }
+        return this.ws[key];
+    }
+    get wsConfigUrl() {
+        return `${this.getClient("domain")}/callback/ws/endpoint`;
+    }
+    setWSInstance(wsInstance) {
+        this.wsInstance = wsInstance;
+    }
+    getWSInstance() {
+        return this.wsInstance;
+    }
+}
+
+class DataCache {
+    constructor(params) {
+        this.cache = new Map();
+        this.logger = params.logger;
+        this.clearAtInterval();
+    }
+    mergeData(params) {
+        const { message_id, sum, seq, trace_id, data } = params;
+        const cache = this.cache.get(message_id);
+        if (!cache) {
+            const buffer = new Array(sum).fill(undefined);
+            buffer[seq] = data;
+            this.cache.set(message_id, {
+                buffer,
+                trace_id,
+                message_id,
+                create_time: Date.now()
+            });
+        }
+        else {
+            cache.buffer[seq] = data;
+        }
+        const mergedCache = this.cache.get(message_id);
+        if (mergedCache === null || mergedCache === void 0 ? void 0 : mergedCache.buffer.every(item => !!item)) {
+            const mergedBuffer = mergedCache.buffer.reduce((acc, cur) => {
+                const combined = new Uint8Array(acc.byteLength + cur.byteLength);
+                combined.set(acc, 0);
+                combined.set(cur, acc.length);
+                return combined;
+            }, new Uint8Array([]));
+            const string = new TextDecoder("utf-8").decode(mergedBuffer);
+            const data = JSON.parse(string);
+            this.deleteCache(message_id);
+            return data;
+        }
+        return null;
+    }
+    deleteCache(message_id) {
+        this.cache.delete(message_id);
+    }
+    clearAtInterval() {
+        // magic number，10s expired
+        const clearIntervalMs = 10000;
+        setInterval(() => {
+            const now = Date.now();
+            this.cache.forEach((value, key) => {
+                var _a;
+                const { create_time, trace_id, message_id } = value;
+                if (now - create_time > clearIntervalMs) {
+                    (_a = this.logger) === null || _a === void 0 ? void 0 : _a.debug(`${message_id} event data is deleted as expired, trace_id: ${trace_id}`);
+                    this.deleteCache(key);
+                }
+            });
+        }, clearIntervalMs);
+    }
+}
+
+var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode[ErrorCode["ok"] = 0] = "ok";
+    ErrorCode[ErrorCode["system_busy"] = 1] = "system_busy";
+    ErrorCode[ErrorCode["forbidden"] = 403] = "forbidden";
+    ErrorCode[ErrorCode["auth_failed"] = 514] = "auth_failed";
+    ErrorCode[ErrorCode["internal_error"] = 1000040343] = "internal_error";
+    ErrorCode[ErrorCode["exceed_conn_limit"] = 1000040350] = "exceed_conn_limit";
+})(ErrorCode || (ErrorCode = {}));
+var FrameType;
+(function (FrameType) {
+    FrameType[FrameType["control"] = 0] = "control";
+    FrameType[FrameType["data"] = 1] = "data";
+})(FrameType || (FrameType = {}));
+var HeaderKey;
+(function (HeaderKey) {
+    HeaderKey["type"] = "type";
+    HeaderKey["message_id"] = "message_id";
+    HeaderKey["sum"] = "sum";
+    HeaderKey["seq"] = "seq";
+    HeaderKey["trace_id"] = "trace_id";
+    HeaderKey["biz_rt"] = "biz_rt";
+    HeaderKey["handshake_status"] = "handshake-status";
+    HeaderKey["handshake_msg"] = "handshake-msg";
+    HeaderKey["handshake_autherrcode"] = "handshake-autherrcode";
+})(HeaderKey || (HeaderKey = {}));
+var MessageType;
+(function (MessageType) {
+    MessageType["event"] = "event";
+    MessageType["card"] = "card";
+    MessageType["ping"] = "ping";
+    MessageType["pong"] = "pong";
+})(MessageType || (MessageType = {}));
+
+class WSClient {
+    constructor(params) {
+        this.wsConfig = new WSConfig();
+        const { appId, appSecret, domain = exports.Domain.Feishu, httpInstance = defaultHttpInstance, loggerLevel = exports.LoggerLevel.info, logger = defaultLogger, autoReconnect = true } = params;
+        this.logger = new LoggerProxy(loggerLevel, logger);
+        assert(!appId, () => this.logger.error('appId is needed'));
+        assert(!appSecret, () => this.logger.error('appSecret is needed'));
+        this.dataCache = new DataCache({ logger: this.logger });
+        this.httpInstance = httpInstance;
+        this.wsConfig.updateClient({
+            appId,
+            appSecret,
+            domain: formatDomain(domain),
+        });
+        this.wsConfig.updateWs({
+            autoReconnect
+        });
+    }
+    pullConnectConfig() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { appId, appSecret } = this.wsConfig.getClient();
+            try {
+                const { code, data: { URL, ClientConfig }, msg } = yield this.httpInstance.request({
+                    method: "post",
+                    url: this.wsConfig.wsConfigUrl,
+                    data: {
+                        AppID: appId,
+                        AppSecret: appSecret
+                    },
+                    // consumed by gateway
+                    headers: {
+                        "locale": "zh",
+                    }
+                });
+                if (code !== ErrorCode.ok) {
+                    this.logger.error('[ws]', `code: ${code}, ${code === ErrorCode.system_busy ? msg : 'system busy'}`);
+                    if (code === ErrorCode.system_busy || code === ErrorCode.internal_error) {
+                        return false;
+                    }
+                }
+                const { device_id, service_id } = qs__default["default"].parse(URL);
+                this.wsConfig.updateWs({
+                    connectUrl: URL,
+                    deviceId: device_id,
+                    serviceId: service_id,
+                    pingInterval: ClientConfig.PingInterval,
+                    reconnectCount: ClientConfig.ReconnectCount,
+                    reconnectInterval: ClientConfig.ReconnectInterval,
+                    reconnectNonce: ClientConfig.ReconnectNonce
+                });
+                this.logger.debug('[ws]', `get connect config success, ws url: ${URL}`);
+                return true;
+            }
+            catch (e) {
+                this.logger.error('[ws]', get__default["default"](e, 'message', 'system busy'));
+                return false;
+            }
+        });
+    }
+    connect() {
+        const connectUrl = this.wsConfig.getWS('connectUrl');
+        const wsInstance = new WebSocket__default["default"](connectUrl);
+        return new Promise((resolve) => {
+            wsInstance.on('open', () => {
+                this.logger.debug('[ws]', 'ws connect success');
+                this.wsConfig.setWSInstance(wsInstance);
+                this.pingLoop();
+                resolve(true);
+            });
+            wsInstance.on('error', () => {
+                this.logger.error('[ws]', 'ws connect failed');
+                resolve(false);
+            });
+        });
+    }
+    reConnect(isStart = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tryConnect = () => {
+                return this.pullConnectConfig()
+                    .then(isSuccess => isSuccess ? this.connect() : Promise.resolve(false))
+                    .then(isSuccess => {
+                    if (isSuccess) {
+                        this.communicate();
+                        return Promise.resolve(true);
+                    }
+                    return Promise.resolve(false);
+                });
+            };
+            if (isStart) {
+                const isSuccess = yield tryConnect();
+                if (!isSuccess) {
+                    this.logger.error('[ws]', 'connect failed');
+                    yield this.reConnect();
+                }
+                this.logger.info('[ws]', 'ws client ready');
+                return;
+            }
+            const wsInstance = this.wsConfig.getWSInstance();
+            const { autoReconnect, reconnectNonce, reconnectCount, reconnectInterval } = this.wsConfig.getWS();
+            if (!autoReconnect) {
+                return;
+            }
+            this.logger.info('[ws]', 'reconnect');
+            if (wsInstance) {
+                wsInstance === null || wsInstance === void 0 ? void 0 : wsInstance.terminate();
+            }
+            this.wsConfig.setWSInstance(null);
+            setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                (function loopReConnect(count) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        count++;
+                        const isSuccess = yield tryConnect();
+                        // if reconnectCount < 0, the reconnect time is infinite
+                        if (isSuccess) {
+                            this.logger.debug('[ws]', 'reconnect success');
+                            return;
+                        }
+                        this.logger.info('ws', `unable to connect to the server after trying ${count} times")`);
+                        if (reconnectCount >= 0 && count >= reconnectCount) {
+                            return;
+                        }
+                        setTimeout(() => {
+                            loopReConnect.bind(this)(count);
+                        }, reconnectInterval);
+                    });
+                }).bind(this)(0);
+            }), reconnectNonce ? reconnectNonce * Math.random() : 0);
+        });
+    }
+    pingLoop() {
+        const { serviceId, pingInterval } = this.wsConfig.getWS();
+        const wsInstance = this.wsConfig.getWSInstance();
+        if ((wsInstance === null || wsInstance === void 0 ? void 0 : wsInstance.readyState) === WebSocket__default["default"].OPEN) {
+            const frame = {
+                headers: [{
+                        key: HeaderKey.type,
+                        value: MessageType.ping
+                    }],
+                service: Number(serviceId),
+                method: FrameType.control,
+                SeqID: 0,
+                LogID: 0
+            };
+            this.sendMessage(frame);
+            this.logger.trace('[ws]', 'ping success');
+        }
+        setTimeout(this.pingLoop.bind(this), pingInterval);
+    }
+    communicate() {
+        const wsInstance = this.wsConfig.getWSInstance();
+        wsInstance === null || wsInstance === void 0 ? void 0 : wsInstance.on('message', (buffer) => __awaiter(this, void 0, void 0, function* () {
+            const data = decode(buffer);
+            const { method } = data;
+            if (method === FrameType.control) {
+                yield this.handleControlData(data);
+            }
+            if (method === FrameType.data) {
+                yield this.handleEventData(data);
+            }
+        }));
+        wsInstance === null || wsInstance === void 0 ? void 0 : wsInstance.on('error', (e) => {
+            this.logger.error('[ws]', 'ws error');
+        });
+        wsInstance === null || wsInstance === void 0 ? void 0 : wsInstance.on('close', () => {
+            this.logger.debug('[ws]', 'client closed');
+            this.reConnect();
+        });
+    }
+    handleControlData(data) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const type = (_a = data.headers.find(item => item.key === HeaderKey.type)) === null || _a === void 0 ? void 0 : _a.value;
+            const payload = data.payload;
+            if (type === MessageType.ping) {
+                return;
+            }
+            if (type === MessageType.pong && payload) {
+                this.logger.trace('[ws]', 'receive pong');
+                const dataString = new TextDecoder("utf-8").decode(payload);
+                const { PingInterval, ReconnectCount, ReconnectInterval, ReconnectNonce } = JSON.parse(dataString);
+                this.wsConfig.updateWs({
+                    pingInterval: PingInterval,
+                    reconnectCount: ReconnectCount,
+                    reconnectInterval: ReconnectInterval,
+                    reconnectNonce: ReconnectNonce,
+                });
+                this.logger.trace('[ws]', 'update wsConfig with pong data');
+            }
+        });
+    }
+    handleEventData(data) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const headers = data.headers.reduce((acc, cur) => {
+                acc[cur.key] = cur.value;
+                return acc;
+            }, {});
+            const { message_id, sum, seq, type, trace_id } = headers;
+            const payload = data.payload;
+            if (type !== MessageType.event) {
+                return;
+            }
+            const mergedData = this.dataCache.mergeData({
+                message_id,
+                sum: Number(sum),
+                seq: Number(seq),
+                trace_id,
+                data: payload
+            });
+            if (!mergedData) {
+                return;
+            }
+            this.logger.debug('[ws]', `receive message, message_type: ${type}; message_id: ${message_id}; trace_id: ${trace_id}; data: ${mergedData.data}`);
+            const startTime = Date.now();
+            yield ((_a = this.eventDispatcher) === null || _a === void 0 ? void 0 : _a.invoke(mergedData, { needCheck: false }));
+            const endTime = Date.now();
+            this.sendMessage(Object.assign(Object.assign({}, data), { headers: [...data.headers, { key: HeaderKey.biz_rt, value: String(startTime - endTime) }], payload: new TextEncoder().encode(JSON.stringify({
+                    // http code
+                    code: 200
+                })) }));
+        });
+    }
+    sendMessage(data) {
+        var _a;
+        const wsInstance = this.wsConfig.getWSInstance();
+        if ((wsInstance === null || wsInstance === void 0 ? void 0 : wsInstance.readyState) === WebSocket__default["default"].OPEN) {
+            const resp = pbbp2.Frame.encode(data).finish();
+            (_a = this.wsConfig.getWSInstance()) === null || _a === void 0 ? void 0 : _a.send(resp, (err) => {
+                if (err) {
+                    this.logger.error('[ws]', 'send data failed');
+                }
+            });
+        }
+    }
+    start(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.info('[ws]', `receive events through persistent connection only available in self-build & Feishu app, Configured in:
+        Developer Console(开发者后台) 
+          ->
+        Events and Callbacks(事件配置)
+          -> 
+        Mode of event subscription(配置订阅方式)
+          -> 
+        Receive events through persistent connection(使用长连接接收事件)`);
+            const { eventDispatcher } = params;
+            if (!eventDispatcher) {
+                this.logger.warn('[ws]', 'client need to start with a eventDispatcher');
+                return;
+            }
+            this.eventDispatcher = eventDispatcher;
+            this.reConnect(true);
+        });
+    }
+}
+
 exports.AESCipher = AESCipher;
 exports.CAppTicket = CAppTicket;
 exports.CTenantAccessToken = CTenantAccessToken;
 exports.CardActionHandler = CardActionHandler;
 exports.Client = Client;
 exports.EventDispatcher = EventDispatcher;
+exports.WSClient = WSClient;
 exports.adaptDefault = adaptDefault;
 exports.adaptExpress = adaptExpress;
 exports.adaptKoa = adaptKoa;