@tuoyuan/micro-app-vue/dist/index.d.ts

拓源微前端解决方案 - 基于Vue的微前端库

import { ComponentOptionsMixin } from 'vue';
import { ComponentProvideOptions } from 'vue';
import { ComputedRef } from 'vue';
import { DefineComponent } from 'vue';
import { ExtractPropTypes } from 'vue';
import { PublicProps } from 'vue';
import { Ref } from 'vue';

/**
 * 分析配置
 */
declare interface AnalyticsConfig {
    /**
     * 是否启用分析
     */
    enabled?: boolean;
    /**
     * 分析服务端点
     */
    endpoint?: string;
    /**
     * 批量发送间隔（毫秒）
     */
    batchInterval?: number;
    /**
     * 批量大小
     */
    batchSize?: number;
    /**
     * 是否自动发送
     */
    autoSend?: boolean;
    /**
     * 用户ID获取函数
     */
    getUserId?: () => string | null;
    /**
     * 会话ID获取函数
     */
    getSessionId?: () => string;
    /**
     * 自定义属性
     */
    customProperties?: Record<string, any>;
}

/**
 * 分析事件类型
 */
declare interface AnalyticsEvent {
    /**
     * 事件名称
     */
    name: string;
    /**
     * 事件数据
     */
    data?: Record<string, any>;
    /**
     * 时间戳
     */
    timestamp: number;
    /**
     * 应用ID
     */
    appId?: string;
    /**
     * 用户ID
     */
    userId?: string;
    /**
     * 会话ID
     */
    sessionId?: string;
}

/**
 * 分析插件
 */
export declare class AnalyticsPlugin extends BasePlugin {
    id: string;
    name: string;
    version: string;
    description: string;
    author: string;
    private config;
    private events;
    private batchTimer;
    private sessionId;
    private logger;
    constructor(config?: AnalyticsConfig);
    install(manager: MicroAppManager): Promise<void>;
    uninstall(manager: MicroAppManager): Promise<void>;
    beforeAppLoad(config: MicroAppConfig): Promise<void>;
    afterAppLoad(config: MicroAppConfig): Promise<void>;
    beforeAppUnload(appId: string): Promise<void>;
    afterAppUnload(appId: string): Promise<void>;
    beforeRouteChange(routeParams: any): Promise<void>;
    afterRouteChange(routeParams: any): Promise<void>;
    beforeMessageSend(message: any): Promise<void>;
    afterMessageReceive(message: any): Promise<void>;
    onError(error: Error, context?: any): Promise<void>;
    /**
     * 跟踪事件
     */
    track(name: string, data?: Record<string, any>, appId?: string): void;
    /**
     * 跟踪页面浏览
     */
    trackPageView(page: string, title?: string, appId?: string): void;
    /**
     * 跟踪用户行为
     */
    trackUserAction(action: string, target?: string, appId?: string): void;
    /**
     * 跟踪性能指标
     */
    trackPerformance(metrics: Record<string, number>, appId?: string): void;
    /**
     * 设置用户属性
     */
    setUserProperties(properties: Record<string, any>): void;
    /**
     * 设置用户ID
     */
    setUserId(userId: string): void;
    /**
     * 获取用户ID
     */
    getUserId(): string | null;
    /**
     * 获取会话ID
     */
    getSessionId(): string;
    /**
     * 生成会话ID
     */
    private generateSessionId;
    /**
     * 启动批量发送定时器
     */
    private startBatchTimer;
    /**
     * 停止批量发送定时器
     */
    private stopBatchTimer;
    /**
     * 发送事件到分析服务
     */
    private flush;
    /**
     * 手动发送事件
     */
    send(): Promise<void>;
    /**
     * 获取事件统计
     */
    getEventStats(): {
        total: number;
        byName: Record<string, number>;
        byApp: Record<string, number>;
        recentEvents: AnalyticsEvent[];
    };
    /**
     * 获取分析报告
     */
    getAnalyticsReport(): {
        events: {
            total: number;
            byName: Record<string, number>;
            byApp: Record<string, number>;
        };
        users: {
            total: number;
            active: number;
        };
        sessions: {
            current: string;
            duration: number;
        };
        performance: {
            averageEventSize: number;
            sendSuccessRate: number;
        };
    };
    /**
     * 清空事件
     */
    clearEvents(): void;
    /**
     * 导出事件数据
     */
    exportEvents(): string;
}

/**
 * 基础插件类
 */
export declare abstract class BasePlugin implements Plugin_2 {
    abstract id: string;
    abstract name: string;
    abstract version: string;
    description?: string;
    author?: string;
    dependencies?: string[];
    options?: Record<string, any>;
    install?(manager: MicroAppManager): void | Promise<void>;
    uninstall?(manager: MicroAppManager): void | Promise<void>;
    beforeAppLoad?(config: MicroAppConfig): void | Promise<void>;
    afterAppLoad?(config: MicroAppConfig): void | Promise<void>;
    beforeAppUnload?(appId: string): void | Promise<void>;
    afterAppUnload?(appId: string): void | Promise<void>;
    beforeRouteChange?(routeParams: any): void | Promise<void>;
    afterRouteChange?(routeParams: any): void | Promise<void>;
    beforeMessageSend?(message: any): void | Promise<void>;
    afterMessageReceive?(message: any): void | Promise<void>;
    onError?(error: Error, context?: any): void | Promise<void>;
}

/**
 * 构建路由URL
 */
export declare function buildRouteUrl(config: MicroAppConfig, routeParams: RouteParams): string;

/**
 * 缓存配置
 */
declare interface CacheConfig {
    /**
     * 是否启用缓存
     */
    enabled?: boolean;
    /**
     * 默认过期时间（毫秒）
     */
    defaultTTL?: number;
    /**
     * 最大缓存大小（字节）
     */
    maxSize?: number;
    /**
     * 缓存策略
     */
    strategy?: 'memory' | 'localStorage' | 'sessionStorage' | 'hybrid';
    /**
     * 是否启用压缩
     */
    enableCompression?: boolean;
    /**
     * 是否启用加密
     */
    enableEncryption?: boolean;
    /**
     * 加密密钥
     */
    encryptionKey?: string;
}

/**
 * 缓存项
 */
