@esengine/cocos-nexus/index.d.ts

类似Unity Odin Inspector的Cocos Creator插件开发框架 - 用TypeScript完全重新定义插件UI开发体验

interface NexusRect {
    x: number;
    y: number;
    width: number;
    height: number;
}
interface NexusColor {
    r: number;
    g: number;
    b: number;
    a: number;
}
interface NexusVector2 {
    x: number;
    y: number;
}
interface NexusTheme {
    name: string;
    colors: {
        primary: string;
        primaryDark: string;
        secondary: string;
        secondaryDark: string;
        background: string;
        surface: string;
        surfaceVariant: string;
        text: string;
        textSecondary: string;
        textOnPrimary: string;
        border: string;
        borderLight: string;
        success: string;
        warning: string;
        error: string;
        info: string;
    };
    spacing: {
        xs: number;
        sm: number;
        md: number;
        lg: number;
        xl: number;
    };
    fonts: {
        primary: string;
        secondary: string;
        mono: string;
    };
    fontSize: {
        xs: number;
        sm: number;
        md: number;
        lg: number;
        xl: number;
    };
    borderRadius: {
        sm: number;
        md: number;
        lg: number;
    };
    shadows: {
        sm: string;
        md: string;
        lg: string;
    };
    animations: {
        duration: {
            fast: number;
            normal: number;
            slow: number;
        };
        easing: {
            ease: string;
            easeIn: string;
            easeOut: string;
            easeInOut: string;
        };
    };
}
interface NexusThemeVariables {
    [key: string]: string | number;
}
interface NexusStyle {
    backgroundColor?: NexusColor;
    borderColor?: NexusColor;
    borderWidth?: number;
    borderRadius?: number;
    padding?: number | {
        top?: number;
        right?: number;
        bottom?: number;
        left?: number;
    };
    margin?: number | {
        top?: number;
        right?: number;
        bottom?: number;
        left?: number;
    };
    fontSize?: number;
    fontColor?: NexusColor;
    fontWeight?: 'normal' | 'bold';
    textAlign?: 'left' | 'center' | 'right';
    width?: number | string;
    height?: number | string;
    minWidth?: number;
    minHeight?: number;
    maxWidth?: number;
    maxHeight?: number;
    theme?: string;
    variant?: 'primary' | 'secondary' | 'success' | 'warning' | 'error' | 'info';
}
interface NexusLayoutOptions {
    direction?: 'horizontal' | 'vertical';
    spacing?: number;
    align?: 'start' | 'center' | 'end' | 'stretch';
    justify?: 'start' | 'center' | 'end' | 'space-between' | 'space-around';
    wrap?: boolean;
}
interface NexusEvent {
    type: string;
    target?: any;
    preventDefault(): void;
    stopPropagation(): void;
}
interface NexusMouseEvent extends NexusEvent {
    x: number;
    y: number;
    button: number;
    ctrlKey: boolean;
    shiftKey: boolean;
    altKey: boolean;
}
interface NexusKeyboardEvent extends NexusEvent {
    key: string;
    keyCode: number;
    ctrlKey: boolean;
    shiftKey: boolean;
    altKey: boolean;
}
interface NexusComponent {
    render(): void;
    update?(): void;
    destroy?(): void;
}
interface NexusPanelConfig {
    title: string;
    width?: number;
    height?: number;
    minWidth?: number;
    minHeight?: number;
    resizable?: boolean;
    closable?: boolean;
    dockable?: boolean;
    modal?: boolean;
    theme?: string;
}
interface NexusPluginConfig {
    name: string;
    version: string;
    description?: string;
    author?: string;
    dependencies?: string[];
    panels?: {
        [key: string]: NexusPanelConfig;
    };
    menu?: NexusMenuConfig[];
    assets?: NexusAssetConfig;
    theme?: NexusTheme | string;
    permissions?: string[];
    sandbox?: boolean;
    hotReload?: boolean;
    errorHandling?: {
        isolate?: boolean;
        fallback?: () => void;
        retry?: boolean;
        maxRetries?: number;
    };
}
interface NexusMenuConfig {
    path: string;
    label: string;
    action: string;
    enabled?: boolean;
    icon?: string;
}
interface NexusAssetConfig {
    menu?: {
        methods: string;
        assetMenu: string;
    };
}
interface NexusError {
    code: string;
    message: string;
    stack?: string;
    source?: string;
    recoverable?: boolean;
}
interface NexusErrorHandler {
    handle(error: NexusError): void;
    canRecover(error: NexusError): boolean;
    recover(error: NexusError): Promise<boolean>;
}
interface NexusDependency {
    name: string;
    version: string;
    required?: boolean;
    optional?: boolean;
}
interface NexusVersion {
    major: number;
    minor: number;
    patch: number;
    preRelease?: string;
    build?: string;
}
declare const NEXUS_PLUGIN_METADATA: unique symbol;
declare const NEXUS_PANEL_METADATA: unique symbol;
declare const NEXUS_COMPONENT_METADATA: unique symbol;
declare const NEXUS_PROPERTY_METADATA: unique symbol;
declare const NEXUS_THEME_METADATA: unique symbol;
interface NexusPropertyOptions {
    label?: string;
    tooltip?: string;
    readonly?: boolean;
    min?: number;
    max?: number;
    step?: number;
    multiline?: boolean;
    password?: boolean;
    placeholder?: string;
    options?: string[] | {
        [key: string]: any;
    };
    validator?: (value: any) => boolean | string;
    onChange?: (value: any) => void;
}

/**
 * 依赖注入令牌
 */
interface InjectionToken<T = any> {
    description?: string;
    providedIn?: 'root' | 'plugin' | 'panel';
}
/**
 * 依赖提供者
 */
interface Provider<T = any> {
    provide: InjectionToken<T> | string;
    useClass?: new (...args: any[]) => T;
    useValue?: T;
    useFactory?: (...args: any[]) => T;
    deps?: (InjectionToken<any> | string)[];
    multi?: boolean;
}
/**
 * 依赖注入容器
 */
declare class DependencyInjector {
    private providers;
    private instances;
    private resolving;
    /**
     * 注册提供者
     */
    register<T>(provider: Provider<T>): void;
    /**
     * 解析依赖
     */
    resolve<T>(token: InjectionToken<T> | string): T;
    /**
     * 获取令牌描述
     */
    private getTokenDescription;
    /**
     * 清空容器
     */
    clear(): void;
}
/**
 * 版本比较工具
 */
declare class VersionComparator {
    /**
     * 解析版本字符串
     */
    static parseVersion(version: string): NexusVersion;
    /**
     * 比较版本
     * @returns -1 if a < b, 0 if a == b, 1 if a > b
     */
    static compareVersions(a: string | NexusVersion, b: string | NexusVersion): number;
    /**
     * 检查版本是否兼容
     */
    static isCompatible(required: string, actual: string): boolean;
    /**
     * 获取版本范围内的最新版本
     */
    static getLatestCompatibleVersion(required: string, availableVersions: string[]): string | null;
}
/**
 * 依赖解析结果
 */
interface DependencyResolutionResult {
    resolved: Map<string, {
        version: string;
        instance?: any;
    }>;
    missing: string[];
    incompatible: Array<{
        name: string;
        required: string;
        actual: string;
    }>;
    circular: string[];
}
/**
 * Nexus依赖管理器
 */
