@realsee/vr-signals/dist/index.d.ts

vr 信号器

/**
 * 日志级别枚举。
 */
declare const LogLevel: {
    NONE: number;
    ERROR: number;
    WARN: number;
    INFO: number;
    DEBUG: number;
};
type LogLevelkey = keyof typeof LogLevel;
type LogLevelValue = (typeof LogLevel)[LogLevelkey];
/**
 * 日志类。
 */
declare class Logger {
    /** 日志级别。 */
    level: LogLevelValue;
    /** 日志前缀。 */
    prefix: string;
    /**
     * 创建一个日志实例。
     * @param {string} [level=debug] - 日志级别。
     * @param {string} [prefix=''] - 日志前缀。
     */
    constructor(level: LogLevelkey, prefix?: string);
    /**
     * 输出调试日志。
     * @param {string} message - 日志消息。
     * @param {any} [payload] - 日志负载。
     * @returns {void}
     */
    debug(message: string, payload?: any): void;
    /**
     * 输出信息日志。
     * @param {string} message - 日志消息。
     * @param {any} [payload] - 日志负载。
     * @returns {void}
     */
    info(message: string, payload?: any): void;
    /**
     * 输出警告日志。
     * @param {string} message - 日志消息。
     * @param {any} [payload] - 日志负载。
     * @returns {void}
     */
    warn(message: string, payload?: any): void;
    /**
     * 输出错误日志。
     * @param {string} message - 日志消息。
     * @param {any} [payload] - 日志负载。
     * @returns {void}
     */
    error(message: string, payload?: any): void;
    /**
     * 格式化日志消息。如果存在负载，将其转换为 JSON 字符串并附加到消息后面。
     * @param {string} message - 日志消息。
     * @param {any} [payload] - 日志负载。
     * @returns {string} 格式化后的消息。
     */
    formatMessage(message: string, payload?: any): string;
    /**
     * 日志级别是否是指定的级别或更高级别。
     * @param requestedLevel
     * @param color
     * @param message
     * @param payload
     */
    private logIfEnabled;
    /**
     * 输出日志。
     * @param level
     * @param color
     * @param message
     * @param payload
     */
    private log;
    /**
     * 在 JSON.stringify 中处理特殊的值。如果值是数组，将数组转换为 JSON 字符串。如果值是错误对象，返回错误的名称和消息。
     * @param {string} key - 属性名。
     * @param {any} value - 属性值。
     * @returns {any} 处理后的值。
     */
    static replacer(key: string, value: any): any;
}

/**
 * 基础映射的类型
 * @typedef {Object} BaseMap
 * @property {Function} [name] - 处理函数，仅接收一个参数，可以返回任意类型的数据
 */
type BaseMap = {
    [name: string]: (arg: any) => any;
};
/**
 * 连接状态枚举
 */
declare enum ConnectionStatus {
    DISCONNECTED = "disconnected",
    CONNECTING = "connecting",
    CONNECTED = "connected",
    RECONNECTING = "reconnecting",
    ERROR = "error"
}
/**
 * 统一的消息结构体
 */
type MessageMap = {
    /** 内置 事件类型 消息 */
    event: EventPayload;
    /** 内置 请求类型 消息 */
    'action.request': ActionRequestPayload;
    /** 内置 响应类型 消息 */
    'action.response': ActionResponsePayload;
    /** 内置 握手类型 消息 */
    handshake: HandshakePayload;
};
/** 消息结构体 */
interface Message<MessageType extends keyof MessageMap> {
    /** 消息发出的时间戳 */
    timestamp: number;
    /** 消息的唯一标识 */
    uid: string;
    /** 消息类型，区分事件和方法 */
    type: MessageType;
    /** 消息体，不同消息类型有不同的 payload */
    payload: MessageMap[MessageType];
    /** 消息发送者 id */
    fromId: string;
    /** 消息接收者 id 集合 */
    toId: string | string[];
}
/** 握手消息的负载 */
interface HandshakePayload {
}
/** 事件消息体负载 */
interface EventPayload {
    /** 事件名称 */
    eventName: string | number;
    /** 事件所带的数据 */
    eventData: any;
    /** 事件唯一 id */
    uid: string;
}
/** 请求 or 指令的消息体负载 */
interface ActionRequestPayload {
    /** 请求调用的方法名 */
    method: string | number;
    /** 请求的唯一 id */
    uid: string;
    /** 请求方法的参数 */
    data: any;
}
/** 响应的消息体负载 */
interface ActionResponsePayload {
    /** 请求调用的方法名 */
    method: string | number;
    /** 请求的唯一 id */
    uid: string;
    /** 响应结果数据 */
    data?: any;
    /** 响应的错误 */
    error?: Error;
}
/**
 * `Base` 类用于处理 VR 链接和消息桥接。
 * 它可以运行在两种模式下：'control' 和 'controlled'。
 * 'control' 模式下，它会向子窗口发送消息，子窗口监听消息，然后执行相应的操作，然后再向父窗口发送消息，父窗口监听消息，然后执行相应的操作。
 * 'controlled' 模式下，它会监听父窗口的消息，然后执行相应的操作，然后再向父窗口发送消息，父窗口监听消息，然后执行相应的操作。
 */
type Mode = 'control' | 'controlled';
/**
 * 初始化的基础配置参数
 */
interface BaseOptions<ActionMap extends BaseMap> {
    /** 加载的 vr 链接 */
    vrLink?: string;
    /** 加载 vr 的 iframe 标签或是 父级 div 标签 */
    element?: HTMLDivElement | HTMLIFrameElement;
    /** 输出的日志级别 */
    logLevel?: LogLevelkey;
    /** 支持的方法列表 */
    actionMap?: Partial<ActionMap>;
    /** 握手重试次数，默认 10 次 */
    shakehandRetryTimes?: number;
    /** 握手重试策略配置 */
    handshakeRetryStrategy?: {
        /** 基础延迟时间（毫秒），默认 500ms */
        baseDelay?: number;
        /** 最大延迟时间（毫秒），默认 5000ms */
        maxDelay?: number;
        /** 抖动因子范围，默认 [0.85, 1.15] */
        jitterRange?: [number, number];
    };
    /** 是否启用自动重连，默认 true */
    enableAutoReconnect?: boolean;
    /** 重连策略配置 */
    reconnectStrategy?: {
        /** 基础重连延迟时间（毫秒），默认 2000ms */
        baseDelay?: number;
        /** 最大重连延迟时间（毫秒），默认 30000ms */
        maxDelay?: number;
        /** 抖动因子范围，默认 [0.8, 1.2] */
        jitterRange?: [number, number];
    };
    /** 重连间隔时间（毫秒），默认 5000ms（已废弃，使用 reconnectStrategy） */
    reconnectInterval?: number;
    /** 最大重连次数，默认 5 次 */
    maxReconnectAttempts?: number;
    /** 安全配置 */
    security?: SecurityConfig;
}
/**
 * 安全配置
 */
interface SecurityConfig {
    /** 是否启用严格模式，默认 false（兼容 1.x 版本） */
    strictMode?: boolean;
    /** 是否验证消息来源，默认 false（兼容 1.x 版本） */
    validateOrigin?: boolean;
    /** 是否验证消息签名，默认 false */
    validateSignature?: boolean;
    /** 消息签名密钥 */
    signatureKey?: string;
    /** 允许的跨域域名列表 */
    allowedOrigins?: string[];
    /** 是否允许通配符域名（如 *.example.com），默认 true（兼容 1.x 版本） */
    allowWildcardDomains?: boolean;
}
/**
 * 客户端的配置参数
 * @deprecated 此类型定义已更新，现在 vrLink 和 element 为可选参数
 *
 * 迁移指南：
 * ```typescript
 * // 旧用法（仍然支持）
 * const client = new RealseeVRSignalsClient({
 *   vrLink: 'http://localhost:3000/vr-app',
 *   element: iframeElement
 * })
 *
 * // 新用法（推荐）
 * const client = new RealseeVRSignalsClient({
 *   vrLink: 'http://localhost:3000/vr-app',
 *   element: iframeElement,
 *   logLevel: 'INFO'
 * })
 * ```
 */
