/**
 * 日志级别枚举。
 */
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;
/**
 * 创建兼容性日志记录器
 *
 * @param remoteVersion Remote 版本
 * @param clientVersion Client 版本
 */
declare function logCompatibilityInfo(remoteVersion: string, clientVersion?: string): void;

export { type ActionExecuteOptions, type DefaultActionMap as ActionMap, type ActionRequestPayload, type ActionResponsePayload, Base, type BaseMap, type BaseOptions, type ClientOptions, type CompatibilityCheckResult, ConnectionStatus, type ConnectionStatusEvent, type DefaultActionMap, type DefaultEventMap, EventCategory, type DefaultEventMap as EventMap, EventNamespace, type EventPayload, EventType, EventTypeGroups, EventTypeUtils, type HandshakePayload, LegacyEventType, Logger, type Message, type MessageMap, type Mode, Client as RealseeVRSignalsClient, Remote as RealseeVRSignalsRemote, type RemoteOptions, type SecurityConfig, SecurityUtils, type StandardActionAPI, StandardActionManager, type StandardConnectionManager, type StandardEventListener, type StandardEventManager, type StandardEventOptions, StandardEventTarget, EventType as StandardEventType, EventTypeGroups as StandardEventTypeGroups, EventTypeUtils as StandardEventTypeUtils, type StandardLifecycleManager, type StandardVRSignalsAPI, type VRMonitor, type VRMonitorList, adaptV1ToV2Message, adaptV2ToV1Message, checkCompatibility, debounce, deepClone, delay, getAutoCompatibilityConfig, getMixedEnvironmentConfig, getV1CompatibilityConfig$1 as getV1CompatibilityConfig, getV1CompatibilityConfig as getV1Config, getV2DefaultConfig, isV1Environment, isV1Message, isV2Message, logCompatibilityInfo, retry, throttle };