declare class NexusDependencyManager {
    private static instance;
    private registeredDependencies;
    private dependencyGraph;
    private injector;
    private loadOrder;
    private constructor();
    static getInstance(): NexusDependencyManager;
    /**
     * 注册核心依赖
     */
    private registerCoreDependencies;
    /**
     * 注册依赖
     */
    registerDependency(name: string, version: string, instance?: any): void;
    /**
     * 注册依赖图
     */
    registerDependencyGraph(pluginName: string, dependencies: NexusDependency[]): void;
    /**
     * 解析依赖
     */
    resolveDependencies(pluginName: string): DependencyResolutionResult;
    /**
     * 计算加载顺序
     */
    calculateLoadOrder(plugins: string[]): string[];
    /**
     * 获取依赖实例
     */
    getDependency<T>(name: string): T | undefined;
    /**
     * 注入依赖
     */
    inject<T>(token: InjectionToken<T> | string): T;
    /**
     * 注册提供者
     */
    registerProvider<T>(provider: Provider<T>): void;
    /**
     * 获取依赖图
     */
    getDependencyGraph(): Map<string, NexusDependency[]>;
    /**
     * 获取已注册的依赖
     */
    getRegisteredDependencies(): Map<string, {
        version: string;
        instance?: any;
    }>;
    /**
     * 检查依赖健康状态
     */
    checkDependencyHealth(): {
        healthy: boolean;
        issues: Array<{
            type: 'missing' | 'incompatible' | 'circular';
            plugin: string;
            dependency?: string;
            message: string;
        }>;
    };
    /**
     * 获取依赖统计
     */
    getDependencyStats(): {
        totalDependencies: number;
        totalPlugins: number;
        averageDependenciesPerPlugin: number;
        mostDependentPlugin: {
            name: string;
            count: number;
        };
        circularDependencies: number;
    };
    /**
     * 导出依赖图
     */
    exportDependencyGraph(): string;
    /**
     * 导入依赖图
     */
    importDependencyGraph(graphJson: string): void;
    /**
     * 清空依赖管理器
     */
    clear(): void;
}
declare function Injectable(token?: string): ClassDecorator;
declare function Inject(token: string | InjectionToken): ParameterDecorator;
declare const DependencyManager: NexusDependencyManager;

/**
 * @fileoverview Nexus错误管理系统 - 智能错误处理和恢复机制
 * @description 提供完整的错误处理功能，包含错误分类、智能恢复、插件沙盒等
 *
 * @author ESEngine Team
 * @version 2.1.0
 * @since 1.0.0
 * @license MIT
 *
 * @example
 * ```typescript
 * const errorManager = NexusErrorManager.getInstance();
 *
 * // 创建插件沙盒
 * const sandbox = errorManager.createPluginSandbox('my-plugin');
 *
 * // 安全执行代码
 * sandbox.execute(() => {
 *   // 可能出错的代码
 * });
 *
 * // 注册恢复策略
 * errorManager.registerRecoveryStrategy('TypeError', new TypeErrorRecoveryStrategy());
 * ```
 */

/**
 * 错误级别枚举
 *
 * @description 定义错误的严重程度级别，从低到高依次为：DEBUG < INFO < WARN < ERROR < FATAL
 * @enum {string}
 * @since 1.0.0
 */
declare enum ErrorLevel {
    /** 调试信息 - 仅在开发环境显示 */
    DEBUG = "debug",
    /** 一般信息 - 正常运行日志 */
    INFO = "info",
    /** 警告信息 - 需要注意但不影响运行 */
    WARN = "warn",
    /** 错误信息 - 影响功能但可恢复 */
    ERROR = "error",
    /** 致命错误 - 导致系统崩溃 */
    FATAL = "fatal"
}
/**
 * 插件状态枚举
 *
 * @description 定义插件的运行状态
 * @enum {string}
 * @since 2.1.0
 */
declare enum PluginState {
    /** 未知状态 */
    UNKNOWN = "unknown",
    /** 正在加载 */
    LOADING = "loading",
    /** 已加载 */
    LOADED = "loaded",
    /** 运行中 */
    RUNNING = "running",
    /** 出现错误 */
    ERROR = "error",
    /** 已隔离 */
    QUARANTINED = "quarantined",
    /** 恢复中 */
    RECOVERING = "recovering"
}
/**
 * 错误分类枚举
 *
 * @description 定义错误的分类类型
 * @enum {string}
 * @since 2.1.0
 */
declare enum ErrorCategory {
    /** 类型错误 */
    TYPE_ERROR = "TYPE_ERROR",
    /** 引用错误 */
    REFERENCE_ERROR = "REFERENCE_ERROR",
    /** 依赖错误 */
    DEPENDENCY_ERROR = "DEPENDENCY_ERROR",
    /** 权限错误 */
    PERMISSION_ERROR = "PERMISSION_ERROR",
    /** 网络错误 */
    NETWORK_ERROR = "NETWORK_ERROR",
    /** 语法错误 */
    SYNTAX_ERROR = "SYNTAX_ERROR",
    /** 运行时错误 */
    RUNTIME_ERROR = "RUNTIME_ERROR",
    /** 资源错误 */
    RESOURCE_ERROR = "RESOURCE_ERROR",
    /** 未知错误 */
    UNKNOWN_ERROR = "UNKNOWN_ERROR"
}
/**
 * 错误上下文接口
 *
 * @description 提供错误发生时的详细上下文信息
 * @interface ErrorContext
 * @since 1.0.0
 */
interface ErrorContext {
    /** 插件名称 */
    pluginName?: string;
    /** 面板名称 */
    panelName?: string;
    /** 组件名称 */
    componentName?: string;
    /** 方法名称 */
    methodName?: string;
    /** 时间戳 */
    timestamp: number;
    /** 用户代理 */
    userAgent?: string;
    /** 页面URL */
    url?: string;
    /** 用户ID */
    userId?: string;
    /** 会话ID */
    sessionId?: string;
    /** 额外信息 */
    additionalInfo?: any;
    /** 错误分类 */
    category?: ErrorCategory;
    /** 是否可恢复 */
    recoverable?: boolean;
}
/**
 * 错误恢复策略接口
 *
 * @description 定义错误恢复策略的标准接口
 * @interface RecoveryStrategy
 * @since 2.1.0
 */
interface RecoveryStrategy {
    /**
     * 检查是否可以恢复指定错误
     *
     * @param error 错误对象
     * @param context 错误上下文
     * @returns 是否可以恢复
     */
    canRecover(error: any, context: ErrorContext): boolean;
    /**
     * 执行错误恢复
     *
     * @param error 错误对象
     * @param context 错误上下文
     * @param pluginState 插件状态
     * @returns 恢复结果
     */
    recover(error: any, context: ErrorContext, pluginState: PluginState): Promise<boolean>;
    /**
     * 获取策略描述
     *
     * @returns 策略描述
     */
    getDescription(): string;
}
/**
 * 错误监听器类型
 *
 * @description 错误事件监听器函数类型
 * @since 1.0.0
 */
interface ErrorListener {
    (error: NexusError, context: ErrorContext): void;
}
/**
 * 插件沙盒
 */