declare interface CacheItem<T = any> {
    /**
     * 键
     */
    key: string;
    /**
     * 值
     */
    value: T;
    /**
     * 过期时间
     */
    expires: number;
    /**
     * 创建时间
     */
    createdAt: number;
    /**
     * 访问次数
     */
    accessCount: number;
    /**
     * 最后访问时间
     */
    lastAccessed: number;
}

/**
 * 缓存插件
 */
export declare class CachePlugin extends BasePlugin {
    id: string;
    name: string;
    version: string;
    description: string;
    author: string;
    private config;
    private memoryCache;
    private cacheStats;
    private logger;
    constructor(config?: CacheConfig);
    install(manager: MicroAppManager): Promise<void>;
    uninstall(manager: MicroAppManager): Promise<void>;
    /**
     * 设置缓存
     */
    set<T>(key: string, value: T, ttl?: number): void;
    /**
     * 获取缓存
     */
    get<T>(key: string): T | null;
    /**
     * 删除缓存
     */
    delete(key: string): boolean;
    /**
     * 检查缓存是否存在
     */
    has(key: string): boolean;
    /**
     * 清空所有缓存
     */
    clear(): void;
    /**
     * 获取缓存统计
     */
    getStats(): {
        hits: number;
        misses: number;
        sets: number;
        deletes: number;
        size: number;
        hitRate: number;
        itemCount: number;
    };
    /**
     * 获取缓存项
     */
    getItem(key: string): CacheItem | null;
    /**
     * 获取所有缓存键
     */
    keys(): string[];
    /**
     * 获取缓存大小
     */
    size(): number;
    /**
     * 清理过期缓存
     */
    cleanup(): void;
    /**
     * 处理值（压缩/加密）
     */
    private processValue;
    /**
     * 更新访问统计
     */
    private updateAccessStats;
    /**
     * 更新缓存大小
     */
    private updateSize;
    /**
     * 检查是否需要淘汰缓存
     */
    private shouldEvict;
    /**
     * 淘汰缓存（LRU策略）
     */
    private evict;
    /**
     * 同步到存储
     */
    private syncToStorage;
    /**
     * 从存储恢复
     */
    private restoreFromStorage;
    /**
     * 从存储中移除
     */
    private removeFromStorage;
    /**
     * 清空存储
     */
    private clearStorage;
    /**
     * 创建缓存高阶函数
     * @param keyOrGetKey 缓存键或获取缓存键的函数
     * @param getter 数据获取函数
     * @param ttl 过期时间（毫秒）
     * @returns 返回一个带缓存的数据获取函数，支持强制刷新
     */
    createCachedGetter<T, Args extends any[] = []>(keyOrGetKey: string | ((...args: Args) => string), getter: (...args: Args) => Promise<T> | T, ttl?: number): (...args: Args) => Promise<T> & {
        forceRefresh: (...args: Args) => Promise<T>;
    };
}

declare interface ConfigCenter {
    getConfig: (appId: string) => MicroAppConfig;
    updateConfig: (appId: string, config: Partial<MicroAppConfig>) => void;
    getAppList: () => MicroAppConfig[];
}

declare class ConfigManager implements ConfigCenter {
    private ctx;
    private configs;
    private configCache;
    private cacheExpiry;
    private preloadManager;
    private logger;
    constructor(ctx: InstanceContainer, logger?: Logger);
    /**
     * 设置预加载管理器引用
     */
    setPreloadManager(preloadManager: any): void;
    /**
     * 设置日志记录器
     */
    setLogger(logger: Logger): void;
    /**
     * 获取应用配置
     */
    getConfig(appId: string): MicroAppConfig;
    /**
     * 更新应用配置
     */
    updateConfig(appId: string, config: Partial<MicroAppConfig>): void;
    /**
     * 获取应用列表
     */
    getAppList(): MicroAppConfig[];
    /**
     * 添加应用配置
     */
    addConfig(config: MicroAppConfig): void;
    /**
     * 移除应用配置
     */
    removeConfig(appId: string): void;
    /**
     * 批量添加配置
     */
    addConfigs(configs: MicroAppConfig[]): void;
    /**
     * 清空所有配置
     */
    clearConfigs(): void;
    /**
     * 获取配置统计信息
     */
    getConfigStats(): {
        totalConfigs: number;
        cachedConfigs: number;
        cacheHitRate: number;
    };
    /**
     * 设置缓存过期时间
     */
    setCacheExpiry(expiry: number): void;
    /**
     * 清理过期缓存
     */
    clearExpiredCache(): void;
    /**
     * 更新缓存
     */
    private updateCache;
    /**
     * 设置事件监听器
     */
    private setupEventListeners;
    /**
     * 导出配置
     */
    exportConfigs(): string;
    /**
     * 导入配置
     */
    importConfigs(configsJson: string): void;
}

/**
 * 创建 Logger 实例的便捷函数
 */
export declare function createLogger(options: LoggerOptions): Logger;

/**
 * 便捷函数：创建 MicroAppManager
 */
export declare function createMicroAppManager(options?: MicroAppFactoryOptions): MicroAppManager;

/**
 * 防抖函数
 */
export declare function debounce<T extends (...args: any[]) => any>(func: T, wait: number): (...args: Parameters<T>) => void;

/**
 * 深度合并对象
 */
export declare function deepMerge<T extends object>(target: T, source: Partial<T>): T;