type ClientOptions<ActionMap extends BaseMap> = BaseOptions<ActionMap>;
/**
 * 远程控制的配置参数
 */
type RemoteOptions<ActionMap extends BaseMap> = Pick<BaseOptions<ActionMap>, 'logLevel' | 'actionMap'>;
/**
 * 连接状态变化事件
 */
interface ConnectionStatusEvent {
    /** 连接状态 */
    status: ConnectionStatus;
    /** 时间戳 */
    timestamp: number;
    /** 错误信息（如果有） */
    error?: Error;
}

/**
 * @fileoverview SDK 中已实现的核心 Action 和 Event 类型定义
 *
 * 这个文件包含了 VR Signals SDK 中预定义的核心功能类型，
 * 包括与 @realsee/five SDK 对应的状态管理和相机控制功能。
 *
 * @author BEIKE REALSEE TECHNOLOGY (HK) LIMITED
 * @version 2.0.0-beta.4
 * @category Types
 */
/**
 * SDK 中已实现的核心 Action 和 Event 类型
 * 只包含必要的核心功能
 */
interface VRMonitor {
    content_data: {
        modelType: string;
    };
    extra_data: {
        adjustment: {
            distance: number;
            fov: number;
        };
        corners: Array<[number, number, number]>;
        matrix: number[];
        scale: number;
    };
    five_state: {
        distance: number;
        fov: number;
        latitude: number;
        longitude: number;
        mode: string;
        offset: {
            x: number;
            y: number;
            z: number;
        };
        panoIndex: number;
        workCode: string;
    };
    id: number;
    media_data: Array<{
        trans_status: number;
        type: string;
        videoSrc: string;
    }>;
    model_config: {
        iconUrl: string;
        objUrl: string;
        textureUrl: string;
        type: string;
    };
    name: string;
    position: string[];
    stick_type: string;
    type: string;
}
type VRMonitorList = VRMonitor[];
/**
 * 核心 Action 类型定义
 *
 * 包含了与 @realsee/five SDK 对应的核心功能 Actions，
 * 支持状态管理、相机控制、标签和监控操作等。
 *
 * @example
 * ```typescript
 * import { DefaultActionMap } from '@realsee/vr-signals'
 *
 * // 使用核心 Action 类型
 * const client = new RealseeVRSignalsClient<DefaultActionMap>({
 *   vrLink: 'http://localhost:3000/vr-app',
 *   element: iframeElement
 * })
 *
 * // 调用核心 Actions
 * await client.send('setState', { mode: 'panorama', longitude: 0 })
 * await client.send('updateCamera', { state: { longitude: 0, latitude: 0 } })
 * ```
 *
 * @category Types
 */
interface DefaultActionMap {
    setState: (data: {
        mode?: 'panorama' | 'floorplan' | 'topview';
        longitude?: number;
        latitude?: number;
        fov?: number;
        panoIndex?: number;
        offset?: {
            x: number;
            y: number;
            z: number;
        };
    }) => void;
    updateCamera: (data: {
        state: {
            longitude?: number;
            latitude?: number;
            fov?: number;
            offset?: {
                x: number;
                y: number;
                z: number;
            };
        };
    }) => void;
    getVRTagList: () => any;
    getVRMonitorList: () => VRMonitorList;
    'monitor.open': (args: {
        id: string;
    }) => void;
    'monitor.close': (args: {
        id: string;
    }) => void;
    'tag.lookAt': (args: {
        id: string;
    }) => void;
    [name: string]: (arg: any) => any;
}
/**
 * 核心 Event 类型定义
 *
 * 包含了与 @realsee/five SDK 对应的核心功能 Events，
 * 支持状态同步、相机事件、标签事件、监控事件等。
 *
 * @example
 * ```typescript
 * import { DefaultEventMap } from '@realsee/vr-signals'
 *
 * // 使用核心 Event 类型
 * const client = new RealseeVRSignalsClient<DefaultActionMap, DefaultEventMap>({
 *   vrLink: 'http://localhost:3000/vr-app',
 *   element: iframeElement
 * })
 *
 * // 监听核心 Events
 * client.on('stateSynced', (data) => {
 *   console.log('状态同步:', data)
 * })
 * client.on('cameraUpdate', (data) => {
 *   console.log('相机更新:', data.state)
 * })
 * ```
 *
 * @category Types
 */
interface DefaultEventMap {
    stateSynced: (data: {
        mode?: 'panorama' | 'floorplan' | 'topview';
        longitude?: number;
        latitude?: number;
        fov?: number;
        panoIndex?: number;
        offset?: {
            x: number;
            y: number;
            z: number;
        };
    }) => void;
    cameraUpdate: (data: {
        state: {
            longitude?: number;
            latitude?: number;
            fov?: number;
            offset?: {
                x: number;
                y: number;
                z: number;
            };
        };
        userAction: boolean;
    }) => void;
    'tag.click': (data: {
        id: string;
        data: {
            id: string;
            title: string;
            description: string;
            type: string;
            extraData: string;
        };
    }) => void;
    'monitor.open': (data: {
        id: string;
        data: {
            id: string;
            name: string;
            videoSrc: string;
            type: string;
            extraData: string;
        };
    }) => void;
    'monitor.close': (data: {
        id: string;
        data: {
            id: string;
            name: string;
            videoSrc: string;
            type: string;
            extraData: string;
        };
    }) => void;
    'overlay.visible': (data: {
        visible: boolean;
    }) => void;
    'sdk.availability.action.registered': (data: {
        actionName: string[];
        timestamp: number;
        stats: {
            total: number;
            registered: (string | number | symbol)[];
            timestamp: number;
        };
    }) => void;
    'sdk.availability.action.unregistered': (data: {
        actionName: string[];
        timestamp: number;
        stats: {
            total: number;
            registered: (string | number | symbol)[];
            timestamp: number;
        };
    }) => void;
    'sdk.availability.action.batch_registered': (data: {
        actionName: string[];
        timestamp: number;
        stats: {
            total: number;
            registered: (string | number | symbol)[];
            timestamp: number;
        };
    }) => void;
    'sdk.availability.action.batch_unregistered': (data: {
        actionName: string[];
        timestamp: number;
        stats: {
            total: number;
            registered: (string | number | symbol)[];
            timestamp: number;
        };
    }) => void;
    'sdk.availability.action.cleared': (data: {
        actionName: string[];
        timestamp: number;
        stats: {
            total: number;
            registered: (string | number | symbol)[];
            timestamp: number;
        };
    }) => void;
    [name: string]: (arg: any) => any;
}

/**
 * 消息桥接的配置项
 */
type MessageBridgeOptions<ActionMap extends BaseMap = DefaultActionMap, EventMap extends BaseMap = DefaultEventMap> = {
    /** 自己  */
    selfWindow: Window;
    /** 目标 */
    targetWindow: Window;
    /** 日志 */
    logger?: Logger;
    /** 本身的 uuid */
    uuid?: string;
    /** 握手次数 */
    shakehandRetryTimes?: number;
    /** action 映射表 */
    actionMap?: ActionMap;
    /** client or remote 的引用 */
    instance: Base<ActionMap, EventMap>;
    /** 是否启用自动重连 */
    enableAutoReconnect?: boolean;
    /** 重连间隔时间（毫秒） */
    reconnectInterval?: number;
    /** 最大重连次数 */
    maxReconnectAttempts?: number;
};
/**
 * 封装了跨域消息通信的类
 * 默认使用已实现的 DefaultActionMap 和 DefaultEventMap 类型
 */