declare class PluginSandbox {
    private pluginName;
    private errorManager;
    private isolateErrors;
    private maxRetries;
    private currentRetries;
    private isQuarantined;
    constructor(pluginName: string, errorManager: NexusErrorManager, isolateErrors?: boolean, maxRetries?: number);
    /**
     * 在沙盒中执行函数
     */
    execute<T>(fn: () => T, context?: Partial<ErrorContext>): T | null;
    /**
     * 在沙盒中执行异步函数
     */
    executeAsync<T>(fn: () => Promise<T>, context?: Partial<ErrorContext>): Promise<T | null>;
    /**
     * 处理错误
     */
    private handleError;
    /**
     * 隔离插件
     */
    private quarantine;
    /**
     * 重置沙盒状态
     */
    reset(): void;
    /**
     * 获取沙盒状态
     */
    getStatus(): {
        isQuarantined: boolean;
        currentRetries: number;
        maxRetries: number;
    };
}
/**
 * Nexus错误管理器
 */
declare class NexusErrorManager {
    private static instance;
    private errorHandlers;
    private errorListeners;
    private errorHistory;
    private sandboxes;
    private maxHistorySize;
    private globalErrorHandlingEnabled;
    private constructor();
    static getInstance(): NexusErrorManager;
    /**
     * 设置全局错误处理
     */
    private setupGlobalErrorHandling;
    /**
     * 处理全局错误
     */
    private handleGlobalError;
    /**
     * 注册错误处理器
     */
    registerErrorHandler(name: string, handler: NexusErrorHandler): void;
    /**
     * 注销错误处理器
     */
    unregisterErrorHandler(name: string): void;
    /**
     * 添加错误监听器
     */
    addErrorListener(listener: ErrorListener): void;
    /**
     * 移除错误监听器
     */
    removeErrorListener(listener: ErrorListener): void;
    /**
     * 创建插件沙盒
     */
    createPluginSandbox(pluginName: string, isolateErrors?: boolean, maxRetries?: number): PluginSandbox;
    /**
     * 获取插件沙盒
     */
    getPluginSandbox(pluginName: string): PluginSandbox | undefined;
    /**
     * 报告错误
     */
    reportError(error: NexusError, context: ErrorContext): void;
    /**
     * 添加到历史记录
     */
    private addToHistory;
    /**
     * 调用错误处理器
     */
    private invokeErrorHandlers;
    /**
     * 通知监听器
     */
    private notifyListeners;
    /**
     * 记录错误日志
     */
    private logError;
    /**
     * 获取日志级别
     */
    private getLogLevel;
    /**
     * 格式化日志消息
     */
    private formatLogMessage;
    /**
     * 通知插件被隔离
     */
    notifyPluginQuarantined(pluginName: string): void;
    /**
     * 获取错误历史
     */
    getErrorHistory(): Array<{
        error: NexusError;
        context: ErrorContext;
    }>;
    /**
     * 清空错误历史
     */
    clearErrorHistory(): void;
    /**
     * 获取错误统计
     */
    getErrorStats(): {
        totalErrors: number;
        errorsBySource: Map<string, number>;
        errorsByCode: Map<string, number>;
        recentErrors: number;
    };
    /**
     * 启用/禁用全局错误处理
     */
    setGlobalErrorHandling(enabled: boolean): void;
    /**
     * 获取所有沙盒状态
     */
    getSandboxStatuses(): Map<string, any>;
    /**
     * 重置所有沙盒
     */
    resetAllSandboxes(): void;
    /**
     * 销毁错误管理器
     */
    destroy(): void;
}
/**
 * 默认错误处理器
 */
declare class DefaultErrorHandler implements NexusErrorHandler {
    handle(error: NexusError): void;
    canRecover(error: NexusError): boolean;
    recover(error: NexusError): Promise<boolean>;
}
declare const ErrorManager: NexusErrorManager;

/**
 * Nexus主题管理器
 * 负责主题注册、切换、CSS变量管理等
 */
declare class NexusThemeManager {
    private static instance;
    private themes;
    private currentTheme;
    private cssVariables;
    private styleElement;
    private constructor();
    static getInstance(): NexusThemeManager;
    /**
     * 初始化默认主题
     */
    private initializeDefaultThemes;
    /**
     * 创建样式元素
     */
    private createStyleElement;
    /**
     * 注册主题
     */
    registerTheme(name: string, theme: NexusTheme): void;
    /**
     * 获取主题
     */
    getTheme(name: string): NexusTheme | undefined;
    /**
     * 获取当前主题
     */
    getCurrentTheme(): NexusTheme | undefined;
    /**
     * 获取所有主题名称
     */
    getThemeNames(): string[];
    /**
     * 切换主题
     */
    setTheme(name: string): boolean;
    /**
     * 更新CSS变量
     */
    private updateCSSVariables;
    /**
     * 生成CSS变量
     */
    private generateCSSVariables;
    /**
     * 将驼峰命名转换为kebab-case
     */
    private kebabCase;
    /**
     * 触发主题变更事件
     */
    private dispatchThemeChangeEvent;
    /**
     * 获取CSS变量值
     */
    getCSSVariable(name: string): string;
    /**
     * 设置CSS变量
     */
    setCSSVariable(name: string, value: string): void;
    /**
     * 获取主题变量
     */
    getThemeVariables(themeName?: string): NexusThemeVariables;
    /**
     * 重置为默认主题
     */
    resetToDefault(): void;
    /**
     * 销毁主题管理器
     */
    destroy(): void;
}
declare const ThemeManager: NexusThemeManager;

/**
 * Nexus插件基类
 *
 * @description 提供插件开发的核心功能，包括：
 * - 插件生命周期管理
 * - 错误处理和插件沙盒
 * - 主题系统集成
 * - 依赖管理
 * - 自动注册和安装
 *
 * @public
 * @abstract
 * @since 1.0.0
 * @version 2.0.0
 *
 * @example
 * ```typescript
 * @Plugin({
 *   name: 'example-plugin',
 *   version: '1.0.0'
 * })
 * class ExamplePlugin extends NexusPlugin {
 *   public onLoad(): void {
 *     console.log('插件加载完成');
 *   }
 *
 *   public onUnload(): void {
 *     console.log('插件卸载');
 *   }
 * }
 * ```
 *
 * @see {@link NexusPluginConfig} 插件配置接口
 * @see {@link NexusExtension} 扩展管理器
 */
