@havue/solutions 1.1.2 → 1.2.1

package/dist/types/bc-connect/src/manager.d.ts

@@ -1,63 +1,71 @@
-/** 事件数据类型 */
+/** 事件数据类型 | Event Datatypes */
 export type BcConnectSendMessageType = {
-    /** 事件类型 */
+    /** 事件类型 | type */
     type: string;
-    /** 数据 */
+    /** 数据 | data */
     data: any;
-    /** 发送事件的实例id */
+    /** 发送事件的实例id | BroadcastChannelManager instance id */
     id: number;
-    /** 消息是发送给目标实例id的 */
+    /** 此消息的目标实例id | The target instance id for this message */
     targetId?: number;
 };
-/** 事件类型 */
+/** 事件类型 | Event types */
 export declare enum BcConnectEventTypeEnum {
-    /** 初始广播 */
-    Broadcast = "Hello world",
-    /** 回复初始广播 */
-    Broadcast_Reply = "I can hear you",
-    /** 主节点心跳 */
-    Main_Node_Hearbeat = "\u82CD\u5929\u8FD8\u5728\uFF0C\u522B\u7ACB\u9EC4\u5929",
-    /** 回复主节点心跳 */
-    Res_Main_Node_Hearbeat = "\u82CD\u5929\u5728\u4E0A\uFF0C\u53D7\u6211\u4E00\u62DC",
-    /** 长时间未收到主节点心跳，我想当主节点，你们同意吗 */
-    Req_Be_Main_Node = "\u82CD\u5929\u5DF2\u6B7B\uFF0C\u9EC4\u5929\u5F53\u7ACB",
-    /** 排资论辈，我应是主节点，不同意 */
-    Res_Be_Main_Node = "\u6211\u662F\u9EC4\u5929\uFF0C\u5C14\u7B49\u9000\u4E0B",
-    /** 当前BC节点类型更改 */
-    Node_Type_Change = "node type change",
-    /** 其他标签页BC节点id列表更新 */
-    Friend_List_Update = "friend list update"
+    /** 初始广播 | Initial broadcast */
+    Broadcast = "__BCM_INIT__",
+    /** 回复初始广播 | Reply to initial broadcast */
+    Broadcast_Reply = "__BCM_INIT_REPLY__",
+    /** 主节点心跳 | Master node heartbeat */
+    Main_Node_Hearbeat = "__BCM_MAIN_NODE_HEARBEAT__",
+    /** 回复主节点心跳 | Reply to the master node heartbeat */
+    Res_Main_Node_Hearbeat = "__BCM_MAIN_NODE_HEARBEAT_REPLY__",
+    /**
+     * 长时间未收到主节点心跳，申请成为主节点
+     * It has not received the heartbeat of the master node for a long time.
+     *  Apply to become the master node
+     */
+    Req_Be_Main_Node = "__BCM_REQ_BE_MAIN_NODE__",
+    /** 拒绝其他节点成为主节点 | Reject other nodes as master nodes */
+    Res_Be_Main_Node = "__BCM_REQ_BE_MAIN_NODE_REJECT__",
+    /** 当前节点类型更改 | The current node type has changed */
+    Node_Type_Change = "__BCM_NODE_TYPE_CHANGE__",
+    /** 其他标签页BC节点id列表更新 | Other TAB node id list updated */
+    Friend_List_Update = "__BCM_FRIEND_LIST_UPDATE__"
 }