declare const _default: {
    MicroAppContainer: DefineComponent<ExtractPropTypes<    {
    config: {
    type: () => MicroAppConfig;
    required: true;
    };
    hooks: {
    type: () => LifecycleHooks;
    default: () => {};
    };
    loadingTimeout: {
    type: NumberConstructor;
    default: number;
    };
    iframeClass: {
    type: StringConstructor;
    default: string;
    };
    instanceId: {
    type: StringConstructor;
    default: string;
    };
    }>, {
    iframeRef: Ref<HTMLIFrameElement | undefined, HTMLIFrameElement | undefined>;
    isLoading: Ref<boolean, boolean>;
    error: Ref<Error | null, Error | null>;
    iframeSrc: ComputedRef<string>;
    handleIframeLoad: () => Promise<void>;
    handleIframeError: () => void;
    retry: () => Promise<void>;
    sendMessage: (type: string, data?: any) => void;
    }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("error" | "message" | "loaded" | "mounted" | "unmounted")[], "error" | "message" | "loaded" | "mounted" | "unmounted", PublicProps, Readonly<ExtractPropTypes<    {
    config: {
    type: () => MicroAppConfig;
    required: true;
    };
    hooks: {
    type: () => LifecycleHooks;
    default: () => {};
    };
    loadingTimeout: {
    type: NumberConstructor;
    default: number;
    };
    iframeClass: {
    type: StringConstructor;
    default: string;
    };
    instanceId: {
    type: StringConstructor;
    default: string;
    };
    }>> & Readonly<{
    onError?: ((...args: any[]) => any) | undefined;
    onMessage?: ((...args: any[]) => any) | undefined;
    onLoaded?: ((...args: any[]) => any) | undefined;
    onMounted?: ((...args: any[]) => any) | undefined;
    onUnmounted?: ((...args: any[]) => any) | undefined;
    }>, {
    hooks: LifecycleHooks;
    loadingTimeout: number;
    iframeClass: string;
    instanceId: string;
    }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
    startMicroApp: typeof startMicroApp;
    getMicroAppManager: (id?: string) => MicroAppManager;
    getEventBus: (id?: string) => EventBus;
    getErrorHandler: (id?: string) => ErrorHandler;
    getPerformanceMonitor: (id?: string) => PerformanceMonitor;
    getConfigManager: (id?: string) => ConfigManager;
    getPreloadManager: (id?: string) => PreloadManager;
    ErrorType: typeof ErrorType;
    BasePlugin: typeof BasePlugin;
    LoggingPlugin: typeof LoggingPlugin;
    PerformancePlugin: typeof PerformancePlugin;
    SecurityPlugin: typeof SecurityPlugin;
    AnalyticsPlugin: typeof AnalyticsPlugin;
    CachePlugin: typeof CachePlugin;
    ErrorHandlingPlugin: typeof ErrorHandlingPlugin;
    generateId: typeof generateId;
    isValidUrl: typeof isValidUrl;
    validateMicroAppConfig: typeof validateMicroAppConfig;
    buildRouteUrl: typeof buildRouteUrl;
    deepMerge: typeof deepMerge;
    debounce: typeof debounce;
    throttle: typeof throttle;
    Logger: typeof Logger;
    LogLevel: typeof LogLevel;
    createLogger: typeof createLogger;
};
export default _default;

declare class ErrorHandler {
    private ctx;
    private errorQueue;
    private maxErrorQueueSize;
    private errorHandlers;
    private logger;
    constructor(ctx: InstanceContainer, logger?: Logger);
    /**
     * 处理错误
     */
    handleError(error: Error, type: ErrorType, appId?: string, details?: any): void;
    /**
     * 添加错误到队列
     */
    private addToErrorQueue;
    /**
     * 通知错误处理器
     */
    private notifyErrorHandlers;
    /**
     * 发送错误事件
     */
    private emitErrorEvent;
    /**
     * 注册错误处理器
     */
    registerErrorHandler(type: ErrorType, handler: Function): void;
    /**
     * 移除错误处理器
     */
    removeErrorHandler(type: ErrorType, handler: Function): void;
    /**
     * 获取错误历史
     */
    getErrorHistory(): MicroAppError[];
    /**
     * 设置日志记录器
     */
    setLogger(logger: Logger): void;
    /**
     * 清空错误队列
     */
    clearErrorQueue(): void;
    /**
     * 获取错误统计
     */
    getErrorStats(): Record<ErrorType, number>;
    /**
     * 设置全局错误处理
     */
    private setupGlobalErrorHandling;
    /**
     * 创建超时错误
     */
    createTimeoutError(appId: string, timeout: number): Error;
    /**
     * 创建通信错误
     */
    createCommunicationError(appId: string, details?: any): Error;
    /**
     * 创建路由错误
     */
    createRouteError(appId: string, route: string, details?: any): Error;
}

/**
 * 错误处理插件
 */
export declare class ErrorHandlingPlugin extends BasePlugin {
    id: string;
    name: string;
    version: string;
    description: string;
    author: string;
    private logger;
    constructor();
    install(manager: MicroAppManager): Promise<void>;
    uninstall(manager: MicroAppManager): Promise<void>;
    onError(error: Error, context?: any): Promise<void>;
}

export declare enum ErrorType {
    LOAD_TIMEOUT = "LOAD_TIMEOUT",
    COMMUNICATION_ERROR = "COMMUNICATION_ERROR",
    ROUTE_ERROR = "ROUTE_ERROR",
    LIFECYCLE_ERROR = "LIFECYCLE_ERROR"
}

declare class EventBus {
    private events;
    private onceEvents;
    private messageQueue;
    private maxQueueSize;
    private maxListeners;
    private logger;
    constructor(logger?: Logger);
    /**
     * 添加事件监听器
     */
    on(event: string, listener: EventListener_2): this;
    /**
     * 添加一次性事件监听器
     */
    once(event: string, listener: EventListener_2): this;
    /**
     * 移除事件监听器
     */
    off(event: string, listener?: EventListener_2): this;
    /**
     * 发送事件
     */
    emit(event: string, ...args: any[]): boolean;
    /**
     * 添加消息到队列
     */
    private addToQueue;
    /**
     * 获取消息历史
     */
    getMessageHistory(): MicroAppMessage[];
    /**
     * 清空消息队列
     */
    clearMessageQueue(): void;
    /**
     * 生成消息ID
     */
    private generateMessageId;
    /**
     * 设置最大监听器数量
     */
    setMaxListeners(count: number): this;
    /**
     * 获取最大监听器数量
     */
    getMaxListeners(): number;
    /**
     * 获取监听器数量
     */
    listenerCount(event: string): number;
    /**
     * 获取所有事件名称
     */
    eventNames(): string[];
    /**
     * 带确认的消息发送
     */
    emitWithAck(event: string, data?: any, timeout?: number): Promise<any>;
    /**
     * 批量发送消息
     */
    emitBatch(events: Array<{
        event: string;
        data?: any;
    }>): Promise<void>;
    /**
     * 获取监听器数量（兼容方法）
     */
    getListenerCount(event: string): number;
    /**
     * 获取所有事件名称（兼容方法）
     */
    getEventNames(): string[];
    /**
     * 设置消息队列
     */
    private setupMessageQueue;
    /**
     * 移除所有监听器
     */
    removeAllListeners(event?: string): this;
    /**
     * 获取事件的所有监听器
     */
    listeners(event: string): EventListener_2[];
    /**
     * 检查是否有监听器
     */
    hasListeners(event: string): boolean;
    /**
     * 设置日志记录器
     */
    setLogger(logger: Logger): void;
}