declare abstract class NexusPlugin {
    /**
     * 插件配置对象
     *
     * @description 包含插件的基本信息和配置选项，在插件实例化时传入。
     * 配置内容包括插件名称、版本、依赖关系、主题设置等。
     *
     * @protected
     * @readonly
     * @since 1.0.0
     *
     * @example
     * ```typescript
     * const config: NexusPluginConfig = {
     *   name: 'my-plugin',
     *   version: '1.0.0',
     *   dependencies: ['other-plugin']
     * };
     * ```
     */
    protected readonly config: NexusPluginConfig;
    /**
     * 主题管理器实例
     *
     * @description 用于管理插件的主题样式，支持动态主题切换
     * @protected
     * @readonly
     * @since 1.0.0
     */
    protected readonly themeManager: NexusThemeManager;
    /**
     * 错误管理器实例
     *
     * @description 用于处理插件运行过程中的错误，提供错误隔离和恢复机制
     * @protected
     * @readonly
     * @since 1.0.0
     */
    protected readonly errorManager: NexusErrorManager;
    /**
     * 依赖管理器实例
     *
     * @description 用于管理插件间的依赖关系，确保正确的加载顺序
     * @protected
     * @readonly
     * @since 1.0.0
     */
    protected readonly dependencyManager: NexusDependencyManager;
    /**
     * 插件沙盒实例
     *
     * @description 提供插件运行的隔离环境，防止错误影响其他插件
     * @protected
     * @readonly
     * @since 2.0.0
     */
    protected readonly sandbox: PluginSandbox;
    /**
     * 插件初始化状态
     *
     * @description 标识插件是否已经初始化完成
     * @protected
     * @since 1.0.0
     */
    protected isInitialized: boolean;
    /**
     * 构造函数
     *
     * @description 初始化插件实例，创建沙盒环境并注册依赖
     * @param config 插件配置对象
     *
     * @since 1.0.0
     * @version 2.0.0
     */
    constructor(config: NexusPluginConfig);
    /**
     * 初始化主题
     *
     * @description 根据插件配置初始化主题，支持字符串主题名称或自定义主题对象
     * @protected
     * @since 2.0.0
     */
    protected initializeTheme(): void;
    /**
     * 注册依赖
     *
     * @description 将插件及其依赖关系注册到依赖管理器中
     * @protected
     * @since 2.0.0
     */
    protected registerDependencies(): void;
    /**
     * 插件加载时调用
     *
     * @description 插件加载时的生命周期方法，子类必须实现。
     * 在此方法中进行插件的初始化工作，如注册面板、菜单项等。
     *
     * @public
     * @abstract
     * @since 1.0.0
     *
     * @example
     * ```typescript
     * public onLoad(): void {
     *   console.log('插件加载完成');
     *   this.registerPanel('my-panel', new MyPanel());
     * }
     * ```
     */
    abstract onLoad(): void;
    /**
     * 插件卸载时调用
     *
     * @description 插件卸载时的生命周期方法，子类必须实现。
     * 在此方法中进行插件的清理工作，如注销面板、清理资源等。
     *
     * @public
     * @abstract
     * @since 1.0.0
     *
     * @example
     * ```typescript
     * public onUnload(): void {
     *   console.log('插件卸载');
     *   this.clearAllPanels();
     * }
     * ```
     */
    abstract onUnload(): void;
    /**
     * 获取插件配置
     *
     * @description 返回插件的配置对象，包含插件的元数据和设置
     * @returns 插件配置对象
     * @public
     * @since 1.0.0
     */
    getConfig(): NexusPluginConfig;
    /**
     * 获取插件名称
     *
     * @description 返回插件的唯一标识符
     * @returns 插件名称字符串
     * @public
     * @since 1.0.0
     */
    getName(): string;
    /**
     * 获取插件版本
     *
     * @description 返回插件的版本号，遵循语义化版本规范
     * @returns 插件版本字符串
     * @public
     * @since 1.0.0
     */
    getVersion(): string;
    /**
     * 安全加载插件
     *
     * @description 在错误隔离的沙盒环境中加载插件，确保插件错误不会影响框架稳定性。
     * 如果插件加载失败，会记录错误信息并尝试恢复。
     *
     * @public
     * @returns {boolean} 加载成功返回true，失败返回false
     *
     * @throws {NexusError} 当插件配置无效时抛出
     *
     * @example
     * ```typescript
     * const plugin = new MyPlugin(config);
     * if (plugin.safeLoad()) {
     *   console.log('插件加载成功');
     * } else {
     *   console.error('插件加载失败');
     * }
     * ```
     *
     * @since 2.0.0
     * @version 2.0.0
     */
    safeLoad(): boolean;
    /**
     * 安全卸载插件
     *
     * @description 在错误隔离的沙盒环境中卸载插件，确保卸载过程不会影响其他插件。
     * 如果卸载失败，会记录错误信息并尝试强制清理。
     *
     * @public
     * @returns {boolean} 卸载成功返回true，失败返回false
     *
     * @example
     * ```typescript
     * if (plugin.safeUnload()) {
     *   console.log('插件卸载成功');
     * } else {
     *   console.error('插件卸载失败');
     * }
     * ```
     *
     * @since 2.0.0
     * @version 2.0.0
     */
    safeUnload(): boolean;
    /**
     * 获取插件状态
     *
     * @description 返回插件的详细状态信息，包括初始化状态、沙盒状态、主题状态和依赖状态
     * @returns 插件状态对象
     * @public
     * @since 2.0.0
     *
     * @example
     * ```typescript
     * const status = plugin.getStatus();
     * console.log(`插件 ${status.name} 状态:`, status);
     * ```
     */
    getStatus(): {
        name: string;
        version: string;
        initialized: boolean;
        sandboxStatus: any;
        themeApplied: boolean;
        dependenciesResolved: boolean;
    };
    /**
     * 自动注册插件到Nexus系统
     *
     * @description 将插件实例自动注册到Nexus扩展系统中，无需手动调用。
     * 这是框架的核心功能之一，实现了插件的自动发现和注册机制。
     *
     * @public
     * @since 2.0.0
     *
     * @example
     * ```typescript
     * const plugin = new MyPlugin(config);
     * plugin.autoRegister(); // 自动注册到系统
     * ```
     */
    autoRegister(): void;
    /**
     * 自动生成并安装到Cocos Creator
     *
     * @description 一键生成所有必要的文件和配置，包括main.ts、package.json、面板文件等。
     * 这是框架的终极功能，实现了从插件代码到Cocos Creator扩展的完全自动化。
     *
     * @public
     * @returns 安装结果对象，包含成功状态、生成的文件列表和消息
     * @since 2.0.0
     *
     * @example
     * ```typescript
     * const plugin = new MyPlugin(config);
     * const result = plugin.autoInstall();
     * if (result.success) {
     *   console.log('插件安装成功');
     *   console.log('生成的文件:', result.files);
     * } else {
     *   console.error('插件安装失败:', result.message);
     * }
     * ```
     */
    autoInstall(): {
        success: boolean;
        files: {
            [path: string]: string;
        };
        message: string;
    };
}
/**
 * 插件装饰器
 *
 * @description 用于标记类为Nexus插件的装饰器，将插件配置信息附加到类的元数据中。
 * 框架会在运行时读取这些元数据来管理插件的生命周期。
 *
 * @param config 插件配置对象
 * @returns 装饰器函数
 *
 * @public
 * @decorator
 * @since 1.0.0
 *
 * @example
 * ```typescript
 * @Plugin({
 *   name: 'my-plugin',
 *   version: '1.0.0',
 *   description: '我的第一个插件'
 * })
 * class MyPlugin extends NexusPlugin {
 *   public onLoad(): void {
 *     console.log('插件加载完成');
 *   }
 *
 *   public onUnload(): void {
 *     console.log('插件卸载');
 *   }
 * }
 * ```
 */
declare function Plugin(config: NexusPluginConfig): <T extends {
    new (...args: any[]): NexusPlugin;
}>(constructor: T) => T;

/**
 * @fileoverview Cocos Creator 扩展配置生成器
 * @description 自动生成符合 Cocos Creator 标准的扩展配置，提供完整的集成支持
 *
 * @author ESEngine Team
 * @version 2.1.0
 * @since 2.1.0
 * @license MIT
 *
 * @example
 * ```typescript
 * const generator = new CocosExtensionGenerator();
 *
 * // 生成扩展配置
 * const config = generator.generateExtensionConfig(pluginInstance);
 *
 * // 写入配置文件
 * generator.writeExtensionFiles('./extensions/my-extension', config);
 * ```
 */

/**
 * 增强的插件配置接口
 *
 * @description 符合 Cocos Creator 扩展标准的完整配置接口
 * @interface EnhancedNexusPluginConfig
 * @since 2.1.0
 */