declare class MessageBridge<ActionMap extends BaseMap = DefaultActionMap, EventMap extends BaseMap = DefaultEventMap> {
    /** 消息发送者 id */
    protected uuid: string;
    /** 当前窗口对象的引用 */
    protected selfWindow: Window;
    /** 目标窗口对象的引用 */
    protected targetWindow: Window;
    /** 消息接收者 id 集合 */
    protected toIds: string[];
    /** 记录已握过手的 */
    protected handshakedIds: string[];
    /** 日志 */
    protected logger: Logger;
    /** 是否已经 ready */
    protected ready: boolean;
    /** 连接状态 */
    protected connectionStatus: ConnectionStatus;
    /** 对父实例的引用 */
    private instance;
    /** 处理内置事件的订阅者 */
    protected eventTarget: EventTarget;
    /** 握手重试次数 */
    private shakehandRetryTimes;
    /** 是否启用自动重连 */
    private enableAutoReconnect;
    /** 重连间隔时间 */
    private reconnectInterval;
    /** 最大重连次数 */
    private maxReconnectAttempts;
    /** 当前重连次数 */
    private currentReconnectAttempts;
    /** 重连定时器 */
    private reconnectTimer;
    /** 握手定时器 */
    private handshakeTimer;
    /** 消息队列（连接断开时缓存消息） */
    private messageQueue;
    /** 是否正在握手 */
    private isHandshaking;
    /**
     * 构造函数
     * @param selfWindow 当前窗口对象的引用
     * @param targetWindow 目标窗口对象的引用
     */
    constructor(opts: MessageBridgeOptions<ActionMap, EventMap>);
    /**
     * 更新连接状态
     * @param status
     */
    private updateConnectionStatus;
    /**
     * 开始握手
     */
    private startHandshake;
    /**
     * 处理消息
     * @param ev  消息事件
     * @returns
     */
    private onMessage;
    /**
     * 处理握手消息
     * @param ev
     */
    private onHandshakeMessage;
    /**
     * 处理 event 消息
     * @param ev
     */
    private onEventMessage;
    /**
     * 处理 action 请求消息
     * @param ev
     */
    private onActionRequestMessage;
    /**
     * 执行 action
     * @param method
     * @param data
     * @returns
     */
    private executeRequest;
    /**
     * 处理 action 响应消息
     * @param ev
     */
    private onActionResponseMessage;
    /**
     * 进行 action 请求
     * @param method
     * @param data
     * @returns
     */
    requestAcion: (method: keyof ActionMap, data: Parameters<ActionMap[keyof ActionMap]>[0]) => Promise<ReturnType<ActionMap[keyof ActionMap]>>;
    /**
     * 握手，尝试 tryTime 次
     * @param tryTime
     */
    private handshake;
    /**
     * 处理握手失败
     */
    private handleHandshakeFailure;
    /**
     * 安排重连
     */
    private scheduleReconnect;
    /**
     * 发送消息
     * @param message
     */
    private sendMessage;
    /**
     * 发送队列中的消息
     */
    private flushMessageQueue;
    /**
     * 发送事件
     * @param eventName
     * @param eventData
     */
    sendEvent: (eventName: keyof EventMap, eventData: Parameters<EventMap[keyof EventMap]>[0]) => void;
    /**
     * 当前实例是否已经 ready
     * @param callback
     */
    onReady: (callback: () => void) => void;
    /**
     * 获取连接状态
     */
    getConnectionStatus: () => ConnectionStatus;
    /**
     * 监听错误
     * @param callback
     * @returns
     */
    onError: (callback: (error: Error) => void) => () => void;
    /**
     * 监听连接状态变化
     * @param callback
     * @returns
     */
    onConnectionStatusChange: (callback: (status: ConnectionStatus) => void) => () => void;
    /**
     * 取消连接状态监听
     * @param callback
     * @returns
     */
    offConnectionStatusChange: (callback: (status: ConnectionStatus) => void) => void;
    /**
     * 手动重连
     */
    reconnect: () => void;
    /**
     * 销毁实例
     */
    dispose: () => void;
}

/**
 * 标准化的 EventTarget 基类
 * 继承原生 EventTarget，提供标准的事件管理方法
 */