declare type EventListener_2<T = any> = (data: T) => void;

declare type EventListener_3<T = any> = (data: T) => void;

/**
 * 生成唯一ID
 */
export declare function generateId(): string;

export declare const getConfigManager: (id?: string) => ConfigManager;

export declare const getErrorHandler: (id?: string) => ErrorHandler;

export declare const getEventBus: (id?: string) => EventBus;

export declare const getMicroAppManager: (id?: string) => MicroAppManager;

export declare const getPerformanceMonitor: (id?: string) => PerformanceMonitor;

export declare const getPreloadManager: (id?: string) => PreloadManager;

export declare interface GlobalData {
    [key: string]: any;
}

declare interface InstanceContainer {
    eventBus: EventBus;
    errorHandler: ErrorHandler;
    performanceMonitor: PerformanceMonitor;
    configManager: ConfigManager;
    preloadManager: PreloadManager;
    storeManager: StoreManager;
}

/**
 * 验证URL格式
 */
export declare function isValidUrl(url: string): boolean;

export declare interface LifecycleHooks {
    beforeLoad?: () => void | Promise<void>;
    afterLoad?: () => void | Promise<void>;
    beforeMount?: () => void | Promise<void>;
    afterMount?: () => void | Promise<void>;
    beforeUnmount?: () => void | Promise<void>;
    afterUnmount?: () => void | Promise<void>;
    onError?: (error: Error) => void;
}

declare enum LoadErrorType {
    TIMEOUT = "timeout",
    NETWORK = "network",
    CORS = "cors",
    SCRIPT = "script",
    COMMUNICATION = "communication",
    UNKNOWN = "unknown"
}

/**
 * 日志条目
 */
declare interface LogEntry {
    timestamp: number;
    level: LogLevel_2;
    message: string;
    appId?: string;
    context?: Record<string, any>;
    error?: Error;
}

/**
 * Logger 类
 * 用于在控制台输出格式化的日志
 */
export declare class Logger {
    private moduleName;
    private level;
    private timestamp;
    private format;
    private colors;
    constructor(options: LoggerOptions);
    /**
     * 输出调试日志
     */
    debug(message: string, ...context: any[]): void;
    /**
     * 输出信息日志
     */
    info(message: string, ...context: any[]): void;
    /**
     * 输出警告日志
     */
    warn(message: string, ...context: any[]): void;
    /**
     * 输出错误日志
     */
    error(message: string, ...context: any[]): void;
    /**
     * 输出致命错误日志
     */
    fatal(message: string, ...context: any[]): void;
    /**
     * 日志输出方法
     */
    log(level: LogLevel, message: string, context: any[]): void;
    /**
     * 带颜色的日志输出
     */
    private logWithColors;
    /**
     * 输出到控制台
     */
    private outputToConsole;
    /**
     * 格式化日志消息
     */
    private formatMessage;
    /**
     * 设置模块名称
     */
    setModuleName(moduleName: string): void;
    /**
     * 设置日志等级
     */
    setLevel(level: LogLevel): void;
    /**
     * 获取当前日志等级
     */
    getLevel(): LogLevel;
    /**
     * 设置时间戳显示
     */
    setTimestamp(enabled: boolean): void;
    /**
     * 设置日志格式
     */
    setFormat(format: string): void;
    /**
     * 设置颜色显示
     */
    setColors(enabled: boolean): void;
    /**
     * 创建子 Logger
     */
    child(subModule: string): Logger;
}

/**
 * Logger 配置选项
 */
export declare interface LoggerOptions {
    /** 模块名称 */
    moduleName: string;
    /** 输出的日志等级，默认 INFO */
    level?: LogLevel;
    /** 是否显示时间戳，默认 true */
    timestamp?: boolean;
    /** 日志格式模板，默认 '[{ts}] [{level}] [{module}] {message}' */
    format?: string;
    /** 是否启用颜色，默认 true */
    colors?: boolean;
}

/**
 * 日志配置
 */
declare interface LoggingConfig {
    /**
     * 日志级别
     */
    level?: LogLevel_2;
    /**
     * 是否启用控制台输出
     */
    console?: boolean;
    /**
     * 是否启用远程日志
     */
    remote?: boolean;
    /**
     * 远程日志端点
     */
    remoteEndpoint?: string;
    /**
     * 日志格式
     */
    format?: 'json' | 'text';
    /**
     * 是否包含时间戳
     */
    includeTimestamp?: boolean;
    /**
     * 是否包含应用ID
     */
    includeAppId?: boolean;
}

/**
 * 日志插件
 */
export declare class LoggingPlugin extends BasePlugin {
    id: string;
    name: string;
    version: string;
    description: string;
    author: string;
    private config;
    private logs;
    private maxLogs;
    private logger;
    constructor(config?: LoggingConfig);
    install(manager: MicroAppManager): Promise<void>;
    uninstall(manager: MicroAppManager): Promise<void>;
    beforeAppLoad(config: MicroAppConfig): Promise<void>;
    afterAppLoad(config: MicroAppConfig): Promise<void>;
    beforeAppUnload(appId: string): Promise<void>;
    afterAppUnload(appId: string): Promise<void>;
    beforeRouteChange(routeParams: any): Promise<void>;
    afterRouteChange(routeParams: any): Promise<void>;
    beforeMessageSend(message: any): Promise<void>;
    afterMessageReceive(message: any): Promise<void>;
    onError(error: Error, context?: any): Promise<void>;
    /**
     * 记录日志
     */
    log(level: LogLevel_2, message: string, context?: Record<string, any>, appId?: string): void;
    /**
     * 输出到控制台
     */
    private outputToConsole;
    /**
     * 发送到远程
     */
    private sendToRemote;
    /**
     * 获取日志
     */
    getLogs(level?: LogLevel_2, limit?: number): LogEntry[];
    /**
     * 清空日志
     */
    clearLogs(): void;
    /**
     * 导出日志
     */
    exportLogs(): string;
    /**
     * 获取日志统计
     */
    getLogStats(): Record<string, any>;
    /**
     * 便捷方法
     */
    debug(message: string, context?: Record<string, any>, appId?: string): void;
    info(message: string, context?: Record<string, any>, appId?: string): void;
    warn(message: string, context?: Record<string, any>, appId?: string): void;
    error(message: string, context?: Record<string, any>, appId?: string): void;
    fatal(message: string, context?: Record<string, any>, appId?: string): void;
}