interface EnhancedNexusPluginConfig {
    /** 插件名称 */
    name: string;
    /** 插件版本 */
    version: string;
    /** 插件描述 */
    description?: string;
    /** 作者信息 */
    author?: string;
    /** 显示名称 */
    displayName?: string;
    /** 扩展图标路径 */
    icon?: string;
    /** 主入口文件 */
    main?: string;
    /** 支持的 Cocos Creator 版本 */
    engines?: {
        'cocos-creator': string;
    };
    /** 依赖列表 */
    dependencies?: string[];
    /** 面板配置 */
    panels?: {
        [key: string]: {
            title: string;
            type?: 'dockable' | 'simple';
            main?: string;
            icon?: string;
            dockable?: boolean;
            resizable?: boolean;
            minWidth?: number;
            minHeight?: number;
            width?: number;
            height?: number;
        };
    };
    /** 菜单配置 */
    menu?: Array<{
        path: string;
        label: string;
        message: string;
        group?: string;
        order?: number;
    }>;
    /** 快捷键配置 */
    shortcuts?: Array<{
        message: string;
        when: string;
        win: string;
        mac: string;
    }>;
    /** 扩展贡献配置 */
    contributions?: {
        profile?: {
            editor?: {
                label: string;
                icon?: string;
            };
            project?: {
                label: string;
                icon?: string;
            };
        };
        menu?: Array<{
            path: string;
            label: string;
            message: string;
            group?: string;
            order?: number;
        }>;
        messages?: {
            [key: string]: {
                methods: string[];
                public?: boolean;
                doc?: string;
            };
        };
        shortcuts?: Array<{
            message: string;
            when: string;
            win: string;
            mac: string;
        }>;
        panels?: {
            [key: string]: {
                title: string;
                type: 'dockable' | 'simple';
                main: string;
                icon?: string;
                flags?: {
                    resizable?: boolean;
                    save_layout?: boolean;
                };
                size?: {
                    'min-width'?: number;
                    'min-height'?: number;
                    width?: number;
                    height?: number;
                };
            };
        };
    };
}
/**
 * Cocos Creator 扩展配置接口
 *
 * @description 标准的 Cocos Creator 扩展配置格式
 * @interface CocosExtensionConfig
 * @since 2.1.0
 */
interface CocosExtensionConfig {
    /** 扩展名称 */
    name: string;
    /** 扩展版本 */
    version: string;
    /** 扩展描述 */
    description: string;
    /** 作者信息 */
    author: string;
    /** 主入口文件 */
    main: string;
    /** 扩展贡献 */
    contributions: {
        profile?: {
            editor?: {
                label: string;
                icon?: string;
            };
            project?: {
                label: string;
                icon?: string;
            };
        };
        menu?: Array<{
            path: string;
            label: string;
            message: string;
            group?: string;
            order?: number;
        }>;
        messages?: {
            [key: string]: {
                methods: string[];
                public?: boolean;
                doc?: string;
            };
        };
        shortcuts?: Array<{
            message: string;
            when: string;
            win: string;
            mac: string;
        }>;
        panels?: {
            [key: string]: {
                title: string;
                type: 'dockable' | 'simple';
                main: string;
                icon?: string;
                flags?: {
                    resizable?: boolean;
                    save_layout?: boolean;
                };
                size?: {
                    'min-width'?: number;
                    'min-height'?: number;
                    width?: number;
                    height?: number;
                };
            };
        };
    };
    /** 支持的引擎版本 */
    engines: {
        'cocos-creator': string;
    };
    /** 依赖项 */
    dependencies?: {
        [key: string]: string;
    };
    /** Nexus 特定配置 */
    nexus?: {
        generated: boolean;
        timestamp: string;
        version: string;
    };
}
/**
 * Cocos Creator 扩展配置生成器
 *
 * @description 自动生成符合 Cocos Creator 标准的扩展配置和文件结构
 * 支持以下功能：
 * - 自动生成 package.json 配置
 * - 创建标准的文件结构
 * - 生成面板和消息配置
 * - 支持菜单和快捷键集成
 * - 提供完整的开发工具支持
 *
 * @class CocosExtensionGenerator
 * @since 2.1.0
 *
 * @example
 * ```typescript
 * const generator = new CocosExtensionGenerator();
 *
 * // 从插件实例生成配置
 * const plugin = new MyPlugin();
 * const config = generator.generateFromPlugin(plugin);
 *
 * // 写入扩展文件
 * await generator.writeExtensionFiles('./extensions/my-extension', config);
 *
 * // 验证配置
 * const validation = generator.validateConfig(config);
 * if (validation.valid) {
 *   console.log('配置验证通过');
 * }
 * ```
 */
declare class CocosExtensionGenerator {
    private readonly TEMPLATE_VERSION;
    private readonly DEFAULT_COCOS_VERSION;
    /**
     * 构造函数
     *
     * @since 2.1.0
     */
    constructor();
    /**
     * 从插件实例生成扩展配置
     *
     * @param plugin 插件实例
     * @returns 生成的扩展配置
     *
     * @public
     * @since 2.1.0
     */
    generateFromPlugin(plugin: NexusPlugin): CocosExtensionConfig;
    /**
     * 生成完整的扩展配置
     *
     * @param config 插件配置
     * @returns 扩展配置对象
     *
     * @public
     * @since 2.1.0
     */
    generateExtensionConfig(config: EnhancedNexusPluginConfig): CocosExtensionConfig;
    /**
     * 生成扩展配置文件
     *
     * @param config 扩展配置
     * @returns JSON 字符串
     *
     * @public
     * @since 2.1.0
     */
    generatePackageJson(config: CocosExtensionConfig): string;
    /**
     * 生成主入口文件
     *
     * @param config 扩展配置
     * @returns 主文件内容
     *
     * @public
     * @since 2.1.0
     */
    generateMainFile(config: CocosExtensionConfig): string;
    /**
     * 生成面板文件
     *
     * @param panelName 面板名称
     * @param panelConfig 面板配置
     * @returns 面板文件内容
     *
     * @public
     * @since 2.1.0
     */
    generatePanelFile(panelName: string, panelConfig: any): string;
    /**
     * 写入扩展文件到指定目录
     *
     * @param outputDir 输出目录
     * @param config 扩展配置
     * @returns 写入结果
     *
     * @public
     * @since 2.1.0
     */
    writeExtensionFiles(outputDir: string, config: CocosExtensionConfig): Promise<{
        success: boolean;
        files: string[];
        errors: string[];
    }>;
    /**
     * 验证扩展配置
     *
     * @param config 扩展配置
     * @returns 验证结果
     *
     * @public
     * @since 2.1.0
     */
    validateConfig(config: CocosExtensionConfig): {
        valid: boolean;
        errors: string[];
        warnings: string[];
    };
    /**
     * 规范化扩展名称
     *
     * @private
     * @param name 原始名称
     * @returns 规范化后的名称
     */
    private sanitizeName;
    /**
     * 生成Profile贡献
     *
     * @private
     * @param config 插件配置
     * @returns Profile贡献配置
     */
    private generateProfileContributions;
    /**
     * 生成菜单贡献
     *
     * @private
     * @param config 插件配置
     * @returns 菜单贡献配置
     */
    private generateMenuContributions;
    /**
     * 生成消息贡献
     *
     * @private
     * @param config 插件配置
     * @returns 消息贡献配置
     */
    private generateMessageContributions;
    /**
     * 生成面板贡献
     *
     * @private
     * @param config 插件配置
     * @returns 面板贡献配置
     */
    private generatePanelContributions;
    /**
     * 生成快捷键贡献
     *
     * @private
     * @param config 插件配置
     * @returns 快捷键贡献配置
     */
    private generateShortcutContributions;
    /**
     * 生成依赖项
     *
     * @private
     * @param config 插件配置
     * @returns 依赖项配置
     */
    private generateDependencies;
    /**
     * 生成面板方法
     *
     * @private
     * @param config 扩展配置
     * @returns 面板方法代码
     */
    private generatePanelMethods;
    /**
     * 生成消息方法
     *
     * @private
     * @param config 扩展配置
     * @returns 消息方法代码
     */
    private generateMessageMethods;
    /**
     * 生成 README 内容
     *
     * @private
     * @param config 扩展配置
     * @returns README 内容
     */
    private generateReadme;
    /**
     * 创建默认图标
     *
     * @private
     * @param iconPath 图标路径
     */
    private createDefaultIcon;
    /**
     * 首字母大写
     *
     * @private
     * @param str 字符串
     * @returns 首字母大写的字符串
     */
    private capitalize;
}
declare const ExtensionGenerator: CocosExtensionGenerator;

