@cocojs/mvc 0.0.1-alpha202511172034

package/dist/index.d.ts

@@ -0,0 +1,1151 @@
+/// <reference types="@types" />
+
+/**
+ * @public
+ */
+export declare class Api extends Metadata {
+}
+
+export declare const api: () => Decorator<ClassDecoratorContext>;
+
+/**
+ * 表示一个web应用实例
+ * @public
+ */
+export declare class Application {
+    componentMetadataClass: ComponentMetadataClass;
+    metadataRepository: MetadataRepository;
+    idClassMap: IdClassMap;
+    propertiesConfig: PropertiesConfig;
+    constructor(jsonConfig?: Record<string, any>);
+    /**
+     * 在项目中，所以的组件都已经收集到coco/index里面了，所以不需要进行组件收集；
+     * 在测试时，组件是在执行到对应的行装饰器才会执行，所以需要先收集在启动。
+     */
+    start(): void;
+    destructor(): void;
+    /**
+     * 根据组件定义返回组件实例，如果存在多个子组件，需要通过qualify指定子组件id
+     * @param cls - 类定义
+     * @param option
+     */
+    getComponent<T>(cls: Class<T>, option?: {
+        qualifier?: string;
+    }): T;
+    getComponent<T>(id: string, option?: {
+        qualifier?: string;
+    }): T;
+    /**
+     * 仅用于view组件的实例化入口，其他ioc组件都应该使用getComponent
+     * @param viewClass view组件的类定义
+     * @param props 组件的props
+     * @returns
+     */
+    getViewComponent<T>(viewClass: Class<T>, props?: any[]): any;
+    listFieldByMetadataCls(beDecoratedCls: Class<any>, MetadataCls: Class<any>): string[];
+    findClassKindMetadataRecursively(beDecoratedCls: Class<any>, TargetCls: Class<any>, upward?: number): any;
+    listBeDecoratedClsByClassKindMetadata(MetadataCls: Class<any>): Map<Class<any>, Metadata>;
+    getMetaClassById(id: string): Class<Metadata>;
+    /**
+     * 启动所有配置boot的组件
+     */
+    private bootComponent;
+}
+
+/**
+ * 表示一个web应用实例
+ * @public
+ */
+declare class Application_2 {
+    componentMetadataClass: ComponentMetadataClass_2;
+    metadataRepository: MetadataRepository_2;
+    idClassMap: IdClassMap_2;
+    propertiesConfig: PropertiesConfig_2;
+    constructor(jsonConfig?: Record<string, any>);
+    /**
+     * 在项目中，所以的组件都已经收集到coco/index里面了，所以不需要进行组件收集；
+     * 在测试时，组件是在执行到对应的行装饰器才会执行，所以需要先收集在启动。
+     */
+    start(): void;
+    destructor(): void;
+    /**
+     * 根据组件定义返回组件实例，如果存在多个子组件，需要通过qualify指定子组件id
+     * @param cls - 类定义
+     * @param option
+     */
+    getComponent<T>(cls: Class<T>, option?: {
+        qualifier?: string;
+    }): T;
+    getComponent<T>(id: string, option?: {
+        qualifier?: string;
+    }): T;
+    /**
+     * 仅用于view组件的实例化入口，其他ioc组件都应该使用getComponent
+     * @param viewClass view组件的类定义
+     * @param props 组件的props
+     * @returns
+     */
+    getViewComponent<T>(viewClass: Class<T>, props?: any[]): any;
+    listFieldByMetadataCls(beDecoratedCls: Class<any>, MetadataCls: Class<any>): string[];
+    findClassKindMetadataRecursively(beDecoratedCls: Class<any>, TargetCls: Class<any>, upward?: number): any;
+    listBeDecoratedClsByClassKindMetadata(MetadataCls: Class<any>): Map<Class<any>, Metadata_2>;
+    getMetaClassById(id: string): Class<Metadata_2>;
+    /**
+     * 启动所有配置boot的组件
+     */
+    private bootComponent;
+}
+
+/**
+ * 表示一个web应用实例
+ * @public
+ */
+declare class Application_3 {
+    componentMetadataClass: ComponentMetadataClass_3;
+    metadataRepository: MetadataRepository_3;
+    idClassMap: IdClassMap_3;
+    propertiesConfig: PropertiesConfig_3;
+    constructor(jsonConfig?: Record<string, any>);
+    /**
+     * 在项目中，所以的组件都已经收集到coco/index里面了，所以不需要进行组件收集；
+     * 在测试时，组件是在执行到对应的行装饰器才会执行，所以需要先收集在启动。
+     */
+    start(): void;
+    destructor(): void;
+    /**
+     * 根据组件定义返回组件实例，如果存在多个子组件，需要通过qualify指定子组件id
+     * @param cls - 类定义
+     * @param option
+     */
+    getComponent<T>(cls: Class<T>, option?: {
+        qualifier?: string;
+    }): T;
+    getComponent<T>(id: string, option?: {
+        qualifier?: string;
+    }): T;
+    /**
+     * 仅用于view组件的实例化入口，其他ioc组件都应该使用getComponent
+     * @param viewClass view组件的类定义
+     * @param props 组件的props
+     * @returns
+     */
+    getViewComponent<T>(viewClass: Class<T>, props?: any[]): any;
+    listFieldByMetadataCls(beDecoratedCls: Class<any>, MetadataCls: Class<any>): string[];
+    findClassKindMetadataRecursively(beDecoratedCls: Class<any>, TargetCls: Class<any>, upward?: number): any;
+    listBeDecoratedClsByClassKindMetadata(MetadataCls: Class<any>): Map<Class<any>, Metadata_4>;
+    getMetaClassById(id: string): Class<Metadata_4>;
+    /**
+     * 启动所有配置boot的组件
+     */
+    private bootComponent;
+}
+
+/**
+ * @public
+ */
+export declare class Autowired extends Metadata {
+    value: Class<any>;
+}
+
+export declare const autowired: (cls?: Class<any>) => Decorator<ClassFieldDecoratorContext>;
+
+/**
+ * @public
+ */
+export declare class Bind extends Metadata_3 {
+}
+
+export declare const bind: () => Decorator_2<ClassMethodDecoratorContext>;
+
+declare interface BizMetadata {
+    classMetadata: Metadata[];
+    fieldMetadata: Map<Field, Metadata[]>;
+    methodMetadata: Map<Field, Metadata[]>;
+}
+
+declare interface BizMetadata_2 {
+    classMetadata: Metadata_2[];
+    fieldMetadata: Map<Field_2, Metadata_2[]>;
+    methodMetadata: Map<Field_2, Metadata_2[]>;
+}
+
+declare interface BizMetadata_3 {
+    classMetadata: Metadata_4[];
+    fieldMetadata: Map<Field_3, Metadata_4[]>;
+    methodMetadata: Map<Field_3, Metadata_4[]>;
+}
+
+/**
+ * Children
+ * @type {{
+ *   map: (children: any, forEachFunc: any, forEachContext: any)=> void,
+ *   forEach: (children: any, func: any, context: any) => void
+ * }}
+ */
+export declare const Children: {
+    map: (children: any, forEachFunc: any, forEachContext: any) => void;
+    forEach: (children: any, func: any, context: any) => void;
+};
+
+/**
+ * Component不添加@scope(SCOPE.Singleton)的原因：
+ * 因为不设置默认就是singleton，还可以避免 scope <-> target 循环依赖的问题
+ */
+/**
+ * @public
+ */
+export declare class Component extends Metadata {
+    value?: Class<any>;
+}
+
+export declare const component: (value?: Class<any>) => Decorator<ClassDecoratorContext | ClassMethodDecoratorContext>;
+
+/**
+ * @public
+ * @param metadata - 元数据实例对象
+ * @param application - 全局的application对象
+ */
+declare type ComponentClassPostConstructFn = (metadata: Metadata, application: Application) => void;
+
+/**
+ * @public
+ * @param metadata - 元数据实例对象
+ * @param application - 全局的application对象
+ * @param field - 被装饰的字段名
+ */
+declare type ComponentFieldPostConstructFn = (metadata: Metadata, application: Application, field: Field) => void;
+
+declare class ComponentMetadataClass {
+    isComponent: Map<Class<Metadata>, boolean>;
+    isComponentMetadata(MetadataClass: Class<Metadata>): boolean;
+    /**
+     * 校验元数据类的组件类，过滤掉所有非法的组件元数据信息
+     * @param metadataListMap 元数据类的元数据信息
+     * @returns 诊断信息
+     */
+    validateMetadata(metadataListMap: Map<Class<Metadata>, MetaMetadata>): Diagnose[];
+    /**
+     * 检测组件装饰器依赖图中的循环
+     * @param componentDecoratorSet 组件装饰器依赖图
+     * @returns 所有循环的集合，每个循环是一个 Set<Class<Metadata>>
+     */
+    private detectCycles;
+}
+
+declare class ComponentMetadataClass_2 {
+    isComponent: Map<Class<Metadata_2>, boolean>;
+    isComponentMetadata(MetadataClass: Class<Metadata_2>): boolean;
+    /**
+     * 校验元数据类的组件类，过滤掉所有非法的组件元数据信息
+     * @param metadataListMap 元数据类的元数据信息
+     * @returns 诊断信息
+     */
+    validateMetadata(metadataListMap: Map<Class<Metadata_2>, MetaMetadata_2>): Diagnose_2[];
+    /**
+     * 检测组件装饰器依赖图中的循环
+     * @param componentDecoratorSet 组件装饰器依赖图
+     * @returns 所有循环的集合，每个循环是一个 Set<Class<Metadata>>
+     */
+    private detectCycles;
+}
+
+declare class ComponentMetadataClass_3 {
+    isComponent: Map<Class<Metadata_4>, boolean>;
+    isComponentMetadata(MetadataClass: Class<Metadata_4>): boolean;
+    /**
+     * 校验元数据类的组件类，过滤掉所有非法的组件元数据信息
+     * @param metadataListMap 元数据类的元数据信息
+     * @returns 诊断信息
+     */
+    validateMetadata(metadataListMap: Map<Class<Metadata_4>, MetaMetadata_3>): Diagnose_3[];
+    /**
+     * 检测组件装饰器依赖图中的循环
+     * @param componentDecoratorSet 组件装饰器依赖图
+     * @returns 所有循环的集合，每个循环是一个 Set<Class<Metadata>>
+     */
+    private detectCycles;
+}
+
+/**
+ * @public
+ */
+declare type ComponentMethodPostConstructFn = (metadata: Metadata, application: Application, field: Field) => void;
+
+declare type ComponentPostConstruct = ComponentClassPostConstructFn | ComponentMethodPostConstructFn | ComponentFieldPostConstructFn;
+
+/**
+ * @public
+ */
+export declare class Configuration extends Metadata {
+}
+
+export declare const configuration: () => Decorator<ClassDecoratorContext>;
+
+/**
+ * @public
+ */
+export declare class ConstructorParam extends Metadata {
+    value: Class<any>[];
+}
+
+export declare const constructorParam: () => Decorator<ClassDecoratorContext>;
+
+/**
+ * @public
+ */
+export declare class Cookie extends Metadata_3 {
+}
+
+export declare const cookie: () => Decorator_2<ClassDecoratorContext>;
+
+/**
+ * 使用元数据类创建一个装饰器函数
+ * 适用于装饰器不装饰自己元数据类的场景
+ * @public
+ */
+export declare function createDecoratorExp(metadataCls: Class<any>, option?: CreateDecoratorExpOption): DecoratorExp;
+
+declare interface CreateDecoratorExpOption {
+    /**
+     * 类实例化之后，会调用类的装饰器的componentPostConstruct做自定义的处理
+     * @param metadata 装饰器参数实例化的元数据实例
+     * @param application 全局application对象
+     * @param field 被装饰的field名
+     * @returns
+     */
+    componentPostConstruct?: ComponentPostConstruct;
+}
+
+/**
+ * 创建一个未绑定元数据的装饰器表达式，后续通过表达式的第二个参数来绑定
+ * 适用于装饰器装饰自己元数据类的场景
+ * @public
+ */
+export declare function createPlaceholderDecoratorExp<T>(option?: CreateDecoratorExpOption): DecoratorExpWithDecoratorSelf<T>;
+
+/**
+ * @public
+ */
+export declare type Decorator<C> = (value: any, context: C) => any;
+
+/**
+ * @public
+ */
+declare type Decorator_2<C> = (value: any, context: C) => any;
+
+/**
+ * @public
+ */
+declare type Decorator_3<C> = (value: any, context: C) => any;
+
+declare interface DecoratorExp {
+    (userParam?: any): Decorator<DecoratorContext>;
+}
+
+declare interface DecoratorExpWithDecoratorSelf<T extends any> {
+    (userParam?: T): Decorator<DecoratorContext>;
+    decorateSelf: (userParam?: T) => Decorator<DecoratorContext>;
+}
+
+declare interface Diagnose {
+    code: DiagnoseCode;
+    args: any[];
+}
+
+declare interface Diagnose_2 {
+    code: DiagnoseCode_2;
+    args: any[];
+}
+
+declare interface Diagnose_3 {
+    code: DiagnoseCode_3;
+    args: any[];
+}
+
+declare enum DiagnoseCode {
+    'CO10001' = 'CO10001',
+    'CO10002' = 'CO10002', // 元数据类必须要添加@target
+    'CO10003' = 'CO10003',
+    'CO10004' = 'CO10004',
+    'CO10005' = 'CO10005',
+    'CO10006' = 'CO10006',
+    'CO10007' = 'CO10007', // 业务类不需要添加@target
+    'CO10008' = 'CO10008', // 只有配置类内部才可以使用component注入第三方组件。
+    'CO10009' = 'CO10009', // autowired注入的类存在多个子类，但是没有使用@qualifier装饰器
+    'CO10010' = 'CO10010', // autowired注入的类存在多个子类，但@qualifier装饰器指定了一个不存在的子类id
+    'CO10011' = 'CO10011', // 要实例化的类没有注册为ioc组件
+    'CO10012' = 'CO10012', // 通过autowired注入的依赖不能是自己
+    'CO10013' = 'CO10013', // 实例化过程中发现循环依赖
+    'CO10014' = 'CO10014', // 一个元数据类创建了不止一个装饰器
+    'CO10015' = 'CO10015', // 元数据类本身存在id属性，且不能修改
+    'CO10016' = 'CO10016', // 元数据类没有id属性或者id属性不是字符串
+    'CO10017' = 'CO10017', // 元数据类id属性存在重复
+    'CO10018' = 'CO10018', // createDecoratorExp的第一个参数不是类，或者不是Metadata的子类
+    'CO10019' = 'CO10019', // 装饰器暂时不是支持装饰 setter getter accessor 类型。
+    'CO10020' = 'CO10020', // [warn]占位的元数据类没有使用decorateSelf函数，但装饰器也没有被使用
+    'CO10021' = 'CO10021', // 占位的元数据类没有使用decorateSelf函数
+    'CO10022' = 'CO10022', // 元数据类不能有字段装饰器
+    'CO10023' = 'CO10023', // 元数据类不能有方法装饰器
+    'CO10024' = 'CO10024', // 元数据类存在多个组件装饰器
+}
+
+declare enum DiagnoseCode_2 {
+    'CO10001' = 'CO10001',
+    'CO10002' = 'CO10002', // 元数据类必须要添加@target
+    'CO10003' = 'CO10003',
+    'CO10004' = 'CO10004',
+    'CO10005' = 'CO10005',
+    'CO10006' = 'CO10006',
+    'CO10007' = 'CO10007', // 业务类不需要添加@target
+    'CO10008' = 'CO10008', // 只有配置类内部才可以使用component注入第三方组件。
+    'CO10009' = 'CO10009', // autowired注入的类存在多个子类，但是没有使用@qualifier装饰器
+    'CO10010' = 'CO10010', // autowired注入的类存在多个子类，但@qualifier装饰器指定了一个不存在的子类id
+    'CO10011' = 'CO10011', // 要实例化的类没有注册为ioc组件
+    'CO10012' = 'CO10012', // 通过autowired注入的依赖不能是自己
+    'CO10013' = 'CO10013', // 实例化过程中发现循环依赖
+    'CO10014' = 'CO10014', // 一个元数据类创建了不止一个装饰器
+    'CO10015' = 'CO10015', // 元数据类本身存在id属性，且不能修改
+    'CO10016' = 'CO10016', // 元数据类没有id属性或者id属性不是字符串
+    'CO10017' = 'CO10017', // 元数据类id属性存在重复
+    'CO10018' = 'CO10018', // createDecoratorExp的第一个参数不是类，或者不是Metadata的子类
+    'CO10019' = 'CO10019', // 装饰器暂时不是支持装饰 setter getter accessor 类型。
+    'CO10020' = 'CO10020', // [warn]占位的元数据类没有使用decorateSelf函数，但装饰器也没有被使用
+    'CO10021' = 'CO10021', // 占位的元数据类没有使用decorateSelf函数
+    'CO10022' = 'CO10022', // 元数据类不能有字段装饰器
+    'CO10023' = 'CO10023', // 元数据类不能有方法装饰器
+    'CO10024' = 'CO10024', // 元数据类存在多个组件装饰器
+}
+
+declare enum DiagnoseCode_3 {
+    'CO10001' = 'CO10001',
+    'CO10002' = 'CO10002', // 元数据类必须要添加@target
+    'CO10003' = 'CO10003',
+    'CO10004' = 'CO10004',
+    'CO10005' = 'CO10005',
+    'CO10006' = 'CO10006',
+    'CO10007' = 'CO10007', // 业务类不需要添加@target
+    'CO10008' = 'CO10008', // 只有配置类内部才可以使用component注入第三方组件。
+    'CO10009' = 'CO10009', // autowired注入的类存在多个子类，但是没有使用@qualifier装饰器
+    'CO10010' = 'CO10010', // autowired注入的类存在多个子类，但@qualifier装饰器指定了一个不存在的子类id
+    'CO10011' = 'CO10011', // 要实例化的类没有注册为ioc组件
+    'CO10012' = 'CO10012', // 通过autowired注入的依赖不能是自己
+    'CO10013' = 'CO10013', // 实例化过程中发现循环依赖
+    'CO10014' = 'CO10014', // 一个元数据类创建了不止一个装饰器
+    'CO10015' = 'CO10015', // 元数据类本身存在id属性，且不能修改
+    'CO10016' = 'CO10016', // 元数据类没有id属性或者id属性不是字符串
+    'CO10017' = 'CO10017', // 元数据类id属性存在重复
+    'CO10018' = 'CO10018', // createDecoratorExp的第一个参数不是类，或者不是Metadata的子类
+    'CO10019' = 'CO10019', // 装饰器暂时不是支持装饰 setter getter accessor 类型。
+    'CO10020' = 'CO10020', // [warn]占位的元数据类没有使用decorateSelf函数，但装饰器也没有被使用
+    'CO10021' = 'CO10021', // 占位的元数据类没有使用decorateSelf函数
+    'CO10022' = 'CO10022', // 元数据类不能有字段装饰器
+    'CO10023' = 'CO10023', // 元数据类不能有方法装饰器
+    'CO10024' = 'CO10024', // 元数据类存在多个组件装饰器
+}
+
+declare class DynamicRoute {
+    regExp: RegExp;
+    paths: string[];
+    constructor(url: string);
+    match(url: string): {};
+}
+
+/**
+ * @public
+ */
+export declare type Field = string;
+
+/**
+ * @public
+ */
+declare type Field_2 = string;
+
+/**
+ * @public
+ */
+declare type Field_3 = string;
+
+/**
+ * @public
+ */
+export declare class Flow extends Metadata {
+}
+
+export declare const flow: () => Decorator<ClassDecoratorContext>;
+
+/**
+ * @public
+ */
+export declare class GlobalData extends Metadata {
+}
+
+export declare const globalData: () => Decorator<ClassDecoratorContext>;
+
+/**
+ * @public
+ */
+export declare class HistoryRouter extends Router {
+    constructor(render: Render_2);
+    handleRouteChange: () => void;
+    init(application: Application_3): void;
+    start(): void;
+    removeListener(): void;
+    navigateTo(url: string): void;
+}
+
+/**
+ * @public
+ */
+export declare class Id extends Metadata {
+    value: string;
+}
+
+/**
+ * @public
+ * @id()装饰器
+ * 用于为元数据类或者组件类设置id，id的作用是可以根据id返回元数据类，也可以根据id实例化组件，所以id必须要唯一。
+ * 如果一个组件不添加id装饰器，那么组件或者元数据类的id就是class.name（webpack目前打包不会压缩class关键字，TODO: rollup打包会压缩class关键字，要么强制添加id装饰器，要么强制不压缩class关键字）
+ * 如果用户显式设置了id装饰器，那么会使用用户设置的id
+ */
+export declare const id: DecoratorExpWithDecoratorSelf<string>;
+
+declare class IdClassMap {
+    private idClassMap;
+    /**
+     * * 保存元数据类本身，方便运行是通过id获取元数据类
+     * * @param metaMetadataMap 元数据类映射map，key是元数据类，value是元数据类的元数据列表
+     */
+    constructor(metaMetadataMap: Map<Class<Metadata>, MetaMetadata>);
+    /**
+     * * 根据id获取元数据类
+     * * @param id 元数据类id
+     * * @returns 元数据类
+     */
+    getMetaClassById(id: string): Class<Metadata>;
+    destructor(): void;
+}
+
+declare class IdClassMap_2 {
+    private idClassMap;
+    /**
+     * * 保存元数据类本身，方便运行是通过id获取元数据类
+     * * @param metaMetadataMap 元数据类映射map，key是元数据类，value是元数据类的元数据列表
+     */
+    constructor(metaMetadataMap: Map<Class<Metadata_2>, MetaMetadata_2>);
+    /**
+     * * 根据id获取元数据类
+     * * @param id 元数据类id
+     * * @returns 元数据类
+     */
+    getMetaClassById(id: string): Class<Metadata_2>;
+    destructor(): void;
+}
+
+declare class IdClassMap_3 {
+    private idClassMap;
+    /**
+     * * 保存元数据类本身，方便运行是通过id获取元数据类
+     * * @param metaMetadataMap 元数据类映射map，key是元数据类，value是元数据类的元数据列表
+     */
+    constructor(metaMetadataMap: Map<Class<Metadata_4>, MetaMetadata_3>);
+    /**
+     * * 根据id获取元数据类
+     * * @param id 元数据类id
+     * * @returns 元数据类
+     */
+    getMetaClassById(id: string): Class<Metadata_4>;
+    destructor(): void;
+}
+
+declare function jsx(component: any, config: any, maybeKey?: any): {
+    $$typeof: any;
+    type: any;
+    key: any;
+    ref: any;
+    props: any;
+};
+export { jsx }
+export { jsx as jsxs }
+
+declare type Kind = typeof KindClass | typeof KindField | typeof KindMethod;
+
+declare type Kind_2 = typeof KindClass_2 | typeof KindField_2 | typeof KindMethod_2;
+
+declare type Kind_3 = typeof KindClass_3 | typeof KindField_3 | typeof KindMethod_3;
+
+export declare const KindClass = "class";
+
+declare const KindClass_2 = "class";
+
+declare const KindClass_3 = "class";
+
+export declare const KindField = "field";
+
+declare const KindField_2 = "field";
+
+declare const KindField_3 = "field";
+
+export declare const KindMethod = "method";
+
+declare const KindMethod_2 = "method";
+
+declare const KindMethod_3 = "method";
+
+/**
+ * @public
+ */
+export declare class Layout extends Metadata_3 {
+}
+
+export declare const layout: () => Decorator_2<ClassDecoratorContext>;
+
+/**
+ * @public
+ */
+export declare class LocalStorage extends Metadata_3 {
+}
+
+declare const localStorage_2: () => Decorator_2<ClassDecoratorContext>;
+export { localStorage_2 as localStorage }
+
+/**
+ * @public
+ */
+export declare class Memoized extends Metadata_3 {
+}
+
+export declare const memoized: () => Decorator_2<ClassMethodDecoratorContext>;
+
+/**
+ * 元信息基类
+ * @public
+ */
+export declare abstract class Metadata {
+}
+
+/**
+ * 元信息基类
+ * @public
+ */
+declare abstract class Metadata_2 {
+}
+
+/**
+ * 元信息基类
+ * @public
+ */
+declare abstract class Metadata_3 {
+}
+
+/**
+ * 元信息基类
+ * @public
+ */
+declare abstract class Metadata_4 {
+}
+
+declare class MetadataRepository {
+    private metaMetadataMap;
+    private bizMetadataMap;
+    constructor(decoratorMap: Map<Class<any>, Params[]>);
+    getAll(): [Map<Class<Metadata>, MetaMetadata>, Map<Class<Metadata>, BizMetadata>];
+    destructor(): void;
+    getMetadataByClass(Cls: Class<any>): {
+        classMetadata: Metadata[];
+        fieldMetadata?: Map<Field, Metadata[]>;
+        methodMetadata?: Map<Field, Metadata[]>;
+    };
+    private addToMap;
+    addClassKindMetadata(cls: Class<any>, MetadataCls?: Class<Metadata>, args?: any): void;
+    addFieldKindMetadata(Cls: Class<any>, fieldName: Field, MetadataCls: Class<Metadata>, args?: any): void;
+    addMethodKindMetadata(Cls: Class<any>, fieldName: Field, MetadataCls: Class<Metadata>, args?: any): void;
+    /**
+     * 获取指定类的类类型的元数据
+     * @param beDecoratedCls 指定类
+     * @param findMetadataCls 如果不指定，返回全部；否则进行列表过滤
+     */
+    listClassKindMetadata(beDecoratedCls: Class<any>, findMetadataCls?: Class<any>): Metadata[];
+    /**
+     * 获取指定类的字段类型的元数据
+     * @param beDecoratedCls 指定类
+     * @param field 指定field名
+     * @param findMetadataCls 如果不指定，返回全部；否则进行列表过滤
+     */
+    listFieldKindMetadata(beDecoratedCls: Class<any>, field: Field, findMetadataCls?: Class<any>): Metadata[];
+    /**
+     * 获取指定类的方法类型的元数据
+     * @param beDecoratedCls 指定类
+     * @param field 指定method名
+     * @param findMetadataCls 如果不指定，返回全部；否则进行列表过滤
+     */
+    listMethodKindMetadata(beDecoratedCls: Class<any>, field: Field, findMetadataCls?: Class<any>): Metadata[];
+    /**
+     * 在类的所有类类型的元数据中递归查找某个元数据类实例，找到就直接返回
+     * TODO: 因为现在组件装饰器的层数没有限制了，那么upward这个参数是否还有必要存在
+     */
+    findClassKindMetadataRecursively(beDecoratedCls: Class<any>, TargetCls: Class<any>, upward?: number): any;
+    /**
+     * 返回包含指定元数据类的所有field
+     * @param beDecoratedCls 指定类
+     * @param MetadataCls 指定元数据类
+     */
+    listFieldByMetadataCls(beDecoratedCls: Class<any>, MetadataCls: Class<any>): Field[];
+    /**
+     * 返回包含指定元数据类的所有method
+     * @param beDecoratedCls 指定类
+     * @param MetadataCls 指定元数据类
+     */
+    listMethodByMetadataCls(beDecoratedCls: Class<any>, MetadataCls: Class<any>): Field[];
+    listBeDecoratedClsByClassKindMetadata(MetadataCls: Class<any>): Map<Class<any>, Metadata>;
+}
+
+declare class MetadataRepository_2 {
+    private metaMetadataMap;
+    private bizMetadataMap;
+    constructor(decoratorMap: Map<Class<any>, Params_2[]>);
+    getAll(): [Map<Class<Metadata_2>, MetaMetadata_2>, Map<Class<Metadata_2>, BizMetadata_2>];
+    destructor(): void;
+    getMetadataByClass(Cls: Class<any>): {
+        classMetadata: Metadata_2[];
+        fieldMetadata?: Map<Field_2, Metadata_2[]>;
+        methodMetadata?: Map<Field_2, Metadata_2[]>;
+    };
+    private addToMap;
+    addClassKindMetadata(cls: Class<any>, MetadataCls?: Class<Metadata_2>, args?: any): void;
+    addFieldKindMetadata(Cls: Class<any>, fieldName: Field_2, MetadataCls: Class<Metadata_2>, args?: any): void;
+    addMethodKindMetadata(Cls: Class<any>, fieldName: Field_2, MetadataCls: Class<Metadata_2>, args?: any): void;
+    /**
+     * 获取指定类的类类型的元数据
+     * @param beDecoratedCls 指定类
+     * @param findMetadataCls 如果不指定，返回全部；否则进行列表过滤
+     */
+    listClassKindMetadata(beDecoratedCls: Class<any>, findMetadataCls?: Class<any>): Metadata_2[];
+    /**
+     * 获取指定类的字段类型的元数据
+     * @param beDecoratedCls 指定类
+     * @param field 指定field名
+     * @param findMetadataCls 如果不指定，返回全部；否则进行列表过滤
+     */
+    listFieldKindMetadata(beDecoratedCls: Class<any>, field: Field_2, findMetadataCls?: Class<any>): Metadata_2[];
+    /**
+     * 获取指定类的方法类型的元数据
+     * @param beDecoratedCls 指定类
+     * @param field 指定method名
+     * @param findMetadataCls 如果不指定，返回全部；否则进行列表过滤
+     */
+    listMethodKindMetadata(beDecoratedCls: Class<any>, field: Field_2, findMetadataCls?: Class<any>): Metadata_2[];
+    /**
+     * 在类的所有类类型的元数据中递归查找某个元数据类实例，找到就直接返回
+     * TODO: 因为现在组件装饰器的层数没有限制了，那么upward这个参数是否还有必要存在
+     */
+    findClassKindMetadataRecursively(beDecoratedCls: Class<any>, TargetCls: Class<any>, upward?: number): any;
+    /**
+     * 返回包含指定元数据类的所有field
+     * @param beDecoratedCls 指定类
+     * @param MetadataCls 指定元数据类
+     */
+    listFieldByMetadataCls(beDecoratedCls: Class<any>, MetadataCls: Class<any>): Field_2[];
+    /**
+     * 返回包含指定元数据类的所有method
+     * @param beDecoratedCls 指定类
+     * @param MetadataCls 指定元数据类
+     */
+    listMethodByMetadataCls(beDecoratedCls: Class<any>, MetadataCls: Class<any>): Field_2[];
+    listBeDecoratedClsByClassKindMetadata(MetadataCls: Class<any>): Map<Class<any>, Metadata_2>;
+}
+
+declare class MetadataRepository_3 {
+    private metaMetadataMap;
+    private bizMetadataMap;
+    constructor(decoratorMap: Map<Class<any>, Params_3[]>);
+    getAll(): [Map<Class<Metadata_4>, MetaMetadata_3>, Map<Class<Metadata_4>, BizMetadata_3>];
+    destructor(): void;
+    getMetadataByClass(Cls: Class<any>): {
+        classMetadata: Metadata_4[];
+        fieldMetadata?: Map<Field_3, Metadata_4[]>;
+        methodMetadata?: Map<Field_3, Metadata_4[]>;
+    };
+    private addToMap;
+    addClassKindMetadata(cls: Class<any>, MetadataCls?: Class<Metadata_4>, args?: any): void;
+    addFieldKindMetadata(Cls: Class<any>, fieldName: Field_3, MetadataCls: Class<Metadata_4>, args?: any): void;
+    addMethodKindMetadata(Cls: Class<any>, fieldName: Field_3, MetadataCls: Class<Metadata_4>, args?: any): void;
+    /**
+     * 获取指定类的类类型的元数据
+     * @param beDecoratedCls 指定类
+     * @param findMetadataCls 如果不指定，返回全部；否则进行列表过滤
+     */
+    listClassKindMetadata(beDecoratedCls: Class<any>, findMetadataCls?: Class<any>): Metadata_4[];
+    /**
+     * 获取指定类的字段类型的元数据
+     * @param beDecoratedCls 指定类
+     * @param field 指定field名
+     * @param findMetadataCls 如果不指定，返回全部；否则进行列表过滤
+     */
+    listFieldKindMetadata(beDecoratedCls: Class<any>, field: Field_3, findMetadataCls?: Class<any>): Metadata_4[];
+    /**
+     * 获取指定类的方法类型的元数据
+     * @param beDecoratedCls 指定类
+     * @param field 指定method名
+     * @param findMetadataCls 如果不指定，返回全部；否则进行列表过滤
+     */
+    listMethodKindMetadata(beDecoratedCls: Class<any>, field: Field_3, findMetadataCls?: Class<any>): Metadata_4[];
+    /**
+     * 在类的所有类类型的元数据中递归查找某个元数据类实例，找到就直接返回
+     * TODO: 因为现在组件装饰器的层数没有限制了，那么upward这个参数是否还有必要存在
+     */
+    findClassKindMetadataRecursively(beDecoratedCls: Class<any>, TargetCls: Class<any>, upward?: number): any;
+    /**
+     * 返回包含指定元数据类的所有field
+     * @param beDecoratedCls 指定类
+     * @param MetadataCls 指定元数据类
+     */
+    listFieldByMetadataCls(beDecoratedCls: Class<any>, MetadataCls: Class<any>): Field_3[];
+    /**
+     * 返回包含指定元数据类的所有method
+     * @param beDecoratedCls 指定类
+     * @param MetadataCls 指定元数据类
+     */
+    listMethodByMetadataCls(beDecoratedCls: Class<any>, MetadataCls: Class<any>): Field_3[];
+    listBeDecoratedClsByClassKindMetadata(MetadataCls: Class<any>): Map<Class<any>, Metadata_4>;
+}
+
+declare interface MetaMetadata {
+    classMetadata: Metadata[];
+    fieldMetadata: Map<Field, Metadata[]>;
+    methodMetadata: Map<Field, Metadata[]>;
+}
+
+declare interface MetaMetadata_2 {
+    classMetadata: Metadata_2[];
+    fieldMetadata: Map<Field_2, Metadata_2[]>;
+    methodMetadata: Map<Field_2, Metadata_2[]>;
+}
+
+declare interface MetaMetadata_3 {
+    classMetadata: Metadata_4[];
+    fieldMetadata: Map<Field_3, Metadata_4[]>;
+    methodMetadata: Map<Field_3, Metadata_4[]>;
+}
+
+/**
+ * @public
+ */
+export declare class Page extends Metadata_3 {
+}
+
+export declare const page: () => Decorator_2<ClassDecoratorContext>;
+
+declare type Params = {
+    metadataKind: Kind;
+    metadataClass: Class<any>;
+    placeholderMetadataClass?: Class<any>;
+    metadataParam: any;
+    /**
+     * 如果metadataKind是'class'，field是undefined
+     * 如果metadataKind是'method'\'field'，field就是对应的prop名字
+     * todo 测试是否支持Symbol类型
+     */
+    field?: Field;
+};
+
+declare type Params_2 = {
+    metadataKind: Kind_2;
+    metadataClass: Class<any>;
+    placeholderMetadataClass?: Class<any>;
+    metadataParam: any;
+    /**
+     * 如果metadataKind是'class'，field是undefined
+     * 如果metadataKind是'method'\'field'，field就是对应的prop名字
+     * todo 测试是否支持Symbol类型
+     */
+    field?: Field_2;
+};
+
+declare type Params_3 = {
+    metadataKind: Kind_3;
+    metadataClass: Class<any>;
+    placeholderMetadataClass?: Class<any>;
+    metadataParam: any;
+    /**
+     * 如果metadataKind是'class'，field是undefined
+     * 如果metadataKind是'method'\'field'，field就是对应的prop名字
+     * todo 测试是否支持Symbol类型
+     */
+    field?: Field_3;
+};
+
+/**
+ * 动态配置操作类
+ * @public
+ */
+export declare class PropertiesConfig {
+    static bootComponentKey: string;
+    beanConfig: Record<string, any>;
+    constructor(jsonConfig?: Record<string, any>);
+    getValue(path: string): any;
+    getAllBootComponents(): string[];
+}
+
+/**
+ * 动态配置操作类
+ * @public
+ */
+declare class PropertiesConfig_2 {
+    static bootComponentKey: string;
+    beanConfig: Record<string, any>;
+    constructor(jsonConfig?: Record<string, any>);
+    getValue(path: string): any;
+    getAllBootComponents(): string[];
+}
+
+/**
+ * 动态配置操作类
+ * @public
+ */
+declare class PropertiesConfig_3 {
+    static bootComponentKey: string;
+    beanConfig: Record<string, any>;
+    constructor(jsonConfig?: Record<string, any>);
+    getValue(path: string): any;
+    getAllBootComponents(): string[];
+}
+
+export declare class Publisher {
+    private readonly name;
+    private subscribers;
+    constructor(name?: string);
+    addListener(subscriber: Subscriber): void;
+    removeListener(subscriber: Subscriber): void;
+    notify(): void;
+}
+
+/**
+ * @public
+ */
+export declare class Qualifier extends Metadata {
+    value: string;
+}
+
+export declare const qualifier: (clsId: string) => Decorator<ClassFieldDecoratorContext>;
+
+/**
+ * 加在field表明是响应式
+ * 加在metadata上用于自定义reactive元数据
+ * @public
+ */
+export declare class Reactive extends Metadata_3 {
+}
+
+export declare const reactive: () => Decorator_2<ClassFieldDecoratorContext | ClassDecoratorContext>;
+
+export declare namespace ReactNoopUpdateQueue {
+    export function isMounted(): boolean;
+    export function enqueueForceUpdate(publicInstance: any, callback: any, callerName: any): void;
+    export function enqueueSetState(publicInstance: any, partialState: any, callback: any, callerName: any): void;
+}
+
+/**
+ * @public
+ */
+export declare class Ref extends Metadata_3 {
+}
+
+export declare const ref: () => Decorator_2<ClassFieldDecoratorContext>;
+
+/**
+ * @public
+ */
+export declare class Refs extends Metadata_3 {
+}
+
+export declare const refs: () => Decorator_2<ClassFieldDecoratorContext>;
+
+/**
+ * @public
+ */
+export declare abstract class Render {
+    abstract render(component: Class<any>): any;
+}
+
+/**
+ * @public
+ */
+declare abstract class Render_2 {
+    abstract render(component: Class<any>): any;
+}
+
+export declare class Route {
+    pathname: string;
+    params: Record<string, string>;
+}
+
+export declare const route: (url: string) => Decorator_3<ClassDecoratorContext>;
+
+declare type Route_2 = string | DynamicRoute;
+
+/**
+ * @public
+ */
+export declare class RouteComponentMapper {
+    mapper: Map<Route_2, Class<any>>;
+    init(map: Map<Class<any>, RouteMeta>): void;
+    private add;
+    match(url: string): any;
+}
+
+/**
+ * @public
+ */
+export declare class RouteMeta extends Metadata_4 {
+    value: string;
+}
+
+/**
+ * @public
+ */
+export declare abstract class Router {
+    protected route: Route;
+    protected render: Render_2;
+    protected routeComponentMapper: RouteComponentMapper;
+    abstract navigateTo(url: string): void;
+}
+
+export declare class RouterMeta extends Metadata_4 {
+}
+
+declare interface Runner {
+    exec: () => void;
+}
+
+/**
+ * @public
+ */
+export declare enum SCOPE {
+    Singleton = 0,
+    Prototype = 1
+}
+
+/**
+ * @public
+ */
+export declare class Scope extends Metadata {
+    value: SCOPE;
+}
+
+export declare const scope: (scope?: SCOPE) => Decorator<ClassDecoratorContext | ClassMethodDecoratorContext>;
+
+/**
+ * @public
+ */
+export declare class SessionStorage extends Metadata_3 {
+}
+
+declare const sessionStorage_2: () => Decorator_2<ClassDecoratorContext>;
+export { sessionStorage_2 as sessionStorage }
+
+/**
+ * @public
+ */
+export declare class Store extends Metadata_3 {
+}
+
+export declare const store: () => Decorator_2<ClassDecoratorContext>;
+
+export declare class StorePublisher {
+    private id;
+    private subscribers;
+    constructor();
+    addListener(subscriber: StoreSubscriber): void;
+    removeListener(subscriber: StoreSubscriber): void;
+    broadcast(): void;
+    getSubscribers(): StoreSubscriber[];
+}
+
+export declare class StoreSubscriber {
+    private id;
+    private publishers;
+    private runner;
+    constructor(runner: Runner);
+    connect(publisher: StorePublisher): void;
+    disconnectAll(): void;
+    exec(): void;
+}
+
+export declare class Subscriber {
+    static Executing: Subscriber;
+    private isDirty;
+    private publishers;
+    private readonly fn;
+    private value;
+    constructor(bindThisFn: Function);
+    subscribe: (publisher: Publisher) => void;
+    memoizedFn: () => any;
+    dirty(): void;
+}
+
+/**
+ * @public
+ */
+export declare class Target extends Metadata {
+    static Type: typeof Type;
+    value: Type[];
+}
+
+/**
+ * @public
+ */
+export declare const target: DecoratorExpWithDecoratorSelf<Type[]>;
+
+/**
+ * @public
+ */
+export declare enum Type {
+    Class = "class",
+    Field = "field",
+    Method = "method"
+}
+
+/**
+ * @public
+ */
+export declare class Util extends Metadata {
+}
+
+export declare const util: () => Decorator<ClassDecoratorContext>;
+
+/**
+ * @public
+ */
+export declare class Value extends Metadata {
+    value: string;
+}
+
+export declare const value: (path: string) => Decorator<ClassFieldDecoratorContext>;
+
+/**
+ * @public
+ */
+export declare class View extends Metadata_3 {
+    static classDecoratorModifyPrototype(prototype: any): void;
+}
+
+export declare const view: () => Decorator_2<ClassDecoratorContext>;
+
+/**
+ * @public
+ */
+export declare class WebApplication extends Metadata {
+}
+
+export declare const webApplication: () => Decorator<ClassDecoratorContext>;
+
+/**
+ * @public
+ */
+export declare class WebRender extends Render {
+    container: HTMLElement;
+    init(application: Application_2): void;
+    render(component: any): any;
+}
+
+export { }