/**
 * 日志等级枚举
 */
export declare enum LogLevel {
    DEBUG = 0,
    INFO = 1,
    WARN = 2,
    ERROR = 3,
    FATAL = 4
}

/**
 * 日志级别
 */
declare enum LogLevel_2 {
    DEBUG = 0,
    INFO = 1,
    WARN = 2,
    ERROR = 3,
    FATAL = 4
}

export declare interface MicroAppClientAPI {
    isMicroApp: boolean;
    appId: string | null;
    appName: string | null;
    dispatch: (name: string, data?: any, options?: {
        global?: boolean;
        app_name?: string;
    }) => void;
    addEventListener: (name: string, listener: EventListener_2, once?: boolean) => void;
    removeEventListener: (name: string, listener: EventListener_2) => void;
    getGlobalData: (key: string) => Promise<any>;
    setGlobalData: (key: string, value: any) => Promise<void>;
    addHookListener: (name: string, listener: EventListener_2, once?: boolean) => void;
    removeHookListener: (name: string, listener: EventListener_2) => void;
    setToken: (token: string) => void;
    sendMessageToMain: (messageType: string, payload?: any) => void;
    sendMessageToApp: (targetAppId: string, messageType: string, payload?: any) => void;
    broadcastMessage: (messageType: string, payload?: any) => void;
}

declare interface MicroAppClientOptions {
    router?: any;
    setToken?: (token: string) => void;
    debug?: boolean;
    routerMode?: 'hash' | 'history';
    accessibleRouter?: boolean;
    routeQueryOptions?: Record<string, string | {
        type: string;
        payload?: any;
    }>;
}

export declare interface MicroAppConfig {
    /** 应用ID */
    appId: string;
    /** 应用名称 */
    name: string;
    /** 应用URL */
    url: string;
    /** 路由模式 */
    routerMode?: 'hash' | 'history';
    /** 是否可访问路由 */
    accessibleRouter?: boolean;
    /** 路由查询参数配置 */
    routeQueryOptions?: Record<string, string | RouteQueryOption>;
    /** 预加载配置 */
    preload?: boolean;
    /** 超时时间(ms) */
    timeout?: number;
}