/**
 * @fileoverview Nexus自动文件监听器 - 高性能零配置文件监听系统
 * @description 提供高性能的文件监听功能，包含防抖机制、智能过滤、性能监控和内存优化
 *
 * @author ESEngine Team
 * @version 2.1.0
 * @since 1.0.0
 * @license MIT
 *
 * @example
 * ```typescript
 * const watcher = NexusAutoWatcher.getInstance();
 * watcher.start();
 *
 * // 获取性能指标
 * const metrics = watcher.getPerformanceMetrics();
 * console.log('监听性能:', metrics);
 *
 * // 自定义过滤规则
 * watcher.addFilterRule(/\.test\.ts$/, 'exclude', 10);
 * ```
 */
/**
 * 自动监听器配置接口
 *
 * @interface AutoWatcherConfig
 * @since 1.0.0
 */
interface AutoWatcherConfig {
    /** 是否启用监听 */
    enabled: boolean;
    /** 防抖延迟时间（毫秒） */
    debounceTime: number;
    /** 是否自动启动 */
    autoStart: boolean;
    /** 最大监听文件数量 */
    maxFiles?: number;
    /** 内存使用阈值（MB） */
    memoryThreshold?: number;
}
/**
 * 文件过滤规则接口
 *
 * @interface FilterRule
 * @since 2.1.0
 */
interface FilterRule {
    /** 匹配模式（正则表达式） */
    pattern: RegExp;
    /** 过滤动作 */
    action: 'include' | 'exclude';
    /** 优先级（数字越大优先级越高） */
    priority: number;
    /** 规则描述 */
    description?: string;
}
/**
 * 性能监控指标接口
 *
 * @interface PerformanceMetrics
 * @since 2.1.0
 */
interface PerformanceMetrics$1 {
    /** 监听触发次数 */
    watchCount: number;
    /** 文件处理次数 */
    processCount: number;
    /** 过滤掉的文件数 */
    filteredCount: number;
    /** 平均响应时间（毫秒） */
    averageResponseTime: number;
    /** 最后触发时间 */
    lastTriggerTime: number;
    /** 内存使用量（MB） */
    memoryUsage: number;
    /** 监听的目录数 */
    watchedDirectories: number;
    /** 缓存命中率 */
    cacheHitRate: number;
}
/**
 * 智能文件过滤器
 *
 * @description 提供基于规则的文件过滤功能，支持自定义过滤条件和优先级
 * @class SmartFileFilter
 * @since 2.1.0
 */
declare class SmartFileFilter {
    private filterRules;
    private cache;
    private cacheHits;
    private cacheTotal;
    /**
     * 构造函数，初始化默认过滤规则
     *
     * @since 2.1.0
     */
    constructor();
    /**
     * 初始化默认过滤规则
     *
     * @private
     * @since 2.1.0
     */
    private initializeDefaultRules;
    /**
     * 添加过滤规则
     *
     * @param pattern 正则表达式模式
     * @param action 动作类型
     * @param priority 优先级（数字越大优先级越高）
     * @param description 规则描述
     *
     * @since 2.1.0
     */
    addRule(pattern: RegExp, action: 'include' | 'exclude', priority?: number, description?: string): void;
    /**
     * 移除过滤规则
     *
     * @param pattern 要移除的规则模式
     * @returns 是否成功移除
     *
     * @since 2.1.0
     */
    removeRule(pattern: RegExp): boolean;
    /**
     * 检查文件是否应该被处理
     *
     * @param filePath 文件路径
     * @returns 是否应该处理
     *
     * @since 2.1.0
     */
    shouldProcess(filePath: string): boolean;
    /**
     * 获取缓存命中率
     *
     * @returns 缓存命中率 (0-1)
     *
     * @since 2.1.0
     */
    getCacheHitRate(): number;
    /**
     * 清理缓存
     *
     * @since 2.1.0
     */
    clearCache(): void;
    /**
     * 获取所有过滤规则
     *
     * @returns 过滤规则数组
     *
     * @since 2.1.0
     */
    getRules(): FilterRule[];
}
/**
 * Nexus自动文件监听器
 *
 * @description 提供高性能的零配置文件监听功能，包含：
 * - 防抖机制和性能优化
 * - 智能文件过滤系统
 * - 内存管理和监控
 * - 详细的性能指标
 *
 * @class NexusAutoWatcher
 * @since 1.0.0
 * @version 2.1.0
 *
 * @example
 * ```typescript
 * const watcher = NexusAutoWatcher.getInstance();
 *
 * // 启动监听
 * watcher.start();
 *
 * // 添加自定义过滤规则
 * watcher.addFilterRule(/\.spec\.ts$/, 'exclude', 120);
 *
 * // 获取性能指标
 * const metrics = watcher.getPerformanceMetrics();
 * console.log('平均响应时间:', metrics.averageResponseTime);
 *
 * // 停止监听
 * watcher.stop();
 * ```
 */