-/** 当前webview BroadcastChannel节点类型 */
+/** BroadcastChannel节点类型 | BroadcastChannel node type */
 export declare enum BcConnectNodeTypeEnum {
     Main = "main",
     Normal = "normal"
 }
 /**
  * 使用BroadcastChannel与其他标签页进行通信
+ * Use BroadcastChannel to communicate with other tabs
  */
 export declare class BroadcastChannelManager {
-    /** 通道名称 */
+    /** 通道名称 | Channel name */
     private _bcName;
-    /** BroadcastChannel实例 */
+    /** BroadcastChannel instance */
     private _broadcastChannel;
-    /** 事件map */
+    /** Event map */
     private _eventMap;
-    /** 主节点发送心跳的interval */
+    /** 主节点发送心跳的interval | The interval at which the master node sends the heartbeat */
     private _mainNodeMsgInterval;
-    /** 认为主节点掉线的timeout */
+    /** 认为主节点掉线的timeout | timeout to consider the primary node to be offline */
     private _mainNodeMsgTimeoutTimer;
-    /** 更新友方列表的timeout */
+    /** 更新友方列表的timeout | Update the timeout of the friend list */
     private _updateFriendListTimer;
-    /** 当前实例id */
+    /** 当前实例id | Current instance id */
     id: number;
-    /** 记录的友方id数组 */
+    /** 其他广播通道id列表 | List of other broadcast channel ids */
     private _oldFrendChannelIdList;
-    /** 正在更新的右方id数组 */
+    /** 正在更新的id数组 | The id array being updated */
     private _friendChannelIdSet;
-    /** 当前节点类型 */
+    /** 当前节点类型 | Current node type */
     private _nodeType;
-    /** 是否开启调试模式，会在控制台打印相关信息 */
+    /**
+     * 是否开启调试模式，会在控制台打印相关信息
+     * If debug mode is enabled, it will print information to the console
+     */
     private _debug;
     constructor(name: string, debug?: boolean);
     get nodeType(): BcConnectNodeTypeEnum | undefined;
@@ -65,73 +73,73 @@ export declare class BroadcastChannelManager {
     connect(): void;
     close(): void;
     /**
-     * 切换节点类型
+     * 切换节点类型 | Switching node type
      * @param {BcConnectNodeTypeEnum} type
      * @returns
      */
     private _setNodeType;
-    /** 更新友方列表 */
+    /** 更新广播id列表 | Update the list of broadcast ids */
     private _updateFriendList;
-    /** 绑定事件 */
+    /** 绑定事件 | Bind event */
     private _bindBroadcastChannelEvent;
-    /** 监听节点类型切换事件 */
+    /** 监听节点类型切换事件 |  */
     private _bindNodeEvent;
-    /** 获取最新的友方列表 */
+    /** 获取最新的节点列表 | Get the latest node list */
     private _getNewFriendList;
     /**
-     * 更新当前节点类型
+     * 更新当前节点类型 | Update the current node type
      */
     private _updataNodeType;
     private _timeoutToBeMainNode;
     /**
-     * 保持记录的活跃的友方id列表
-     * 清空正在记录的友方id列表
+     * 保存最新的节点列表到_oldFrendChannelIdList，清空_friendChannelIdSet
+     * Save the latest node list to _oldFrendChannelIdList and clear _friendChannelIdSet
      */
     private _catchOldFriend;
     /**
-     * 申请成为主节点
+     * 申请成为主节点 | Apply to be a master node
      */
     private _req_beMainNode;
     /**
-     * 添加友方
-     * @param id 节点id
+     * add node
+     * @param id id
      */
     _addFriend(id: number): void;
     /**
-     * 广播消息
-     * @param type 消息类型
-     * @param data 数据
+     * 广播消息 | Send Broadcast message
+     * @param type 消息类型 | Message type
+     * @param data 数据 | data
      */
     send(type: string, data?: any): void;
     /**
-     * 给特定id的节点发送消息
-     * @param type 消息类型
-     * @param targetId 目标节点id
-     * @param data 数据
+     * 给特定id的节点发送消息 | Send a message to a node with a specific id
+     * @param type 消息类型 | Message type
+     * @param targetId 目标节点id | Target Node id
+     * @param data 数据 | data
      */
     sendToTarget(type: string, targetId: number, data?: any): void;
     /**
-     * 注册事件
-     * @param { string } event 事件类型
-     * @param callback 回调
+     * 注册事件 | Registering events
+     * @param { string } event 事件类型 | Event type
+     * @param callback 回调 | callback
      * @returns void
      */
     on(event: string, callback: (_: BcConnectSendMessageType) => void): void;
     /**
-     * 注销事件
-     * @param { string } event 事件类型
-     * @param callback 事件回调
+     * 注销事件 | Remove events
+     * @param { string } event 事件类型 | Event type
+     * @param callback 事件回调 | callback
      * @returns
      */
     off(event: string, callback?: (_: BcConnectSendMessageType) => void): void;
     /**
-     * 触发事件
-     * @param { string } event 事件类型
-     * @param data 数据
+     * 触发事件 | Triggering events
+     * @param { string } event 事件类型 | Event type
+     * @param data 数据 | data
      */
     emit(event: string, data: BcConnectSendMessageType): void;
     /**
-     * 销毁
+     * 销毁 | destroy
      */
     destroy(): void;
 }

package/dist/types/ws-video-manager/src/loader/websocket-loader.d.ts

@@ -1,25 +1,28 @@
-/** 心跳配置 */
+/** 心跳配置 | Heartbeat configuration */
 type HeartbeatConfigType = {
-    /** 只发送一次 */
+    /** 只发送一次 | Only send it once */
     once: boolean;
-    /** 心跳消息 */
+    /** 心跳消息 | Heartbeat message */
     message: string;
-    /** 时间间隔 */
+    /** 心跳间隔 | Interval of heartbeat */
     interval?: number;
 };
-/** 重连配置 */
+/** 重连配置 | Reconnect configuration */
 type InterruptConfigType = {
-    /** 是否重连 */
+    /** 是否重连 | Reconnect or not */
     reconnect: boolean;
-    /** 最大重连次数 */
+    /** 最大重连次数 | Maximum number of reconnections */
     maxReconnectTimes: number;
-    /** 每次重连延时 */
+    /** 每次重连延时 | Delay per reconnection */
     delay: number;
 };
 export type WebSocketOptionsType = {
-    /** WebSocket 子协议 WebSocket(url: string, protocols: string | string[]) */
+    /** WebSocket subprotocol: WebSocket(url: string, protocols: string | string[]) */
     protocols?: string | string[];
-    /** WebSocket 连接所传输二进制数据的类型 */
+    /**
+     * WebSocket 连接接收的二进制数据类型
+     *  the type of binary data being received over the WebSocket connection
+     */
     binaryType?: WebSocket['binaryType'];
     heartbeat?: HeartbeatConfigType;
     interrupt?: InterruptConfigType;

package/dist/types/ws-video-manager/src/manager/index.d.ts

@@ -3,21 +3,31 @@ import type { RenderConstructorOptionType, VideoInfo } from '../render';
 import { EventBus } from '@havue/shared';
 import { RenderEventsEnum, AudioState, VideoState } from '../render';
 export type WsVideoManaCstorOptionType = {
-    /** 预监流连接数量限制, 移动端默认10个，pc端默认32个 */
+    /**
+     * websocket流连接数量限制, 移动端默认10个，pc端默认32个
+     * Limit the number of websocket streaming connections to 10 by default for mobile and 32 by default for pc
+     */
     connectLimit?: number;
-    /** WebSocketLoader 实例配置 */
+    /** WebSocketLoader configuration */
     wsOptions?: WebSocketOptionsType;
     /**
      * websocket重连时，重新解析视频编码方式，
      * 默认 true
+     *
+     * When the websocket reconnects, the video encoding is reparsed.
+     * The default is true
      */
     reparseMimeOnReconnect?: boolean;
     /** Render 实例配置 */
     renderOptions?: Partial<RenderConstructorOptionType>;
     /**
-     * 是否使用WebGL，
-     * 默认 false，
-     * WebGL在不同游览器，以及受限于显存，不能同时创建过多WebGL上下文，一般8-16个 */
+     * 是否使用WebGL，默认 false，
+     * WebGL在不同游览器，以及受限于显存，不能同时创建过多WebGL上下文，一般8-16个
+     *
+     * Whether to use WebGL, false by default,
+     * WebGL can not be created too many WebGL contexts at the same time in different browsers,
+     *  and due to the limitations of video memory, usually 8-16 WebGL contexts
+     */
     useWebgl?: boolean;
 };
 export declare enum EventEnums {
@@ -35,7 +45,7 @@ type Events = {
 };
 export declare const WsVideoManagerEventEnums: typeof EventEnums & typeof RenderEventsEnum;
 export declare class WsVideoManager extends EventBus<Events> {
-    /** socket连接 渲染相关对应信息 */
+    /** socket相关信息map | map of socket information */
     private _wsInfoMap;
     private _option;
     private _reqAnimationID;
@@ -44,100 +54,107 @@ export declare class WsVideoManager extends EventBus<Events> {
     get connectLimit(): number;
     private _setAnimate;
     /**
-     * 添加socket实例
-     * @param url socket地址
+     * 添加socket连接 | Adding a socket connection
+     * @param url socket url
      * @returns
      */
     private _addSocket;
     /**
-     * 绑定render事件
-     * @param url 连接地址
-     * @param render Render实例
+     * 绑定render事件 | Binding the render event
+     * @param url 连接地址 | websocket url
+     * @param render Render instance
      */
     private _bindRenderEvent;
     /**
-     * 销毁socket实例
-     * @param url socket地址
+     * Destroying the socket connect
+     * @param url socket url
      */
     private _removeSocket;
     /**
-     * 绑定socket事件
-     * @param url 连接地址
-     * @param socket WebSocketLoader实例
+     * 绑定socket事件 | Binding socket events
+     * @param url websocket url
+     * @param socket WebSocketLoader instance
      */
     private _bindSocketEvent;
     private _emitWsUrlListChange;
     /**
-     * url对应的 socket实例是否已存在
-     * @param url socket地址
+     * url对应的 socket实例是否已存在 | Whether the socket instance for the url already exists
+     * @param url websocket url
      * @returns boolean
      */
     private _isSocketExist;
     /**
      * 添加url对应socket，以及需要绘制的canvas元素
-     * @param canvas canvas元素
-     * @param url socket url地址
+     * Add the socket for the url and the canvas element to draw
+     * @param canvas canvas
+     * @param url websocket url
      */
     addCanvas(canvas: HTMLCanvasElement, url: string, renderOptions?: Partial<RenderConstructorOptionType>): void;
     /**
-     * 初始化canvas背景
-     * @param canvas canvas元素
+     * 初始化canvas背景 | Initialize the canvas background
+     * @param canvas canvas
      * @returns
      */
     /**
-     * 删除canvas元素
-     * @param canvas canvas元素
+     * 删除canvas元素 || Remove the canvas element
+     * @param canvas canvas
      */
     removeCanvas(canvas: HTMLCanvasElement): void;
     /**
-     * 返回canvas是否已经添加过
-     * @param canvas canvas元素
+     * 获取canvas是否已经添加过 | Gets whether the canvas has already been added
+     * @param canvas canvas
      * @returns boolean
      */
     isCanvasExist(canvas: HTMLCanvasElement): boolean;
-    /** 设置全部render静音状态 */
+    /** 设置全部render静音状态 | Mute all render */
     setAllVideoMutedState(muted: boolean): void;
-    /** 更新单个render实例的配置 */
+    /** 更新单个render实例的配置 | Update the configuration of a single render instance */
     updateRenderOptions(url: string, options?: Partial<RenderConstructorOptionType>): void;
     /**
-     * 设置单个render静音状态
+     * 设置单个render静音状态 | Set a single render to be silent
      * @param url
-     * @param muted boolean 是否静音
+     * @param {boolean} muted  是否静音 | Muted or not
      */
     setOneMutedState(url: string, muted: boolean): void;
     /**
      * 获取url对应render video元素是否静音
-     * @param url socket地址
+     * Gets whether the render video element of the url is muted
+     * @param url websocket url
      */
     getOneMutedState(url: string): boolean;
     /**
      * 单个解除静音，其他未静音的变成静音，只播放一个
-     * @param url socket地址
+     * Unmute a single video and mute all other videos
+     * @param url websocket url
      */
     playOneAudio(url: string): void;
     /**
      * 设置单个render是否继续处理ws数据
+     * Sets whether a single render continues to process ws data
      * @param url
      */
     setOneVideoPausedState(url: string, paused: boolean): void;
-    /** 设置全部render是否继续处理ws数据 */
+    /** 设置全部render是否继续处理ws数据 | Sets whether all render continues to process ws data */
     setAllVideoPausedState(paused: boolean): void;
     /**
-     * 获取url对应render video元素是否继续播放
-     * @param url socket地址
+     * 获取url对应render video元素的播放状态
+     * Get the playback status of the render video element corresponding to the url
+     * @param url websocket url
      */
     getOneVideoPausedState(url: string): boolean;
     /**
      * 单个视频继续播放，其他暂停处理数据
-     * @param url socket地址
+     * A single video continues to play while others pause to process data
+     * @param url websocket url
      */
     playOneVideo(url: string): void;
     /**
      * 刷新socket，以及播放时间
+     * Refresh the socket, and the playback time
      */
     refresh(url?: string): void;
     /**
-     * 销毁
+     * 销毁 | Destroy
      */
     destroy(): void;
 }

package/dist/types/ws-video-manager/src/render/drawer.d.ts

@@ -1,5 +1,5 @@
 /**
- * 绘制视频到canvas中
+ * 绘制视频到canvas中 | Draw video into canvas
  */
 declare class CanvasDrawer {
     private _canvas;
@@ -17,27 +17,27 @@ declare class CanvasDrawer {
     constructor(canvas: HTMLCanvasElement, useWebgl?: boolean);
     private init2d;
     /**
-     * 初始化 webgl
+     * 初始化 webgl | Initialize webgl
      */
     private initGl;
     /**
-     * 创建着色器源码
+     * 创建着色器源码 | Create shader source code
      */
     private createShaderSource;
     /**
-     * 创建着色器
+     * 创建着色器 | Create shaders
      */
     private createShader;
     /**
-     * 创建着色器程序
+     * 创建着色器程序 | Create program
      */
     private createProgram;
     /**
-     * 绘制
+     * 绘制 | draw
      */
     draw(video: HTMLVideoElement): void;
     /**
-     * 销毁
+     * 销毁 | Destroy
      */
     destroy(): void;
 }

package/dist/types/ws-video-manager/src/render/index.d.ts

@@ -1,10 +1,20 @@
 import { EventBus } from '@havue/shared';
 export type RenderConstructorOptionType = {
-    /** 当前播放currentTime和最新视频时长最多相差 秒数，默认0.3s */
+    /**
+     * 当前播放currentTime和最新视频时长最多相差 秒数，默认0.3s
+     * The delay of currentTime relative to the latest video duration is 0.3s by default
+     */
     liveMaxLatency: number;
-    /** 最多缓存ws传输的未处理的buffer数据大小, 默认200kb */
+    /**
+     * 最多缓存ws传输的未处理的buffer数据大小, 默认200kb。
+     * The maximum amount of unprocessed buffer data to be cached for websocket transfers.
+     * 200kb by default
+     */
     maxCacheBufByte: number;
-    /** 最多存储的时间，用于清除在currentTime之前x秒时间节点前的buffer数据, 默认10s */
+    /**
+     * 最多存储的时间，用于清除在currentTime之前x秒时间节点前的buffer数据, 默认10s
+     * The maximum amount of time used to clear the buffer before a time node x seconds before currentTime (default 10s)
+     */
     maxCache: number;
 };
 export declare const WS_VIDEO_RENDER_DEFAULT_OPTIONS: Readonly<{
@@ -35,29 +45,32 @@ export type RenderEvents = {
     [RenderEventsEnum.VIDEO_INFO_UPDATE]: (info: VideoInfo) => void;
 };
 export declare class Render extends EventBus<RenderEvents> {
-    /** video元素 */
+    /** video元素 | videw element */
     private _videoEl;
-    /** mp4box 实例 */
+    /** mp4box file */
     private _mp4box;
-    /** mp4box onFragment获取的视频数据buffer数组 */
+    /**
+     * mp4box onFragment获取的视频数据buffer数组
+     * mp4box onFragment gets a buffer array of audio and video data
+     */
     private _audioBufsQueue;
     private _videoBufsQueue;
-    /** MediaSource 实例 */
+    /** MediaSource instance */
     private _mediaSource;
-    /** SourceBuffer 实例 */
+    /** SourceBuffer instance */
     private _audioSourceBuffer;
     private _videoSourceBuffer;
     private _audioTrackId;
     private _videoTrackId;
-    /** 用于MediaSource的mimeType */
+    /** 用于MediaSource的mimeType | mime type of the video */
     private _mimeType;
     private _audioMimeType;
     private _videoMimeType;
-    /** 是否暂停播放 */
+    /** 是否暂停播放 | Pause or not */
     private _paused;
     private _options;
     private _cacheAnimationID;
-    /** fmp4初始化片段是否已经添加 */
+    /** fmp4初始化片段是否已经添加 | fmp4 Initializes whether the fragment has been added */
     private _isAudioInitSegmentAdded;
     private _isVideoInitSegmentAdded;
     private _offset;
@@ -67,51 +80,54 @@ export declare class Render extends EventBus<RenderEvents> {
     set paused(paused: boolean);
     get paused(): boolean;
     get videoEl(): HTMLVideoElement | undefined;
-    /** 更新实例配置 */
+    /** 更新实例配置 | Update configuration */
     updateOptions(option?: Partial<RenderConstructorOptionType>): void;
     /**
-     * 添加视频流buffer数据
+     * 添加视频流buffer数据 | Add video stream buffer data
      * @param buf
      */
     appendMediaBuffer(bufs: Array<ArrayBuffer & {
         fileStart: number;
     }>): void;
     /**
-     * mp4box解析完成
-     * @param info mp4box解析信息
+     * mp4box解析完成 | handle Mp4box onReady
+     * @param info mp4box解析信息 | mp4box parses the information
      */
     private _onMp4boxReady;
     private _onSegment;
     /**
-     * 初始化视频元素
+     * 初始化视频元素 | Initialize the video element
      */
     private _setupVideo;
     /**
      * 是否支持Media Source Extention
+     * whether Media Source Extention is supported
      * @returns boolean
      */
     isSupportMSE(): boolean;
     /**
-     * 初始化MSE
+     * 初始化MSE | Init MSE
      * @returns
      */
     private _setupMSE;
     private _setupSourceBuffer;
     /**
      * 将_bufsQueue中的数据添加到SourceBuffer中
+     * Add the data from _bufsQueue to the SourceBuffer
      * @returns
      */
     private _cache;
     /**
      * 刷新播放时间为最新
+     * Refresh the playback time to the latest
      */
     refresh(): void;
-    /** 重置解析的视频mime type */
+    /** 重置解析的视频mime type | Reset the parsed video mime type */
     resetMimeType(): void;
     private destroyMediaSource;
     destroyMp4box(): void;
     /**
-     * 销毁
+     * 销毁 | Destroy
      */
     destroy(): void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@havue/solutions",
-  "version": "1.1.2",
+  "version": "1.2.1",
   "description": "Javascript class for special scene",
   "keywords": [
     "havue",
@@ -17,9 +17,9 @@
   },
   "dependencies": {
     "lodash": "^4.17.21",
-    "@havue/shared": "^1.1.2",
-    "@havue/bc-connect": "^1.1.2",
-    "@havue/ws-video-manager": "^1.1.2"
+    "@havue/shared": "^1.2.1",
+    "@havue/bc-connect": "^1.2.1",
+    "@havue/ws-video-manager": "^1.2.1"
   },
   "publishConfig": {
     "access": "public",

package/vite.config.ts

@@ -1,4 +1,4 @@
 import { defineConfig } from 'vite'
-import { getConfig } from '../../internal/build/src'
+import { getConfig } from '@havue/build'
 
 export default defineConfig(({ mode }) => getConfig(mode))

package/ws-video-manager/dist/types/src/loader/websocket-loader.d.ts

@@ -1,25 +1,28 @@
-/** 心跳配置 */
+/** 心跳配置 | Heartbeat configuration */
 type HeartbeatConfigType = {
-    /** 只发送一次 */
+    /** 只发送一次 | Only send it once */
     once: boolean;
-    /** 心跳消息 */
+    /** 心跳消息 | Heartbeat message */
     message: string;
-    /** 时间间隔 */
+    /** 心跳间隔 | Interval of heartbeat */
     interval?: number;
 };
-/** 重连配置 */
+/** 重连配置 | Reconnect configuration */
 type InterruptConfigType = {
-    /** 是否重连 */
+    /** 是否重连 | Reconnect or not */
     reconnect: boolean;
-    /** 最大重连次数 */
+    /** 最大重连次数 | Maximum number of reconnections */
     maxReconnectTimes: number;
-    /** 每次重连延时 */
+    /** 每次重连延时 | Delay per reconnection */
     delay: number;
 };
 export type WebSocketOptionsType = {
-    /** WebSocket 子协议 WebSocket(url: string, protocols: string | string[]) */
+    /** WebSocket subprotocol: WebSocket(url: string, protocols: string | string[]) */
     protocols?: string | string[];
-    /** WebSocket 连接所传输二进制数据的类型 */
+    /**
+     * WebSocket 连接接收的二进制数据类型
+     *  the type of binary data being received over the WebSocket connection
+     */
     binaryType?: WebSocket['binaryType'];
     heartbeat?: HeartbeatConfigType;
     interrupt?: InterruptConfigType;