export declare const MicroAppContainer: DefineComponent<ExtractPropTypes<    {
config: {
type: () => MicroAppConfig;
required: true;
};
hooks: {
type: () => LifecycleHooks;
default: () => {};
};
loadingTimeout: {
type: NumberConstructor;
default: number;
};
iframeClass: {
type: StringConstructor;
default: string;
};
instanceId: {
type: StringConstructor;
default: string;
};
}>, {
iframeRef: Ref<HTMLIFrameElement | undefined, HTMLIFrameElement | undefined>;
isLoading: Ref<boolean, boolean>;
error: Ref<Error | null, Error | null>;
iframeSrc: ComputedRef<string>;
handleIframeLoad: () => Promise<void>;
handleIframeError: () => void;
retry: () => Promise<void>;
sendMessage: (type: string, data?: any) => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("error" | "message" | "loaded" | "mounted" | "unmounted")[], "error" | "message" | "loaded" | "mounted" | "unmounted", PublicProps, Readonly<ExtractPropTypes<    {
config: {
type: () => MicroAppConfig;
required: true;
};
hooks: {
type: () => LifecycleHooks;
default: () => {};
};
loadingTimeout: {
type: NumberConstructor;
default: number;
};
iframeClass: {
type: StringConstructor;
default: string;
};
instanceId: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{
onError?: ((...args: any[]) => any) | undefined;
onMessage?: ((...args: any[]) => any) | undefined;
onLoaded?: ((...args: any[]) => any) | undefined;
onMounted?: ((...args: any[]) => any) | undefined;
onUnmounted?: ((...args: any[]) => any) | undefined;
}>, {
hooks: LifecycleHooks;
loadingTimeout: number;
iframeClass: string;
instanceId: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare interface MicroAppError {
    type: ErrorType;
    message: string;
    appId?: string;
    timestamp: number;
    details?: any;
    loadErrorType?: LoadErrorType;
}

/**
 * 微应用管理器工厂
 * 用于创建和管理 MicroAppManager 实例
 */
export declare class MicroAppFactory {
    private static instances;
    /**
     * 创建或获取 MicroAppManager 实例
     */
    static create(options?: MicroAppFactoryOptions): MicroAppManager;
    /**
     * 获取指定容器ID的实例
     */
    static getInstance(containerId?: string): MicroAppManager | null;
    /**
     * 获取默认实例（兼容性方法）
     */
    static getDefault(): MicroAppManager | null;
    /**
     * 销毁指定容器ID的管理器实例
     */
    static destroyContainer(containerId: string): void;
    /**
     * 获取所有容器ID
     */
    static getContainerIds(): string[];
    /**
     * 检查容器是否存在
     */
    static hasContainer(containerId: string): boolean;
    /**
     * 重置所有容器和实例（主要用于测试）
     */
    static reset(): void;
}

/**
 * 微应用管理器工厂配置选项
 */
declare interface MicroAppFactoryOptions {
    /** 日志等级 */
    logLevel?: LogLevel;
    /** 容器ID，不传时使用 'default' */
    containerId?: string;
}

/**
 * 微应用管理器 - 协调各个功能模块
 */
export declare class MicroAppManager {
    private isInitialized;
    private id;
    private logLevel;
    private getTokenFn?;
    private pluginManager;
    private configManager;
    private preloadManager;
    private performanceMonitor;
    private eventBus;
    private errorHandler;
    private storeManager;
    private logger;
    constructor(options: MicroAppManagerOptions);
    /**
     * 初始化管理器
     */
    initialize(): Promise<void>;
    /**
     * 为各个管理器设置子 logger
     */
    private setupManagerLoggers;
    /**
     * 添加应用配置（集成版本）
     */
    addApp(config: MicroAppConfig): Promise<void>;
    /**
     * 批量添加应用配置
     */
    addApps(configs: MicroAppConfig[]): Promise<void>;
    /**
     * 移除应用配置
     */
    removeApp(appId: string): Promise<void>;
    /**
     * 获取应用配置
     */
    getAppConfig(appId: string): MicroAppConfig;
    /**
     * 获取所有应用配置
     */
    getAllAppConfigs(): MicroAppConfig[];
    /**
     * 预加载应用
     */
    preloadApp(appId: string): Promise<void>;
    /**
     * 检查应用是否已预加载
     */
    isAppPreloaded(appId: string): boolean;
    /**
     * 获取应用性能指标
     */
    getAppPerformance(appId: string): any;
    /**
     * 获取所有性能指标
     */
    getAllPerformanceMetrics(): any;
    /**
     * 生成性能报告
     */
    generatePerformanceReport(): any;
    /**
     * 智能预加载
     */
    smartPreload(currentAppId: string): void;
    /**
     * 清理资源
     */
    cleanup(): Promise<void>;
    /**
     * 获取系统状态
     */
    getSystemStatus(): any;
    /**
     * 设置获取token的函数
     */
    setGetTokenFunction(fn: () => string | null): void;
    /**
     * 获取token
     */
    getToken(): string | null;
    /**
     * 打开应用路由
     */
    openAppRoute(appId: string, routeParams: RouteParams): Promise<void>;
    /**
     * 打开应用（默认路由）
     */
    openApp(appId: string): void;
    /**
     * 向指定应用发送消息
     */
    sendMessageToApp(targetAppId: string, messageType: string, payload?: any, options?: {
        from?: string;
    }): Promise<void>;
    /**
     * 广播消息到所有应用
     */
    broadcastMessage(messageType: string, payload?: any, options?: {
        from?: string;
        excludeAppIds?: string[];
    }): void;
    /**
     * 确保已初始化
     */
    private ensureInitialized;
    /**
     * 设置事件监听器
     */
    private setupEventListeners;
    /**
     * 注册插件
     */
    registerPlugin(plugin: any): Promise<void>;
    /**
     * 卸载插件
     */
    unregisterPlugin(pluginId: string): Promise<void>;
    /**
     * 获取插件
     */
    getPlugin(pluginId: string): any;
    /**
     * 获取所有插件
     */
    getAllPlugins(): any[];
    /**
     * 检查是否有插件
     */
    hasPlugin(pluginId: string): boolean;
    /**
     * 获取插件管理器
     */
    getPluginManager(): PluginManager;
    /**
     * 检查是否启用调试模式
     */
    isDebugEnabled(): boolean;
    /**
     * 获取日志记录器
     */
    getLogger(): Logger;
    /**
     * 创建子日志记录器
     */
    createChildLogger(moduleName: string): Logger;
    /**
     * 添加事件监听器
     */
    addEventListener(name: string, listener: EventListener_3, once?: boolean): void;
    /**
     * 移除事件监听器
     */
    removeEventListener(name: string, listener: EventListener_3): void;
    setGlobalData(key: string, value: any): void;
    getGlobalData(key: string): any;
    removeGlobalData(key: string): void;
    clearGlobalData(): void;
}

/**
 * 微应用管理器配置选项
 */
declare interface MicroAppManagerOptions {
    /** 容器ID */
    id: string;
    /** 日志等级 */
    logLevel?: LogLevel;
    /** 配置管理器 */
    configManager: ConfigManager;
    /** 预加载管理器 */
    preloadManager: PreloadManager;
    /** 性能监控器 */
    performanceMonitor: PerformanceMonitor;
    /** 事件总线 */
    eventBus: EventBus;
    /** 错误处理器 */
    errorHandler: ErrorHandler;
    /** 数据仓库管理器 */
    storeManager: StoreManager;
    /** 父级日志记录器（可选） */
    parentLogger?: Logger;
    /** 是否自动为各个管理器设置子 logger（默认 true） */
    autoSetupLoggers?: boolean;
}

declare interface MicroAppMessage<T = any> {
    id: string;
    type: string;
    payload: T;
    timestamp: number;
    source: string;
    target: string;
}

export declare const MicroAppVuePlugin: {
    install: (app: any) => void;
};

/**
 * 性能配置
 */
declare interface PerformanceConfig {
    /**
     * 是否启用性能监控
     */
    enabled?: boolean;
    /**
     * 监控间隔（毫秒）
     */
    interval?: number;
    /**
     * 是否启用内存监控
     */
    memoryMonitoring?: boolean;
    /**
     * 是否启用CPU监控
     */
    cpuMonitoring?: boolean;
    /**
     * 是否启用网络监控
     */
    networkMonitoring?: boolean;
    /**
     * 性能阈值警告
     */
    thresholds?: {
        loadTime?: number;
        mountTime?: number;
        renderTime?: number;
        memoryUsage?: number;
        cpuUsage?: number;
    };
    /**
     * 是否自动上报
     */
    autoReport?: boolean;
    /**
     * 上报端点
     */
    reportEndpoint?: string;
}

declare interface PerformanceMetrics {
    loadTime: number;
    mountTime: number;
    memoryUsage?: number;
    errorCount: number;
}

/**
 * 性能指标类型
 */
declare interface PerformanceMetrics_2 {
    /**
     * 应用ID
     */
    appId: string;
    /**
     * 加载时间（毫秒）
     */
    loadTime: number;
    /**
     * 挂载时间（毫秒）
     */
    mountTime: number;
    /**
     * 渲染时间（毫秒）
     */
    renderTime: number;
    /**
     * 内存使用量（MB）
     */
    memoryUsage: number;
    /**
     * CPU使用率（%）
     */
    cpuUsage: number;
    /**
     * 网络请求数量
     */
    networkRequests: number;
    /**
     * 错误数量
     */
    errorCount: number;
    /**
     * 时间戳
     */
    timestamp: number;
}

declare class PerformanceMonitor {
    private ctx;
    private metrics;
    private observers;
    private logger;
    constructor(ctx: InstanceContainer, logger?: Logger);
    /**
     * 开始监控应用性能
     */
    startMonitoring(appId: string): void;
    /**
     * 记录错误
     */
    recordError(appId: string): void;
    /**
     * 获取应用性能指标
     */
    getMetrics(appId: string): PerformanceMetrics | undefined;
    /**
     * 获取所有性能指标
     */
    getAllMetrics(): Map<string, PerformanceMetrics>;
    /**
     * 获取平均加载时间
     */
    getAverageLoadTime(): number;
    /**
     * 获取平均挂载时间
     */
    getAverageMountTime(): number;
    /**
     * 获取内存使用情况
     */
    getMemoryUsage(): number;
    /**
     * 清理性能数据
     */
    clearMetrics(appId?: string): void;
    /**
     * 设置性能观察器
     */
    private setupPerformanceObservers;
    /**
     * 生成性能报告
     */
    generateReport(): object;
    /**
     * 生成性能优化建议
     */
    private generateRecommendations;
    /**
     * 销毁观察器
     */
    destroy(): void;
    /**
     * 设置日志记录器
     */
    setLogger(logger: Logger): void;
}

/**
 * 性能监控插件
 */
export declare class PerformancePlugin extends BasePlugin {
    id: string;
    name: string;
    version: string;
    description: string;
    author: string;
    private config;
    private metrics;
    private timers;
    private intervals;
    private observers;
    private logger;
    constructor(config?: PerformanceConfig);
    install(manager: MicroAppManager): Promise<void>;
    uninstall(manager: MicroAppManager): Promise<void>;
    beforeAppLoad(config: MicroAppConfig): Promise<void>;
    afterAppLoad(config: MicroAppConfig): Promise<void>;
    beforeAppUnload(appId: string): Promise<void>;
    afterAppUnload(appId: string): Promise<void>;
    /**
     * 开始监控
     */
    private startMonitoring;
    /**
     * 停止监控
     */
    private stopMonitoring;
    /**
     * 收集性能指标
     */
    private collectMetrics;
    /**
     * 记录指标
     */
    private recordMetrics;
    /**
     * 记录单个指标
     */
    private recordMetric;
    /**
     * 记录最终指标
     */
    private recordFinalMetrics;
    /**
     * 计算平均指标
     */
    private calculateAverageMetrics;
    /**
     * 获取网络请求数量
     */
    private getNetworkRequestCount;
    /**
     * 上报指标
     */
    private reportMetrics;
    /**
     * 初始化性能观察器
     */
    private initializeObservers;
    /**
     * 获取应用性能指标
     */
    getAppMetrics(appId: string): PerformanceMetrics_2[];
    /**
     * 获取所有应用性能指标
     */
    getAllMetrics(): Map<string, PerformanceMetrics_2[]>;
    /**
     * 获取性能报告
     */
    getPerformanceReport(): {
        apps: Record<string, {
            average: Partial<PerformanceMetrics_2>;
            latest: PerformanceMetrics_2 | null;
            count: number;
        }>;
        summary: {
            totalApps: number;
            totalMetrics: number;
            averageLoadTime: number;
            averageMemoryUsage: number;
        };
    };
    /**
     * 清空指标
     */
    clearMetrics(appId?: string): void;
}

/**
 * 插件接口
 */
declare interface Plugin_2 extends PluginLifecycle, PluginMetadata {
    /**
     * 插件唯一标识
     */
    id: string;
}
export { Plugin_2 as Plugin }

/**
 * 插件生命周期钩子
 */
export declare interface PluginLifecycle {
    /**
     * 插件安装时调用
     */
    install?(manager: MicroAppManager): void | Promise<void>;
    /**
     * 插件卸载时调用
     */
    uninstall?(manager: MicroAppManager): void | Promise<void>;
    /**
     * 应用加载前调用
     */
    beforeAppLoad?(config: MicroAppConfig): void | Promise<void>;
    /**
     * 应用加载后调用
     */
    afterAppLoad?(config: MicroAppConfig): void | Promise<void>;
    /**
     * 应用卸载前调用
     */
    beforeAppUnload?(appId: string): void | Promise<void>;
    /**
     * 应用卸载后调用
     */
    afterAppUnload?(appId: string): void | Promise<void>;
    /**
     * 路由变化前调用
     */
    beforeRouteChange?(routeParams: any): void | Promise<void>;
    /**
     * 路由变化后调用
     */
    afterRouteChange?(routeParams: any): void | Promise<void>;
    /**
     * 消息发送前调用
     */
    beforeMessageSend?(message: any): void | Promise<void>;
    /**
     * 消息接收后调用
     */
    afterMessageReceive?(message: any): void | Promise<void>;
    /**
     * 错误发生时调用
     */
    onError?(error: Error, context?: any): void | Promise<void>;
}

/**
 * 插件管理器
 */
declare class PluginManager {
    private plugins;
    private lifecycleHooks;
    private manager;
    private logger;
    constructor();
    /**
     * 设置 MicroAppManager 实例
     */
    setManager(manager: MicroAppManager): void;
    /**
     * 设置日志记录器
     */
    setLogger(logger: Logger): void;
    /**
     * 注册插件
     */
    registerPlugin(plugin: Plugin_2): Promise<void>;
    /**
     * 卸载插件
     */
    unregisterPlugin(pluginId: string): Promise<void>;
    /**
     * 获取插件
     */
    getPlugin(pluginId: string): Plugin_2 | undefined;
    /**
     * 获取所有插件
     */
    getAllPlugins(): Plugin_2[];
    /**
     * 检查插件是否已注册
     */
    hasPlugin(pluginId: string): boolean;
    /**
     * 触发生命周期钩子
     */
    triggerHook(hookName: string, ...args: any[]): Promise<void>;
    /**
     * 初始化生命周期钩子映射
     */
    private initializeLifecycleHooks;
    /**
     * 注册插件的生命周期钩子
     */
    private registerLifecycleHooks;
    /**
     * 移除插件的生命周期钩子
     */
    private unregisterLifecycleHooks;
    /**
     * 获取插件统计信息
     */
    getPluginStats(): {
        total: number;
        active: number;
        plugins: Array<{
            id: string;
            name: string;
            version: string;
        }>;
    };
}

/**
 * 插件元数据
 */
export declare interface PluginMetadata {
    /**
     * 插件名称
     */
    name: string;
    /**
     * 插件版本
     */
    version: string;
    /**
     * 插件描述
     */
    description?: string;
    /**
     * 插件作者
     */
    author?: string;
    /**
     * 依赖的其他插件
     */
    dependencies?: string[];
    /**
     * 插件配置选项
     */
    options?: Record<string, any>;
}

declare class PreloadManager {
    private ctx;
    private preloadedApps;
    private preloadErrors;
    private preloadQueue;
    private isPreloading;
    private maxPreloadCount;
    private configGetter;
    private logger;
    constructor(ctx: InstanceContainer, logger?: Logger);
    /**
     * 预加载应用（增强版）
     */
    preloadApp(config: MicroAppConfig): Promise<void>;
    /**
     * 批量预加载应用
     */
    preloadApps(configs: MicroAppConfig[]): Promise<void>;
    /**
     * 处理预加载队列
     */
    private processPreloadQueue;
    /**
     * 创建预加载iframe
     */
    private createPreloadIframe;
    /**
     * 检测跨域错误
     */
    private detectCorsError;
    /**
     * 检测网络连接
     */
    private detectNetworkError;
    /**
     * 获取预加载的iframe
     */
    getPreloadedIframe(appId: string): HTMLIFrameElement | undefined;
    /**
     * 移除预加载的iframe
     */
    removePreloadedIframe(appId: string): void;
    /**
     * 清理所有预加载的iframe
     */
    clearAllPreloadedIframes(): void;
    /**
     * 获取预加载状态
     */
    getPreloadStatus(appId: string): boolean;
    /**
     * 获取预加载错误
     */
    getPreloadError(appId: string): Error | undefined;
    /**
     * 检查是否有预加载错误
     */
    hasPreloadError(appId: string): boolean;
    /**
     * 重试预加载
     */
    retryPreload(appId: string): Promise<void>;
    /**
     * 获取所有预加载的应用
     */
    getPreloadedApps(): string[];
    /**
     * 获取所有预加载失败的应用
     */
    getFailedPreloadApps(): string[];
    /**
     * 设置最大预加载数量
     */
    setMaxPreloadCount(count: number): void;
    /**
     * 智能预加载（基于用户行为）
     */
    smartPreload(configs: MicroAppConfig[], currentAppId: string): void;
    /**
     * 获取相关应用（基于配置或使用模式）
     */
    private getRelatedApps;
    /**
     * 设置事件监听器
     */
    private setupEventListeners;
    /**
     * 获取应用配置（修复后的方法）
     */
    private getAppConfig;
    /**
     * 设置配置获取方法
     */
    setConfigGetter(getter: (appId: string) => MicroAppConfig | null): void;
    /**
     * 设置日志记录器
     */
    setLogger(logger: Logger): void;
    /**
     * 获取预加载统计信息
     */
    getPreloadStats(): object;
}

export declare interface RouteParams {
    route: string;
    query?: string | Record<string, string>;
    params?: Record<string, string>;
}

declare interface RouteQueryOption {
    type: 'static' | 'globalData' | 'dynamic';
    value?: string;
    key?: string;
}

/**
 * 安全配置
 */
declare interface SecurityConfig {
    /**
     * 是否启用CSP
     */
    enableCSP?: boolean;
    /**
     * CSP策略
     */
    cspPolicy?: string;
    /**
     * 是否启用沙箱
     */
    enableSandbox?: boolean;
    /**
     * 沙箱配置
     */
    sandboxConfig?: {
        allowScripts?: boolean;
        allowSameOrigin?: boolean;
        allowForms?: boolean;
        allowPopups?: boolean;
        allowModals?: boolean;
        allowTopNavigation?: boolean;
    };
    /**
     * 允许的域名白名单
     */
    allowedDomains?: string[];
    /**
     * 是否启用XSS防护
     */
    enableXSSProtection?: boolean;
    /**
     * 是否启用CSRF防护
     */
    enableCSRFProtection?: boolean;
    /**
     * CSRF Token名称
     */
    csrfTokenName?: string;
}

/**
 * 安全插件
 */
export declare class SecurityPlugin extends BasePlugin {
    id: string;
    name: string;
    version: string;
    description: string;
    author: string;
    private config;
    private securityEvents;
    private logger;
    constructor(config?: SecurityConfig);
    install(manager: MicroAppManager): Promise<void>;
    uninstall(manager: MicroAppManager): Promise<void>;
    beforeAppLoad(config: MicroAppConfig): Promise<void>;
    beforeMessageSend(message: any): Promise<void>;
    afterMessageReceive(message: any): Promise<void>;
    onError(error: Error, context?: any): Promise<void>;
    /**
     * 设置CSP策略
     */
    private setupCSP;
    /**
     * 设置安全头
     */
    private setupSecurityHeaders;
    /**
     * 验证应用URL安全性
     */
    private validateAppUrl;
    /**
     * 检查域名白名单
     */
    private checkDomainWhitelist;
    /**
     * 验证消息安全性
     */
    private validateMessage;
    /**
     * 检查接收到的消息
     */
    private checkReceivedMessage;
    /**
     * 检查XSS攻击
     */
    private checkForXSS;
    /**
     * 检查对象中的XSS
     */
    private checkObjectForXSS;
    /**
     * 生成CSRF Token
     */
    generateCSRFToken(): string;
    /**
     * 验证CSRF Token
     */
    validateCSRFToken(token: string): boolean;
    /**
     * 获取沙箱配置
     */
    getSandboxConfig(): string;
    /**
     * 记录安全事件
     */
    private recordSecurityEvent;
    /**
     * 获取安全事件
     */
    getSecurityEvents(type?: string): Array<{
        type: string;
        timestamp: number;
        details: any;
    }>;
    /**
     * 获取安全报告
     */
    getSecurityReport(): {
        totalEvents: number;
        eventsByType: Record<string, number>;
        recentEvents: Array<{
            type: string;
            timestamp: number;
            details: any;
        }>;
        securityStatus: {
            cspEnabled: boolean;
            sandboxEnabled: boolean;
            xssProtectionEnabled: boolean;
            csrfProtectionEnabled: boolean;
        };
    };
    /**
     * 清空安全事件
     */
    clearSecurityEvents(): void;
}

export declare function startMicroApp(options?: MicroAppClientOptions): Promise<MicroAppClientAPI>;

declare class StoreManager {
    private ctx;
    private stores;
    private logger;
    constructor(ctx: InstanceContainer, logger?: Logger);
    get(name: string): any;
    set(name: string, store: any): void;
    remove(name: string): void;
    clear(): void;
    /**
     * 设置日志记录器
     */
    setLogger(logger: Logger): void;
}

/**
 * 节流函数
 */
export declare function throttle<T extends (...args: any[]) => any>(func: T, limit: number): (...args: Parameters<T>) => void;

/**
 * 验证微应用配置
 */
export declare function validateMicroAppConfig(config: MicroAppConfig): string[];

export { }


declare global {
    interface Window {
        __MICRO_APP__: boolean;
        __MICRO_APP_DEBUGGER__?: boolean;
        microApp?: MicroAppClientAPI;
        __START_MICRO_APP__: (options?: MicroAppClientOptions) => Promise<MicroAppClientAPI>;
    }
}