declare class NexusAutoWatcher {
    private static instance;
    private watchers;
    private debounceTimers;
    private isWatching;
    private fileFilter;
    private performanceMetrics;
    private processingQueue;
    /** 自动监听器配置 */
    private config;
    /**
     * 私有构造函数（单例模式）
     *
     * @private
     * @since 1.0.0
     */
    private constructor();
    /**
     * 获取单例实例
     *
     * @returns NexusAutoWatcher实例
     * @since 1.0.0
     */
    static getInstance(): NexusAutoWatcher;
    /**
     * 初始化性能指标
     *
     * @private
     * @returns 初始化的性能指标
     * @since 2.1.0
     */
    private initializeMetrics;
    /**
     * 设置内存监控
     *
     * @private
     * @since 2.1.0
     */
    private setupMemoryMonitoring;
    /**
     * 执行内存优化
     *
     * @private
     * @since 2.1.0
     */
    private performMemoryOptimization;
    /**
     * 启动自动监听
     *
     * @description 在错误隔离环境中启动文件监听，确保监听器错误不会影响主程序
     * @public
     * @since 1.0.0
     */
    start(): void;
    /**
     * 停止监听
     *
     * @description 停止所有文件监听并清理资源
     * @public
     * @since 1.0.0
     */
    stop(): void;
    /**
     * 查找源代码目录
     *
     * @private
     * @returns 源代码目录路径或null
     * @since 1.0.0
     */
    private findSourceDirectory;
    /**
     * 监听目录
     *
     * @private
     * @param dirPath 目录路径
     * @since 1.0.0
     */
    private watchDirectory;
    /**
     * 处理文件变化
     *
     * @private
     * @param filePath 文件路径
     * @param eventType 事件类型
     * @since 1.0.0
     */
    private handleFileChange;
    /**
     * 处理文件变化（防抖后）
     *
     * @private
     * @param filePath 文件路径
     * @param eventType 事件类型
     * @param startTime 开始时间
     * @since 1.0.0
     */
    private processFileChange;
    /**
     * 更新性能指标
     *
     * @private
     * @param responseTime 响应时间
     * @since 2.1.0
     */
    private updatePerformanceMetrics;
    /**
     * 检查是否是Nexus文件
     *
     * @private
     * @param content 文件内容
     * @returns 是否是Nexus文件
     * @since 1.0.0
     */
    private isNexusFile;
    /**
     * 重新生成插件
     *
     * @private
     * @param filePath 文件路径
     * @param content 文件内容
     * @since 1.0.0
     */
    private regeneratePlugin;
    /**
     * 提取插件名称
     *
     * @private
     * @param content 文件内容
     * @returns 插件名称或null
     * @since 1.0.0
     */
    private extractPluginName;
    /**
     * 获取输出目录
     *
     * @private
     * @returns 输出目录路径或null
     * @since 1.0.0
     */
    private getOutputDirectory;
    /**
     * 生成主文件内容
     *
     * @private
     * @param sourceContent 源文件内容
     * @returns 生成的主文件内容
     * @since 1.0.0
     */
    private generateMainFile;
    /**
     * 生成package.json内容
     *
     * @private
     * @param pluginName 插件名称
     * @returns 生成的package.json内容
     * @since 1.0.0
     */
    private generatePackageJson;
    /**
     * 清理所有定时器
     *
     * @private
     * @since 1.0.0
     */
    private clearAllTimers;
    /**
     * 添加文件过滤规则
     *
     * @param pattern 正则表达式模式
     * @param action 过滤动作
     * @param priority 优先级
     * @param description 规则描述
     *
     * @public
     * @since 2.1.0
     */
    addFilterRule(pattern: RegExp, action: 'include' | 'exclude', priority?: number, description?: string): void;
    /**
     * 移除文件过滤规则
     *
     * @param pattern 要移除的规则模式
     * @returns 是否成功移除
     *
     * @public
     * @since 2.1.0
     */
    removeFilterRule(pattern: RegExp): boolean;
    /**
     * 获取监听状态
     *
     * @returns 监听状态对象
     * @since 1.0.0
     */
    getStatus(): {
        watching: boolean;
        watchedDirectories: number;
        config: AutoWatcherConfig;
    };
    /**
     * 获取性能监控数据
     *
     * @returns 性能监控数据
     * @since 2.1.0
     */
    getPerformanceMetrics(): PerformanceMetrics$1;
    /**
     * 重置性能监控数据
     *
     * @since 2.1.0
     */
    resetPerformanceMetrics(): void;
    /**
     * 打印性能报告
     *
     * @since 2.1.0
     */
    printPerformanceReport(): void;
    /**
     * 更新配置
     *
     * @param newConfig 新配置
     * @since 1.0.0
     */
    updateConfig(newConfig: Partial<AutoWatcherConfig>): void;
    /**
     * 获取所有过滤规则
     *
     * @returns 过滤规则数组
     * @since 2.1.0
     */
    getFilterRules(): FilterRule[];
    /**
     * 清理缓存
     *
     * @since 2.1.0
     */
    clearCache(): void;
}
declare const AutoWatcher: NexusAutoWatcher;

/**
 * Nexus面板基类
 *
 * @description 提供即时模式UI面板开发的核心功能，包括：
 * - 即时模式GUI渲染
 * - 主题系统集成
 * - 错误处理和性能监控
 * - 面板生命周期管理
 * - 自动注册和配置生成
 *
 * @public
 * @abstract
 * @since 1.0.0
 * @version 2.0.0
 *
 * @example
 * ```typescript
 * @Panel({
 *   title: '示例面板',
 *   width: 800,
 *   height: 600,
 *   dockable: true
 * })
 * class ExamplePanel extends NexusPanel {
 *   private counter = 0;
 *
 *   public onGUI(): void {
 *     NexusGUI.Label(`计数器: ${this.counter}`);
 *     if (NexusGUI.Button('增加')) {
 *       this.counter++;
 *       this.forceUpdate();
 *     }
 *   }
 * }
 * ```
 *
 * @see {@link NexusPanelConfig} 面板配置接口
 * @see {@link NexusGUI} GUI渲染系统
 */