declare class StandardEventTarget extends EventTarget {
    /**
     * 添加事件监听器（标准方法）
     * @param type 事件类型
     * @param listener 事件监听器
     * @param options 选项
     */
    addEventListener(type: string, listener: EventListener | EventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
    /**
     * 移除事件监听器（标准方法）
     * @param type 事件类型
     * @param listener 事件监听器
     * @param options 选项
     */
    removeEventListener(type: string, listener: EventListener | EventListenerObject | null, options?: boolean | EventListenerOptions): void;
    /**
     * 分发事件（标准方法）
     * @param event 事件对象
     * @returns 是否被取消
     */
    dispatchEvent(event: Event): boolean;
    /**
     * 创建并分发自定义事件
     * @param type 事件类型
     * @param detail 事件详情
     * @param options 事件选项
     * @returns 是否被取消
     */
    dispatchCustomEvent<T = any>(type: string, detail?: T, options?: CustomEventInit<T>): boolean;
    /**
     * 创建并分发内置事件
     * @param type 事件类型
     * @param options 事件选项
     * @returns 是否被取消
     */
    dispatchBuiltInEvent(type: string, options?: EventInit): boolean;
    /**
     * 检查是否有指定类型的事件监听器
     * @param type 事件类型
     * @returns 是否有监听器
     */
    hasEventListener(type: string): boolean;
    /**
     * 获取事件监听器数量（近似值）
     * @param type 事件类型
     * @returns 监听器数量
     */
    getListenerCount(type: string): number;
    /**
     * 移除指定类型的所有事件监听器
     * @param type 事件类型
     */
    removeAllListeners(type: string): void;
    /**
     * 使用 AbortController 添加事件监听器
     * @param type 事件类型
     * @param listener 事件监听器
     * @param options 选项
     * @param signal AbortSignal
     * @returns 清理函数
     */
    addEventListenerWithAbort(type: string, listener: EventListener | EventListenerObject | null, options?: AddEventListenerOptions, signal?: AbortSignal): () => void;
}

/**
 * 标准化的 Action 管理器
 * 使用标准的 Promise 和 AbortController
 */
declare class StandardActionManager<ActionMap extends Record<string, (...args: any[]) => any>> {
    private actions;
    private logger;
    constructor(logger?: Console);
    /**
     * 注册 Action
     * @param name Action 名称
     * @param handler Action 处理器
     */
    register<K extends keyof ActionMap>(name: K, handler: ActionMap[K]): void;
    /**
     * 批量注册 Actions
     * @param actions Actions 映射
     */
    registerActions(actions: Partial<ActionMap>): void;
    /**
     * 移除 Action
     * @param name Action 名称
     * @returns 是否成功移除
     */
    unregister<K extends keyof ActionMap>(name: K): boolean;
    /**
     * 检查 Action 是否已注册
     * @param name Action 名称
     * @returns 是否已注册
     */
    has<K extends keyof ActionMap>(name: K): boolean;
    /**
     * 获取已注册的 Actions 列表
     * @returns Actions 名称列表
     */
    getRegisteredActions(): (keyof ActionMap)[];
    /**
     * 执行 Action（标准 Promise 接口）
     * @param name Action 名称
     * @param data Action 参数
     * @param options 执行选项
     * @returns Promise 结果
     */
    execute<K extends keyof ActionMap>(name: K, data: Parameters<ActionMap[K]>[0], options?: ActionExecuteOptions$1): Promise<ReturnType<ActionMap[K]>>;
    /**
     * 执行 Action 并支持取消（返回 Promise 和 AbortController）
     * @param name Action 名称
     * @param data Action 参数
     * @param options 执行选项
     * @returns 执行结果和控制器
     */
    executeWithAbort<K extends keyof ActionMap>(name: K, data: Parameters<ActionMap[K]>[0], options?: ActionExecuteOptions$1): {
        promise: Promise<ReturnType<ActionMap[K]>>;
        abort: () => void;
        signal: AbortSignal;
    };
    /**
     * 清空所有 Actions
     */
    clear(): void;
    /**
     * 获取 Actions 数量
     */
    get size(): number;
    /**
     * 合并多个 AbortSignal
     * @param signals 要合并的信号
     * @returns 合并后的信号
     */
    private combineSignals;
}
/**
 * Action 执行选项
 */
interface ActionExecuteOptions$1 {
    /** 取消信号 */
    signal?: AbortSignal;
    /** 超时时间（毫秒） */
    timeout?: number;
}

/**
 * 核心的基类
 * 继承标准化的 EventTarget，提供标准的事件管理
 * 默认使用已实现的 DefaultActionMap 和 DefaultEventMap 类型
 */
declare class Base<ActionMap extends BaseMap = DefaultActionMap, EventMap extends BaseMap = DefaultEventMap> extends StandardEventTarget {
    /**
     * 运行模式
     */
    private mode;
    /**
     * 父元素
     */
    private parentElement;
    /**
     * iframe 元素
     */
    private iframeElement;
    /**
     * VR 链接
     */
    private vrLink;
    /**
     * 当前实例的 uuid
     */
    private uuid;
    /**
     * 消息桥接实例
     */
    protected messageBridge: MessageBridge<ActionMap, EventMap> | null;
    /**
     * 支持的方法列表（向后兼容）
     */
    private _actionMap?;
    /**
     * 获取支持的方法列表（向后兼容）
     */
    get actionMap(): Partial<ActionMap> | undefined;
    /**
     * Action 管理器
     */
    private _actionManager;
    /**
     * 获取 Action 管理器
     */
    get actionManager(): StandardActionManager<ActionMap>;
    /**
     * 获取目标窗口
     */
    private get targetWindow();
    /**
     * 日志记录器
     */
    protected logger: Logger;
    /**
     * 配置选项
     */
    private options;
    /**
     * 连接状态
     */
    private _connectionStatus;
    /**
     * 获取连接状态
     */
    get connectionStatus(): ConnectionStatus;
    /**
     * 获取配置选项
     */
    getOptions(): Partial<BaseOptions<ActionMap>>;
    /**
     * 构造函数接受一个可选的 `Options` 对象。
     * 它首先初始化 logger，然后检测是否在 iframe 中运行。
     * @param options - 包含 VR 链接、元素和日志级别的选项对象。
     */
    constructor(options?: Partial<BaseOptions<ActionMap>>);
    /**
     * 验证控制模式下的配置选项
     * @param options
     */
    private validateControlModeOptions;
    /**
     * 设置控制模式
     * @param options
     */
    private setupControlMode;
    /**
     * 创建 iframe 元素
     * @param parentElement
     * @returns
     */
    private createIframe;
    /**
     * 初始化消息桥接
     */
    private initMessageBridge;
    /**
     * 当消息桥接准备好时，执行回调
     * @param callback
     * @returns
     */
    onReady: (callback: () => void) => void;
    /**
     * 监听连接状态变化
     * @param callback
     * @returns
     */
    onConnectionStatusChange(callback: (status: ConnectionStatus) => void): (() => void) | undefined;
    /**
     * 取消连接状态监听
     * @param callback
     */
    offConnectionStatusChange(callback: (status: ConnectionStatus) => void): void | undefined;
    /**
     * 手动重连
     */
    reconnect: () => void;
    /**
     * 处理 Action 请求（子类可以重写此方法）
     */
    protected handleActionRequest(actionName: string, data: any): Promise<any>;
    /**
     * 发送事件
     */
    sendEvent<EventName extends keyof EventMap>(eventName: EventName, eventData: Parameters<EventMap[EventName]>[0]): void;
    /**
     * 发送 Action 请求
     */
    send<K extends keyof ActionMap>(action: K, data: Parameters<ActionMap[K]>[0]): Promise<ReturnType<ActionMap[K]>>;
    /**
     * 监听事件（向后兼容，内部使用标准 addEventListener）
     */
    on<EventName extends keyof EventMap>(eventName: EventName, callback: EventMap[EventName]): () => void;
    /**
     * 取消监听事件（向后兼容，内部使用标准 removeEventListener）
     */
    off<EventName extends keyof EventMap>(eventName: EventName, callback: EventMap[EventName]): void;
    /**
     * 只监听一次事件（向后兼容，内部使用标准 addEventListener）
     */
    once<EventName extends keyof EventMap>(eventName: EventName, callback: EventMap[EventName]): () => void;
    /**
     * 连接状态变化回调（子类可以重写）
     */
    protected onConnectionStatusChanged?(status: ConnectionStatus): void;
    /**
     * 销毁
     */
    dispose: () => void;
}

/**
 * VR 信号客户端类 - 专注于连接管理和 Action 调用
 *
 * 这个类用于在父窗口中创建客户端实例，负责与 VR 应用建立通信连接，
 * 发送 Action 请求，监听事件，并管理连接状态。
 *
 * @template ActionMap Action 映射类型，默认为 DefaultActionMap
 * @template EventMap Event 映射类型，默认为 DefaultEventMap
 *
 * @example
 * ```typescript
 * import { RealseeVRSignalsClient } from '@realsee/vr-signals'
 *
 * const client = new RealseeVRSignalsClient({
 *   vrLink: 'http://localhost:3000/vr-app',
 *   element: iframeElement,
 *   logLevel: 'INFO'
 * })
 *
 * // 监听事件
 * client.on('cameraUpdate', (data) => {
 *   console.log('相机更新:', data.state)
 * })
 *
 * // 发送 Action
 * await client.send('setState', { mode: 'panorama' })
 * ```
 *
 * @category Core Classes
 */
declare class Client<ActionMap extends BaseMap = DefaultActionMap, EventMap extends BaseMap = DefaultEventMap> extends Base<ActionMap, EventMap> {
    private actionAvailabilityManager;
    protected logger: Logger;
    /**
     * @deprecated 此属性已废弃，请直接使用 Client 实例的事件监听方法
     * @see {@link on}
     * @see {@link once}
     *
     * 迁移指南：
     * ```typescript
     * // 旧用法
     * client.subscribe.on('cameraUpdate', handler)
     *
     * // 新用法
     * client.on('cameraUpdate', handler)
     * ```
     */
    subscribe: this;
    /**
     * 创建 VR 信号客户端实例
     *
     * @param options 客户端配置选项
     * @param options.vrLink VR 应用链接地址
     * @param options.element iframe 或容器元素
     * @param options.logLevel 日志级别，默认为 'NONE'
     * @param options.handshakeRetryStrategy 握手重试策略配置
     * @param options.reconnectStrategy 重连策略配置
     * @param options.shakehandRetryTimes 握手重试次数，默认为 10
     * @param options.enableAutoReconnect 是否启用自动重连，默认为 true
     * @param options.maxReconnectAttempts 最大重连次数，默认为 5
     * @param options.security 安全配置选项
     *
     * @example
     * ```typescript
     * const client = new RealseeVRSignalsClient({
     *   vrLink: 'http://localhost:3000/vr-app',
     *   element: iframeElement,
     *   logLevel: 'INFO',
     *   handshakeRetryStrategy: {
     *     baseDelay: 500,
     *     maxDelay: 5000,
     *     jitterRange: [0.85, 1.15]
     *   }
     * })
     * ```
     */
    constructor(options: ClientOptions<ActionMap>);
    /**
     * 发送 Action 请求（带可用性检查）
     */
    send<K extends keyof ActionMap>(action: K, data: Parameters<ActionMap[K]>[0]): Promise<ReturnType<ActionMap[K]>>;
    /**
     * @deprecated 此方法已废弃，请使用 send() 方法替代
     * @see {@link send}
     *
     * 迁移指南：
     * ```typescript
     * // 旧用法
     * const result = await client.callAction('setState', { mode: 'editing' })
     *
     * // 新用法
     * const result = await client.send('setState', { mode: 'editing' })
     * ```
     */
    callAction<K extends keyof ActionMap>(action: K, data: Parameters<ActionMap[K]>[0]): Promise<ReturnType<ActionMap[K]>>;
    /**
     * 检查 Action 是否可用
     */
    isActionAvailable<K extends keyof ActionMap>(action: K): boolean;
    /**
     * 获取所有可用的 Actions
     */
    getAvailableActions(): (keyof ActionMap)[];
    /**
     * 监听 Action 可用性变化
     */
    onActionAvailabilityChange<K extends keyof ActionMap>(action: K, callback: (available: boolean) => void): () => void;
    /**
     * 监听所有 Action 可用性变化
     */
    onActionAvailabilityChangeAll(callback: (event: {
        actions: (keyof ActionMap)[];
        available: boolean;
    }) => void): () => void;
    /**
     * 等待特定 Action 可用
     */
    waitForAction<K extends keyof ActionMap>(action: K, timeout?: number): Promise<void>;
    /**
     * 获取 Action 统计信息
     */
    getActionStats(): {
        available: number;
        total: number;
        availableActions: (keyof ActionMap)[];
    };
    /**
     * 处理来自 Remote 的 Action 可用性变化事件
     */
    private handleActionAvailabilityChange;
    /**
     * 重写基类的连接状态变化处理
     */
    protected onConnectionStatusChanged(status: ConnectionStatus): void;
}

/**
 * 动态 Action 注册器
 */
declare class DynamicActionRegistry<ActionMap extends BaseMap = DefaultActionMap> {
    private actions;
    private logger;
    /**
     * 注册一个 action
     */
    register<K extends keyof ActionMap>(name: K, handler: ActionMap[K]): void;
    /**
     * 移除一个 action
     */
    unregister<K extends keyof ActionMap>(name: K): boolean;
    /**
     * 检查 action 是否已注册
     */
    has<K extends keyof ActionMap>(name: K): boolean;
    /**
     * 获取已注册的 action 列表
     */
    getRegisteredActions(): (keyof ActionMap)[];
    /**
     * 执行 action
     */
    execute<K extends keyof ActionMap>(name: K, data: Parameters<ActionMap[K]>[0]): Promise<ReturnType<ActionMap[K]>>;
    /**
     * 清空所有 actions
     */
    clear(): void;
    /**
     * 获取 actions 数量
     */
    get size(): number;
}
/**
 * VR 信号远程控制类 - 专注于 Action 管理和执行
 *
 * 这个类用于在 VR 应用中创建远程控制实例，负责接收来自父窗口的 Action 请求，
 * 执行相应的处理逻辑，并支持动态注册和移除 Actions。
 *
 * @template ActionMap Action 映射类型，默认为 DefaultActionMap
 * @template EventMap Event 映射类型，默认为 DefaultEventMap
 *
 * @example
 * ```typescript
 * import { RealseeVRSignalsRemote } from '@realsee/vr-signals'
 *
 * const remote = new RealseeVRSignalsRemote({
 *   logLevel: 'INFO',
 *   actionMap: {
 *     setState(data) {
 *       console.log('状态更新:', data)
 *       return { success: true }
 *     }
 *   }
 * })
 *
 * // 动态注册 Action
 * remote.registerAction('updateCamera', async (data) => {
 *   console.log('相机更新:', data)
 *   return { success: true }
 * })
 * ```
 *
 * @category Core Classes
 */
declare class Remote<ActionMap extends BaseMap = DefaultActionMap, EventMap extends BaseMap = DefaultEventMap> extends Base<ActionMap, EventMap> {
    private actionRegistry;
    protected logger: Logger;
    /**
     * 创建 VR 信号远程控制实例
     *
     * @param options 远程控制配置选项
     * @param options.logLevel 日志级别，默认为 'NONE'
     * @param options.actionMap 初始 Action 映射，可选
     *
     * @example
     * ```typescript
     * const remote = new RealseeVRSignalsRemote({
     *   logLevel: 'INFO',
     *   actionMap: {
     *     setState(data) {
     *       console.log('状态更新:', data)
     *       return { success: true }
     *     },
     *     updateCamera({ state }) {
     *       console.log('相机更新:', state)
     *       return { success: true }
     *     }
     *   }
     * })
     * ```
     */
    constructor(options?: RemoteOptions<ActionMap>);
    /**
     * 注册单个 action
     */
    registerAction<K extends keyof ActionMap>(name: K, handler: ActionMap[K]): void;
    /**
     * 批量注册 actions
     */
    registerActions(actions: Partial<ActionMap>): void;
    /**
     * 移除单个 action
     */
    unregisterAction<K extends keyof ActionMap>(name: K): boolean;
    /**
     * 批量移除 actions
     */
    unregisterActions(names: (keyof ActionMap)[]): number;
    /**
     * 检查 action 是否已注册
     */
    hasAction<K extends keyof ActionMap>(name: K): boolean;
    /**
     * 获取已注册的 action 列表
     */
    getRegisteredActions(): (keyof ActionMap)[];
    /**
     * 清空所有 actions
     */
    clearActions(): void;
    /**
     * 监听 action 变化事件
     */
    onActionChange(callback: (event: ActionChangeEvent<ActionMap>) => void): () => void;
    /**
     * 监听特定 action 的可用性变化
     */
    onActionAvailabilityChange<K extends keyof ActionMap>(actionName: K, callback: (available: boolean) => void): () => void;
    /**
     * 获取 action 统计信息
     */
    getActionStats(): ActionStats;
    /**
     * 通知 action 变化
     */
    private notifyActionChange;
    /**
     * 重写基类的 action 处理逻辑
     */
    protected handleActionRequest(actionName: string, data: any): Promise<any>;
    /**
     * 获取 action 注册器实例（用于高级操作）
     */
    getActionRegistry(): DynamicActionRegistry<ActionMap>;
}
/**
 * Action 变化事件类型
 */
type ActionChangeType = 'registered' | 'unregistered' | 'batch_registered' | 'batch_unregistered' | 'cleared';
/**
 * Action 变化事件
 */
interface ActionChangeEvent<ActionMap extends BaseMap> {
    type: ActionChangeType;
    actionName: (keyof ActionMap)[];
    timestamp: number;
    stats: ActionStats;
}
/**
 * Action 统计信息
 */
interface ActionStats {
    total: number;
    registered: (string | number | symbol)[];
    timestamp: number;
}

/**
 * 安全工具类
 */
declare class SecurityUtils {
    /**
     * 获取当前页面的域名信息
     * @returns 当前域名信息
     */
    static getCurrentDomainInfo(): {
        origin: string;
        hostname: string;
        protocol: string;
        port: string;
        isLocalhost: boolean;
        isSecure: boolean;
        accessible: boolean;
    };
    /**
     * 获取目标窗口的域名信息
     * @param targetWindow 目标窗口
     * @returns 目标域名信息
     */
    static getTargetDomainInfo(targetWindow: Window): {
        origin: string;
        hostname: string;
        protocol: string;
        port: string;
        isLocalhost: boolean;
        isSecure: boolean;
        accessible: boolean;
    };
    /**
     * 生成自适应的允许域名列表
     * @param currentWindow 当前窗口
     * @param targetWindow 目标窗口
     * @param allowedOrigins 配置的允许域名列表
     * @returns 自适应的允许域名列表
     */
    static generateAdaptiveAllowedOrigins(currentWindow: Window, targetWindow: Window, allowedOrigins?: string[]): string[];
    /**
     * 提取域名（去掉子域名）
     * @param hostname 主机名
     * @returns 域名
     */
    private static extractDomain;
    /**
     * 验证消息来源是否安全（自适应策略）
     * @param origin 消息来源
     * @param currentWindow 当前窗口
     * @param targetWindow 目标窗口
     * @param strictMode 是否启用严格模式
     * @returns 是否安全
     */
    static validateOriginAdaptive(origin: string, currentWindow: Window, targetWindow: Window, strictMode?: boolean): boolean;
    /**
     * 验证消息来源是否安全
     * @param origin 消息来源
     * @param allowedOrigins 允许的域名列表
     * @param strictMode 是否启用严格模式
     * @returns 是否安全
     */
    static validateOrigin(origin: string, allowedOrigins?: string[], strictMode?: boolean): boolean;
    /**
     * 验证消息结构是否合法
     * @param message 消息对象
     * @returns 是否合法
     */
    static validateMessageStructure(message: any): boolean;
    /**
     * 检测消息是否来自 devtools
     * @param message 消息对象
     * @returns 是否来自 devtools
     */
    static isDevToolsMessage(message: any): boolean;
    /**
     * 验证消息结构是否合法，并返回详细的验证结果
     * @param message 消息对象
     * @returns 验证结果对象
     */
    static validateMessageStructureDetailed(message: any): {
        valid: boolean;
        reason?: string;
        details?: any;
    };
    /**
     * 生成消息签名
     * @param message 消息对象
     * @param key 签名密钥
     * @returns 签名
     */
    static generateSignature(message: any, key: string): string;
    /**
     * 验证消息签名
     * @param message 消息对象
     * @param key 签名密钥
     * @returns 是否有效
     */
    static validateSignature(message: any, key: string): boolean;
    /**
     * 清理消息对象，移除敏感信息
     * @param message 消息对象
     * @returns 清理后的消息
     */
    static sanitizeMessage(message: any): any;
    /**
     * 获取安全的 targetOrigin（自适应策略）
     * @param targetWindow 目标窗口
     * @param strictMode 是否启用严格模式
     * @param allowedOrigins 配置的允许域名列表
     * @returns 安全的 targetOrigin
     */
    static getSecureTargetOriginAdaptive(targetWindow: Window, strictMode?: boolean, // 默认改为 false
    allowedOrigins?: string[]): string;
    /**
     * 获取安全的 targetOrigin
     * @param targetWindow 目标窗口
     * @param allowedOrigins 允许的域名列表
     * @param strictMode 是否启用严格模式
     * @returns 安全的 targetOrigin
     */
    static getSecureTargetOrigin(targetWindow: Window, allowedOrigins?: string[], strictMode?: boolean): string;
}

/**
 * 统一的事件类型定义
 * 明确区分 inner、SDK 和注册的事件类型
 */
/**
 * 事件类型分类
 */
declare enum EventCategory {
    /** 内部事件 - SDK 内部使用，开发者通常不需要监听 */
    INNER = "inner",
    /** SDK 事件 - SDK 提供的标准事件，开发者可以监听 */
    SDK = "sdk",
    /** 注册事件 - 开发者注册的自定义事件 */
    REGISTERED = "registered"
}
/**
 * 事件命名空间
 */
declare enum EventNamespace {
    /** 连接相关事件 */
    CONNECTION = "connection",
    /** 状态相关事件 */
    STATE = "state",
    /** 消息相关事件 */
    MESSAGE = "message",
    /** 动作相关事件 */
    ACTION = "action",
    /** 标签相关事件 */
    TAG = "tag",
    /** 监控相关事件 */
    MONITOR = "monitor",
    /** 相机相关事件 */
    CAMERA = "camera",
    /** 覆盖层相关事件 */
    OVERLAY = "overlay",
    /** 自定义事件 */
    CUSTOM = "custom"
}
/**
 * 统一的事件类型枚举
 * 使用命名空间前缀明确事件来源和分类
 */
declare enum EventType {
    INNER_CONNECTION_HANDSHAKE = "inner.connection.handshake",
    INNER_CONNECTION_HANDSHAKE_SUCCESS = "inner.connection.handshake.success",
    INNER_CONNECTION_HANDSHAKE_FAIL = "inner.connection.handshake.fail",
    INNER_CONNECTION_RECONNECT = "inner.connection.reconnect",
    INNER_MESSAGE_QUEUED = "inner.message.queued",
    INNER_MESSAGE_SENT = "inner.message.sent",
    INNER_MESSAGE_RECEIVED = "inner.message.received",
    INNER_MESSAGE_ERROR = "inner.message.error",
    INNER_ACTION_REQUEST = "inner.action.request",
    INNER_ACTION_RESPONSE = "inner.action.response",
    INNER_ACTION_TIMEOUT = "inner.action.timeout",
    INNER_ACTION_ERROR = "inner.action.error",
    SDK_CONNECTION_CONNECT = "sdk.connection.connect",
    SDK_CONNECTION_DISCONNECT = "sdk.connection.disconnect",
    SDK_CONNECTION_RECONNECT = "sdk.connection.reconnect",
    SDK_CONNECTION_ERROR = "sdk.connection.error",
    SDK_CONNECTION_STATUS_CHANGE = "sdk.connection.status.change",
    SDK_LIFECYCLE_READY = "sdk.lifecycle.ready",
    SDK_LIFECYCLE_DESTROY = "sdk.lifecycle.destroy",
    SDK_LIFECYCLE_STATE_CHANGE = "sdk.lifecycle.state.change",
    SDK_MESSAGE_SENT = "sdk.message.sent",
    SDK_MESSAGE_RECEIVED = "sdk.message.received",
    SDK_MESSAGE_ERROR = "sdk.message.error",
    SDK_ACTION_EXECUTED = "sdk.action.executed",
    SDK_ACTION_SUCCESS = "sdk.action.success",
    SDK_ACTION_FAILED = "sdk.action.failed",
    SDK_ACTION_TIMEOUT = "sdk.action.timeout",
    SDK_ACTION_ABORTED = "sdk.action.aborted",
    SDK_AVAILABILITY_ACTION_REGISTERED = "sdk.availability.action.registered",
    SDK_AVAILABILITY_ACTION_UNREGISTERED = "sdk.availability.action.unregistered",
    SDK_AVAILABILITY_ACTION_BATCH_REGISTERED = "sdk.availability.action.batch.registered",
    SDK_AVAILABILITY_ACTION_BATCH_UNREGISTERED = "sdk.availability.action.batch.unregistered",
    SDK_AVAILABILITY_ACTION_CLEARED = "sdk.availability.action.cleared",
    REGISTERED_STATE_SYNCED = "registered.state.synced",
    REGISTERED_CAMERA_UPDATE = "registered.camera.update",
    REGISTERED_TAG_CLICK = "registered.tag.click",
    REGISTERED_TAG_LIST_RETRIEVED = "registered.tag.list.retrieved",
    REGISTERED_TAG_LIST_ERROR = "registered.tag.list.error",
    REGISTERED_MONITOR_OPEN = "registered.monitor.open",
    REGISTERED_MONITOR_CLOSE = "registered.monitor.close",
    REGISTERED_OVERLAY_VISIBLE = "registered.overlay.visible",
    REGISTERED_CUSTOM = "registered.custom"
}
/**
 * 事件类型分组
 */
declare const EventTypeGroups: {
    /** 内部事件组 */
    readonly INNER: readonly [EventType.INNER_CONNECTION_HANDSHAKE, EventType.INNER_CONNECTION_HANDSHAKE_SUCCESS, EventType.INNER_CONNECTION_HANDSHAKE_FAIL, EventType.INNER_CONNECTION_RECONNECT, EventType.INNER_MESSAGE_QUEUED, EventType.INNER_MESSAGE_SENT, EventType.INNER_MESSAGE_RECEIVED, EventType.INNER_MESSAGE_ERROR, EventType.INNER_ACTION_REQUEST, EventType.INNER_ACTION_RESPONSE, EventType.INNER_ACTION_TIMEOUT, EventType.INNER_ACTION_ERROR];
    /** SDK 事件组 */
    readonly SDK: readonly [EventType.SDK_CONNECTION_CONNECT, EventType.SDK_CONNECTION_DISCONNECT, EventType.SDK_CONNECTION_RECONNECT, EventType.SDK_CONNECTION_ERROR, EventType.SDK_CONNECTION_STATUS_CHANGE, EventType.SDK_LIFECYCLE_READY, EventType.SDK_LIFECYCLE_DESTROY, EventType.SDK_LIFECYCLE_STATE_CHANGE, EventType.SDK_MESSAGE_SENT, EventType.SDK_MESSAGE_RECEIVED, EventType.SDK_MESSAGE_ERROR, EventType.SDK_ACTION_EXECUTED, EventType.SDK_ACTION_SUCCESS, EventType.SDK_ACTION_FAILED, EventType.SDK_ACTION_TIMEOUT, EventType.SDK_ACTION_ABORTED, EventType.SDK_AVAILABILITY_ACTION_REGISTERED, EventType.SDK_AVAILABILITY_ACTION_UNREGISTERED, EventType.SDK_AVAILABILITY_ACTION_BATCH_REGISTERED, EventType.SDK_AVAILABILITY_ACTION_BATCH_UNREGISTERED, EventType.SDK_AVAILABILITY_ACTION_CLEARED];
    /** 注册事件组 */
    readonly REGISTERED: readonly [EventType.REGISTERED_STATE_SYNCED, EventType.REGISTERED_CAMERA_UPDATE, EventType.REGISTERED_TAG_CLICK, EventType.REGISTERED_TAG_LIST_RETRIEVED, EventType.REGISTERED_TAG_LIST_ERROR, EventType.REGISTERED_MONITOR_OPEN, EventType.REGISTERED_MONITOR_CLOSE, EventType.REGISTERED_OVERLAY_VISIBLE, EventType.REGISTERED_CUSTOM];
};
/**
 * 事件类型工具函数
 */
declare class EventTypeUtils {
    /**
     * 检查事件类型是否属于指定分类
     */
    static isEventOfCategory(eventType: string, category: EventCategory): boolean;
    /**
     * 检查事件类型是否属于指定命名空间
     */
    static isEventOfNamespace(eventType: string, namespace: EventNamespace): boolean;
    /**
     * 获取事件分类
     */
    static getEventCategory(eventType: string): EventCategory | null;
    /**
     * 获取事件命名空间
     */
    static getEventNamespace(eventType: string): EventNamespace | null;
    /**
     * 检查事件类型是否为内部事件
     */
    static isInnerEvent(eventType: string): boolean;
    /**
     * 检查事件类型是否为 SDK 事件
     */
    static isSDKEvent(eventType: string): boolean;
    /**
     * 检查事件类型是否为注册事件
     */
    static isRegisteredEvent(eventType: string): boolean;
    /**
   * 获取所有内部事件类型
   */
    static getInnerEventTypes(): string[];
    /**
     * 获取所有 SDK 事件类型
     */
    static getSDKEventTypes(): string[];
    /**
     * 获取所有注册事件类型
     */
    static getRegisteredEventTypes(): string[];
    /**
     * 获取指定分类的所有事件类型
     */
    static getEventTypesByCategory(category: EventCategory): string[];
    /**
     * 获取指定命名空间的所有事件类型
     */
    static getEventTypesByNamespace(namespace: EventNamespace): string[];
}
/**
 * 向后兼容的事件类型别名
 * @deprecated 使用 EventType 枚举替代
 */
declare const LegacyEventType: {
    readonly CONNECT: EventType.SDK_CONNECTION_CONNECT;
    readonly DISCONNECT: EventType.SDK_CONNECTION_DISCONNECT;
    readonly RECONNECT: EventType.SDK_CONNECTION_RECONNECT;
    readonly ERROR: EventType.SDK_CONNECTION_ERROR;
    readonly READY: EventType.SDK_LIFECYCLE_READY;
    readonly STATE_CHANGE: EventType.SDK_LIFECYCLE_STATE_CHANGE;
    readonly MESSAGE: EventType.SDK_MESSAGE_RECEIVED;
    readonly ACTION_REQUEST: EventType.INNER_ACTION_REQUEST;
    readonly ACTION_RESPONSE: EventType.INNER_ACTION_RESPONSE;
    readonly CUSTOM: EventType.REGISTERED_CUSTOM;
};

/**
 * 标准化的 API 接口
 * 与 Web 标准对齐，提供标准的事件管理和 Action 执行
 */

/**
 * 标准化的 VR Signals API 接口
 */
interface StandardVRSignalsAPI<ActionMap extends Record<string, (...args: any[]) => any>, EventMap extends Record<string, (...args: any[]) => any>> {
    addEventListener(type: string, listener: EventListener | EventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
    removeEventListener(type: string, listener: EventListener | EventListenerObject | null, options?: boolean | EventListenerOptions): void;
    dispatchEvent(event: Event): boolean;
    on<EventName extends keyof EventMap>(eventName: EventName, callback: EventMap[EventName]): () => void;
    off<EventName extends keyof EventMap>(eventName: EventName, callback: EventMap[EventName]): void;
    once<EventName extends keyof EventMap>(eventName: EventName, callback: EventMap[EventName]): () => void;
    connect(): Promise<void>;
    disconnect(): void;
    reconnect(): Promise<void>;
    getConnectionStatus(): ConnectionStatus;
    isConnected(): boolean;
    isConnecting(): boolean;
    hasError(): boolean;
    ready(): Promise<void>;
    destroy(): void;
    sendEvent<EventName extends keyof EventMap>(eventName: EventName, data: Parameters<EventMap[EventName]>[0]): void;
}
/**
 * 标准化的 Action 执行接口
 */
interface StandardActionAPI<ActionMap extends Record<string, (...args: any[]) => any>> {
    execute<K extends keyof ActionMap>(action: K, data: Parameters<ActionMap[K]>[0], options?: ActionExecuteOptions): Promise<ReturnType<ActionMap[K]>>;
    executeWithAbort<K extends keyof ActionMap>(action: K, data: Parameters<ActionMap[K]>[0], options?: ActionExecuteOptions): {
        promise: Promise<ReturnType<ActionMap[K]>>;
        abort: () => void;
        signal: AbortSignal;
    };
    registerAction<K extends keyof ActionMap>(name: K, handler: ActionMap[K]): void;
    unregisterAction<K extends keyof ActionMap>(name: K): boolean;
    hasAction<K extends keyof ActionMap>(name: K): boolean;
    getRegisteredActions(): (keyof ActionMap)[];
}
/**
 * Action 执行选项
 */
interface ActionExecuteOptions {
    /** 取消信号 */
    signal?: AbortSignal;
    /** 超时时间（毫秒） */
    timeout?: number;
}
/**
 * 标准的事件选项
 */
interface StandardEventOptions extends AddEventListenerOptions {
    /** 是否只执行一次 */
    once?: boolean;
    /** 是否被动监听 */
    passive?: boolean;
    /** 是否在捕获阶段触发 */
    capture?: boolean;
    /** 取消信号 */
    signal?: AbortSignal;
}
/**
 * 标准的事件监听器
 */
type StandardEventListener<T = any> = (event: CustomEvent<T>) => void;
/**
 * 标准的事件管理器
 */
interface StandardEventManager {
    addEventListener(type: string, listener: EventListener | EventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
    removeEventListener(type: string, listener: EventListener | EventListenerObject | null, options?: boolean | EventListenerOptions): void;
    addEventListenerWithOptions(type: string, listener: EventListener | EventListenerObject | null, options: StandardEventOptions): () => void;
    dispatchEvent(event: Event): boolean;
    dispatchCustomEvent<T = any>(type: string, detail?: T, options?: CustomEventInit<T>): boolean;
    dispatchBuiltInEvent(type: string, options?: EventInit): boolean;
    hasEventListener(type: string): boolean;
    getListenerCount(type: string): number;
}
/**
 * 标准的连接管理器
 */
interface StandardConnectionManager {
    getConnectionStatus(): ConnectionStatus;
    isConnected(): boolean;
    isConnecting(): boolean;
    hasError(): boolean;
    connect(): Promise<void>;
    disconnect(): void;
    reconnect(): Promise<void>;
    onConnectionStatusChange(callback: (status: ConnectionStatus) => void): () => void;
    onReady(callback: () => void): void;
    onError(callback: (error: Error) => void): () => void;
}
/**
 * 标准的生命周期管理器
 */
interface StandardLifecycleManager {
    isReady(): boolean;
    isDestroyed(): boolean;
    ready(): Promise<void>;
    destroy(): void;
    onReady(callback: () => void): void;
    onDestroy(callback: () => void): void;
}

/**
 * 防抖函数
 * @param func 要防抖的函数
 * @param wait 等待时间（毫秒）
 * @param immediate 是否立即执行
 * @returns 防抖后的函数
 */
declare const debounce: <T extends (...args: any[]) => any>(func: T, wait: number, immediate?: boolean) => (...args: Parameters<T>) => void;
/**
 * 节流函数
 * @param func 要节流的函数
 * @param limit 限制时间（毫秒）
 * @returns 节流后的函数
 */
declare const throttle: <T extends (...args: any[]) => any>(func: T, limit: number) => (...args: Parameters<T>) => void;
/**
 * 深度克隆对象
 * @param obj 要克隆的对象
 * @returns 克隆后的对象
 */
declare const deepClone: <T>(obj: T) => T;
/**
 * 延迟执行
 * @param ms 延迟时间（毫秒）
 * @returns Promise
 */
declare const delay: (ms: number) => Promise<void>;
/**
 * 重试函数
 * @param fn 要重试的函数
 * @param maxAttempts 最大重试次数
 * @param delayMs 重试间隔（毫秒）
 * @returns Promise
 */
declare const retry: <T>(fn: () => Promise<T>, maxAttempts?: number, delayMs?: number) => Promise<T>;

/**
 * 1.x 版本兼容性配置
 * 用于与旧版本 SDK 进行通信
 */

/**
 * 获取 1.x 版本兼容的安全配置
 * 禁用严格的安全验证以支持通配符通信
 */
declare function getV1CompatibilityConfig$1(): BaseOptions<BaseMap>['security'];
/**
 * 获取混合环境配置
 * 在开发环境中保持宽松，生产环境中保持严格
 */
declare function getMixedEnvironmentConfig(isDevelopment?: boolean): BaseOptions<BaseMap>['security'];
/**
 * 检测是否为 1.x 版本环境
 * 通过检查 window 对象上的特定属性来判断
 */
declare function isV1Environment(): boolean;

/**
 * 兼容性层
 *
 * 提供 1.x 和 2.x 版本之间的兼容性支持
 *
 * @fileoverview 兼容性适配器和配置
 * @author Realsee
 * @version 2.0
 * @license MIT
 */

/**
 * 获取 1.x 版本的兼容配置
 *
 * 当 Remote 端使用 2.x 版本，需要与 1.x 版本的 Client 通信时使用此配置
 *
 * @returns 兼容 1.x 的安全配置
 *
 * @example
 * ```typescript
 * import { RealseeVRSignalsRemote, getV1CompatibilityConfig } from '@realsee/vr-signals'
 *
 * const remote = new RealseeVRSignalsRemote({
 *   logLevel: 'INFO',
 *   security: getV1CompatibilityConfig(),
 *   actionMap: {
 *     setState(data) {
 *       return { success: true }
 *     }
 *   }
 * })
 * ```
 */
declare function getV1CompatibilityConfig(): SecurityConfig;
/**
 * 获取自动兼容配置
 *
 * 自动检测并配置兼容性，平衡安全性和兼容性
 *
 * @returns 自动兼容配置
 *
 * @example
 * ```typescript
 * import { RealseeVRSignalsRemote, getAutoCompatibilityConfig } from '@realsee/vr-signals'
 *
 * const remote = new RealseeVRSignalsRemote({
 *   security: getAutoCompatibilityConfig()
 * })
 * ```
 */
declare function getAutoCompatibilityConfig(): SecurityConfig;
/**
 * 获取 2.x 版本的默认配置
 *
 * 用于 2.x Client 和 2.x Remote 之间的通信
 * 提供更高的安全性
 *
 * @param signatureKey 签名密钥（可选）
 * @returns 2.x 默认安全配置
 *
 * @example
 * ```typescript
 * import { RealseeVRSignalsRemote, getV2DefaultConfig } from '@realsee/vr-signals'
 *
 * const remote = new RealseeVRSignalsRemote({
 *   security: getV2DefaultConfig('my-secret-key')
 * })
 * ```
 */
declare function getV2DefaultConfig(signatureKey?: string): SecurityConfig;
/**
 * 检测消息是否来自 1.x 版本的 Client
 *
 * @param message 消息对象
 * @returns 是否来自 1.x Client
 */
declare function isV1Message(message: any): boolean;
/**
 * 检测消息是否来自 2.x 版本的 Client
 *
 * @param message 消息对象
 * @returns 是否来自 2.x Client
 */
declare function isV2Message(message: any): boolean;
/**
 * 适配 1.x 消息到 2.x 格式
 *
 * @param message 1.x 消息
 * @returns 2.x 格式的消息
 */
declare function adaptV1ToV2Message(message: any): any;
/**
 * 适配 2.x 消息到 1.x 格式
 *
 * @param message 2.x 消息
 * @returns 1.x 格式的消息
 */
declare function adaptV2ToV1Message(message: any): any;
/**
 * 兼容性检查结果
 */
interface CompatibilityCheckResult {
    /** 是否兼容 */
    compatible: boolean;
    /** 检测到的版本 */
    version: '1.x' | '2.x' | 'unknown';
    /** 建议的配置 */
    suggestedConfig: SecurityConfig;
    /** 警告信息 */
    warnings: string[];
}
/**
 * 检查兼容性并提供建议
 *
 * @param remoteVersion Remote 端版本
 * @param clientVersion Client 端版本（如果已知）
 * @returns 兼容性检查结果
 *
 * @example
 * ```typescript
 * const result = checkCompatibility('2.0', '1.0')
 * if (result.compatible) {
 *   console.log('兼容，使用配置:', result.suggestedConfig)
 * } else {
 *   console.warn('不兼容，警告:', result.warnings)
 * }
 * ```
 */
declare function checkCompatibility(remoteVersion: string, clientVersion?: string): CompatibilityCheckResult;
/**
 * 创建兼容性日志记录