declare abstract class NexusPanel {
    /**
     * 面板配置对象
     *
     * @description 包含面板的基本信息和配置选项，如标题、尺寸、可停靠性等
     * @protected
     * @readonly
     * @since 1.0.0
     */
    protected readonly config: NexusPanelConfig;
    /**
     * 面板DOM容器元素
     *
     * @description 面板内容渲染的DOM容器，由框架自动管理
     * @protected
     * @since 1.0.0
     */
    protected container: HTMLElement | null;
    /**
     * 面板可见状态
     *
     * @description 标识面板当前是否可见
     * @protected
     * @since 1.0.0
     */
    protected isVisible: boolean;
    /**
     * 主题管理器实例
     *
     * @description 用于管理面板的主题样式，支持动态主题切换
     * @protected
     * @readonly
     * @since 1.0.0
     */
    protected readonly themeManager: NexusThemeManager;
    /**
     * 错误管理器实例
     *
     * @description 用于处理面板运行过程中的错误
     * @protected
     * @readonly
     * @since 1.0.0
     */
    protected readonly errorManager: NexusErrorManager;
    /**
     * 渲染次数计数器
     *
     * @description 记录面板的渲染次数，用于性能监控
     * @private
     * @since 2.0.0
     */
    private renderCount;
    /**
     * 最后一次渲染耗时
     *
     * @description 记录最后一次渲染的耗时（毫秒），用于性能监控
     * @private
     * @since 2.0.0
     */
    private lastRenderTime;
    /**
     * 构造函数
     *
     * @description 初始化面板实例，应用主题并设置主题监听器
     * @param config 面板配置对象
     *
     * @since 1.0.0
     * @version 2.0.0
     */
    constructor(config: NexusPanelConfig);
    /**
     * 应用主题
     *
     * @description 根据主题名称应用相应的主题样式
     * @param themeName 主题名称
     * @protected
     * @since 2.0.0
     */
    protected applyTheme(themeName: string): void;
    /**
     * 设置主题监听器
     *
     * @description 监听全局主题变化事件，自动更新面板主题
     * @protected
     * @since 2.0.0
     */
    protected setupThemeListener(): void;
    /**
     * 处理主题变化
     *
     * @description 主题变化时的回调函数，强制重新渲染以应用新主题
     * @protected
     * @since 2.0.0
     */
    protected handleThemeChange(): void;
    /**
     * 面板初始化
     *
     * @description 面板初始化时调用，带性能监控功能。
     * 子类可以重写safeInit方法来实现自定义初始化逻辑。
     *
     * @public
     * @since 1.0.0
     * @version 2.0.0
     *
     * @example
     * ```typescript
     * public onInit(): void {
     *   super.onInit();
     *   // 自定义初始化逻辑
     * }
     * ```
     */
    onInit(): void;
    /**
     * 安全的初始化方法
     *
     * @description 在错误处理包装中执行的初始化逻辑，子类可以重写
     * @protected
     * @since 2.0.0
     *
     * @example
     * ```typescript
     * protected safeInit(): void {
     *   console.log('面板初始化');
     *   // 自定义初始化逻辑
     * }
     * ```
     */
    protected safeInit(): void;
    /**
     * 面板GUI渲染方法
     *
     * @description 面板的即时模式GUI渲染方法，子类必须实现。
     * 在此方法中使用NexusGUI的API来构建用户界面。
     *
     * @public
     * @abstract
     * @since 1.0.0
     *
     * @example
     * ```typescript
     * public onGUI(): void {
     *   NexusGUI.Label('标题', NexusStyles.Title);
     *   NexusGUI.Separator();
     *
     *   if (NexusGUI.Button('点击我')) {
     *     console.log('按钮被点击');
     *   }
     *
     *   this.inputText = NexusGUI.TextField('输入框', this.inputText);
     * }
     * ```
     */
    abstract onGUI(): void;
    /**
     * 面板销毁
     *
     * @description 面板销毁时调用，清理GUI组件和资源。
     * 子类可以重写此方法来实现自定义清理逻辑。
     *
     * @public
     * @since 1.0.0
     *
     * @example
     * ```typescript
     * public onDestroy(): void {
     *   super.onDestroy();
     *   // 自定义清理逻辑
     *   this.clearData();
     * }
     * ```
     */
    onDestroy(): void;
    /**
     * 设置容器
     */
    setContainer(container: HTMLElement): void;
    /**
     * 渲染面板 - 基于优化NexusGUI的现代系统，带性能监控
     */
    render(): void;
    /**
     * 强制更新面板 - React系统会自动处理重新渲染
     */
    forceUpdate(): void;
    /**
     * 显示面板
     */
    show(): void;
    /**
     * 隐藏面板
     */
    hide(): void;
    /**
     * 获取面板配置
     */
    getConfig(): NexusPanelConfig;
    /**
     * 获取面板标题
     */
    getTitle(): string;
    /**
     * 是否可见
     */
    getVisible(): boolean;
    /**
     * 自动注册面板到Nexus系统
     */
    autoRegister(name?: string): void;
    /**
     * 自动生成Cocos面板文件
     */
    generateCocosPanel(panelName?: string): string;
    /**
     * 快速显示面板为独立窗口（无需复杂配置）
     * @param panelClass 面板类
     * @param config 可选配置
     */
    static showAsWindow<T extends NexusPanel>(panelClass: new (config: NexusPanelConfig) => T, config?: Partial<NexusPanelConfig>): T;
    /**
     * 生成窗口HTML内容 - 为React渲染系统优化
     */
    private static generateWindowHTML;
}
/**
 * 面板装饰器
 * @param config 面板配置信息
 * @returns 装饰器函数
 */
declare function Panel(config: NexusPanelConfig): <T extends {
    new (...args: any[]): NexusPanel;
}>(constructor: T) => T;

/**
 * Nexus独立窗口管理器
 * 允许直接创建独立窗口，无需依赖Cocos Creator的面板系统
 */
declare class NexusWindow {
    private static windows;
    private windowElement;
    private panel;
    private config;
    private isVisible;
    constructor(panel: NexusPanel, config: NexusPanelConfig);
    /**
     * 创建并显示独立窗口
     */
    static create(panel: NexusPanel, config?: Partial<NexusPanelConfig>): NexusWindow;
    /**
     * 显示窗口
     */
    show(): void;
    /**
     * 隐藏窗口
     */
    hide(): void;
    /**
     * 关闭窗口
     */
    close(): void;
    /**
     * 创建窗口元素
     */
    private createWindowElement;
    /**
     * 添加拖拽功能
     */
    private addDragFunctionality;
    /**
     * 开始渲染循环
     */
    private startRenderLoop;
    /**
     * 获取所有打开的窗口
     */
    static getAllWindows(): NexusWindow[];
    /**
     * 关闭所有窗口
     */
    static closeAll(): void;
}

/**
 * Nexus扩展管理器
 * 用于集成到Cocos Creator的扩展系统
 */
declare class NexusExtension {
    private static instance;
    private plugins;
    private panels;
    static get Instance(): NexusExtension;
    /**
     * 注册插件
     */
    registerPlugin(plugin: NexusPlugin): void;
    /**
     * 注册面板
     */
    registerPanel(name: string, panel: NexusPanel): void;
    /**
     * 获取插件
     */
    getPlugin(name: string): NexusPlugin | undefined;
    /**
     * 获取面板
     */
    getPanel(name: string): NexusPanel | undefined;
    /**
     * 获取所有插件
     */
    getAllPlugins(): NexusPlugin[];
    /**
     * 获取所有面板
     */
    getAllPanels(): NexusPanel[];
    /**
     * 卸载插件
     */
    unregisterPlugin(name: string): void;
    /**
     * 卸载面板
     */
    unregisterPanel(name: string): void;
    /**
     * 启动扩展系统
     */
    static start(): Promise<void>;
    /**
     * 停止扩展系统
     */
    static stop(): Promise<void>;
    /**
     * 创建标准的Cocos面板定义
     * 这是核心功能：将Nexus面板转换为Cocos面板
     */
    createCocosPanel(nexusPanel: NexusPanel, panelName: string): any;
    /**
     * 生成面板样式
     */
    private generatePanelStyles;
    /**
     * 生成Cocos Creator扩展的main.ts
     */
    generateMainTs(): string;
    /**
     * 生成面板文件内容
     * 这是关键功能：自动生成符合Cocos标准的面板文件
     */
    generatePanelFile(nexusPanel: NexusPanel, panelName: string): string;
    /**
     * 自动化插件集成
     * 这是你需要的核心功能：让插件遵循你的规范
     */
    integratePlugin(plugin: NexusPlugin): {
        mainTs: string;
        panelFiles: Map<string, string>;
        packageJson: any;
    };
    /**
     * 生成插件的main.ts文件
     */
    private generatePluginMainTs;
    /**
     * 生成package.json配置
     */
    private generatePackageJson;
}

interface NexusMessageHandler {
    (data: any): Promise<any> | any;
}
/**
 * 消息通信管理器
 */
declare class NexusMessage {
    private static handlers;
    private static messageId;
    private static pendingMessages;
    /**
     * 发送请求消息到编辑器
     * @param message 消息名称
     * @param args 消息参数
     * @returns Promise<any>
     */
    static request(message: string, ...args: any[]): Promise<any>;
    /**
     * 发送消息到编辑器（不等待响应）
     * @param message 消息名称
     * @param data 消息数据
     */
    static send(message: string, data?: any): void;
    /**
     * 广播消息到所有面板
     * @param message 消息名称
     * @param data 消息数据
     */
    static broadcast(message: string, data?: any): void;
    /**
     * 注册消息处理器
     * @param message 消息名称
     * @param handler 处理函数
     */
    static on(message: string, handler: NexusMessageHandler): void;
    /**
     * 移除消息处理器
     * @param message 消息名称
     * @param handler 处理函数
     */
    static off(message: string, handler?: NexusMessageHandler): void;
    /**
     * 处理接收到的消息
     * @param message 消息名称
     * @param data 消息数据
     */
    static handle(message: string, data?: any): Promise<any>;
    /**
     * 场景相关操作
     */
    static Sc