@ai-setting/roy-agent-cli 1.3.14 → 1.3.16

package/dist/core/src/env/workflow/decorators/decorator-node.d.ts

@@ -0,0 +1,77 @@
+/**
+ * DecoratorNode - 执行装饰器类方法的节点
+ *
+ * 实现 Node 接口，用于执行使用 @Workflow/@NodeAs 装饰的类方法
+ */
+import type { Node, NodeDefinition, NodeExecutionContext, NodeExecutionResult } from '../types';
+/**
+ * DecoratorNode 节点配置
+ */
+export interface DecoratorNodeConfig extends NodeDefinition {
+    config: {
+        /** 方法名称 */
+        _methodName: string;
+        /** 类实例 */
+        _instance: any;
+        /** 用户自定义配置 */
+        [key: string]: unknown;
+    };
+}
+/**
+ * DecoratorNode - 执行装饰器类方法的节点
+ *
+ * 用于执行使用 @Workflow/@NodeAs 装饰器定义的类方法
+ *
+ * @example
+ * ```typescript
+ * const definition: DecoratorNodeConfig = {
+ *   id: 'myNode',
+ *   type: 'decorator',
+ *   config: {
+ *     _methodName: 'myMethod',
+ *     _instance: myWorkflowInstance,
+ *   }
+ * };
+ *
+ * const node = new DecoratorNode(definition);
+ * const result = await node.execute(context);
+ * ```
+ */
+export declare class DecoratorNode implements Node {
+    readonly type = "decorator";
+    readonly id: string;
+    private readonly methodName;
+    private readonly instance;
+    private readonly dependsOn;
+    private readonly timeout?;
+    private readonly retryConfig?;
+    constructor(definition: NodeDefinition);
+    /**
+     * 执行装饰器方法
+     */
+    execute(context: NodeExecutionContext): Promise<NodeExecutionResult>;
+    /**
+     * 准备输入参数
+     *
+     * 根据依赖的节点 ID，从 nodeOutputs 中提取对应的输出
+     * 返回格式: { [depNodeId]: depOutput }
+     */
+    private prepareInput;
+    /**
+     * 带重试的执行
+     */
+    private executeWithRetry;
+    /**
+     * 带超时的执行
+     */
+    private executeWithTimeout;
+    /**
+     * 计算退避延迟
+     */
+    private calculateBackoff;
+    /**
+     * 睡眠
+     */
+    private sleep;
+}
+//# sourceMappingURL=decorator-node.d.ts.map

package/dist/core/src/env/workflow/decorators/decorator-node.js

@@ -0,0 +1,176 @@
+/**
+ * DecoratorNode - 执行装饰器类方法的节点
+ *
+ * 实现 Node 接口，用于执行使用 @Workflow/@NodeAs 装饰的类方法
+ */
+/**
+ * DecoratorNode - 执行装饰器类方法的节点
+ *
+ * 用于执行使用 @Workflow/@NodeAs 装饰器定义的类方法
+ *
+ * @example
+ * ```typescript
+ * const definition: DecoratorNodeConfig = {
+ *   id: 'myNode',
+ *   type: 'decorator',
+ *   config: {
+ *     _methodName: 'myMethod',
+ *     _instance: myWorkflowInstance,
+ *   }
+ * };
+ *
+ * const node = new DecoratorNode(definition);
+ * const result = await node.execute(context);
+ * ```
+ */
+export class DecoratorNode {
+    type = 'decorator';
+    id;
+    methodName;
+    instance;
+    dependsOn;
+    timeout;
+    retryConfig;
+    constructor(definition) {
+        const config = definition.config;
+        this.id = definition.id;
+        this.methodName = config._methodName;
+        this.instance = config._instance;
+        this.dependsOn = definition.depends_on || [];
+        this.timeout = definition.timeout;
+        this.retryConfig = definition.retry;
+    }
+    /**
+     * 执行装饰器方法
+     */
+    async execute(context) {
+        const startTime = Date.now();
+        // 获取方法
+        const method = this.instance[this.methodName];
+        if (typeof method !== 'function') {
+            return {
+                success: false,
+                error: `Method '${this.methodName}' is not a function`,
+                duration: Date.now() - startTime,
+            };
+        }
+        // 准备输入参数
+        const input = this.prepareInput(context);
+        // 执行（带重试和超时）
+        const result = await this.executeWithRetry(input, context.abort);
+        return {
+            success: !result.error,
+            output: result.output,
+            error: result.error,
+            duration: Date.now() - startTime,
+            metadata: {
+                methodName: this.methodName,
+            },
+        };
+    }
+    /**
+     * 准备输入参数
+     *
+     * 根据依赖的节点 ID，从 nodeOutputs 中提取对应的输出
+     * 返回格式: { [depNodeId]: depOutput }
+     */
+    prepareInput(context) {
+        // nodeOutputs 可以是 Map 或普通对象
+        const nodeOutputs = context.nodeOutputs;
+        // 如果没有依赖节点，直接使用全局 input
+        if (this.dependsOn.length === 0) {
+            return context.input || {};
+        }
+        // 根据依赖节点 ID 提取输出，构建输入对象
+        const input = {};
+        for (const depId of this.dependsOn) {
+            // 支持 Map 和普通对象
+            const depOutput = nodeOutputs instanceof Map
+                ? nodeOutputs.get(depId)
+                : nodeOutputs?.[depId];
+            if (depOutput && typeof depOutput === 'object') {
+                // 如果是完整的 NodeExecutionResult，提取 output 字段
+                if ('output' in depOutput) {
+                    input[depId] = depOutput.output;
+                }
+                else {
+                    // 已经是裸对象
+                    input[depId] = depOutput;
+                }
+            }
+        }
+        return input;
+    }
+    /**
+     * 带重试的执行
+     */
+    async executeWithRetry(input, abort) {
+        const maxAttempts = this.retryConfig?.max_attempts ?? 1;
+        const backoff = this.retryConfig?.backoff ?? 'exponential';
+        const initialDelay = this.retryConfig?.initial_delay ?? 1000;
+        let lastError;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            // 检查中断信号
+            if (abort?.aborted) {
+                return { error: 'Execution aborted' };
+            }
+            try {
+                // 执行方法
+                const output = await this.executeWithTimeout(input, abort);
+                return { output };
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                // 如果不是最后一次尝试，等待后重试
+                if (attempt < maxAttempts) {
+                    const delay = this.calculateBackoff(backoff, initialDelay, attempt - 1);
+                    await this.sleep(delay, abort);
+                }
+            }
+        }
+        return { error: lastError?.message || 'Unknown error' };
+    }
+    /**
+     * 带超时的执行
+     */
+    async executeWithTimeout(input, abort) {
+        if (!this.timeout) {
+            // 无超时限制
+            return this.instance[this.methodName](input);
+        }
+        // 创建超时 Promise
+        const timeoutPromise = new Promise((_, reject) => {
+            setTimeout(() => {
+                reject(new Error(`Execution timeout after ${this.timeout}ms`));
+            }, this.timeout);
+        });
+        // 竞速执行
+        return Promise.race([
+            this.instance[this.methodName](input),
+            timeoutPromise,
+        ]);
+    }
+    /**
+     * 计算退避延迟
+     */
+    calculateBackoff(backoff, initialDelay, attempt) {
+        if (backoff === 'exponential') {
+            return initialDelay * Math.pow(2, attempt);
+        }
+        return initialDelay;
+    }
+    /**
+     * 睡眠
+     */
+    sleep(ms, abort) {
+        return new Promise((resolve) => {
+            const timeout = setTimeout(resolve, ms);
+            // 如果被中断，清除定时器
+            abort?.addEventListener('abort', () => {
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    }
+}
+//# sourceMappingURL=decorator-node.js.map

package/dist/core/src/env/workflow/decorators/decorator.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @fileoverview Workflow Decorator Integration Tests
+ */
+import 'reflect-metadata';
+//# sourceMappingURL=decorator.test.d.ts.map

package/dist/core/src/env/workflow/decorators/decorator.test.js

@@ -0,0 +1,212 @@
+/**
+ * @fileoverview Workflow Decorator Integration Tests
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { describe, test, expect } from 'bun:test';
+import 'reflect-metadata';
+import { Workflow, NodeAs, WorkflowEdges } from "./index.js";
+import { WorkflowConverter } from "../extractor/workflow-converter.js";
+import { createWorkflowFromClass } from "../utils/create-workflow.js";
+import { getWorkflowMetadata, getNodeMetadatas, getEdgeMetadatas } from "./index.js";
+describe('Workflow Decorators', () => {
+    // ============ Test Workflow Class ============
+    let TestWorkflow = class TestWorkflow {
+        async step1(input) {
+            return { result: `Step1: ${input.message}` };
+        }
+        async step2(input) {
+            return { result: `Step2: ${input.step1.result}` };
+        }
+        async step3(input) {
+            return { result: `Step3: ${input.step1.result}` };
+        }
+        async step4(input) {
+            return {
+                result: `Step4: ${input.step2.result} & ${input.step3.result}`
+            };
+        }
+    };
+    __decorate([
+        NodeAs({ nodeId: 'step1', nodeType: 'tool' }),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", Promise)
+    ], TestWorkflow.prototype, "step1", null);
+    __decorate([
+        NodeAs({ nodeId: 'step2', dependsOn: 'step1' }),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", Promise)
+    ], TestWorkflow.prototype, "step2", null);
+    __decorate([
+        NodeAs({ nodeId: 'step3', dependsOn: 'step1' }),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", Promise)
+    ], TestWorkflow.prototype, "step3", null);
+    __decorate([
+        NodeAs({ nodeId: 'step4', dependsOn: ['step2', 'step3'] }),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", Promise)
+    ], TestWorkflow.prototype, "step4", null);
+    TestWorkflow = __decorate([
+        Workflow({
+            name: 'test-workflow',
+            version: '1.0',
+            description: 'Test workflow for decorator functionality',
+            entry: 'step1',
+            config: { parallel_limit: 3 }
+        }),
+        WorkflowEdges([
+            { from: 'step2', to: 'step3' },
+            { from: 'step3', to: 'step4' }
+        ])
+    ], TestWorkflow);
+    // ============ Tests ============
+    test('should extract workflow metadata', () => {
+        const metadata = getWorkflowMetadata(TestWorkflow);
+        expect(metadata).toBeDefined();
+        expect(metadata?.name).toBe('test-workflow');
+        expect(metadata?.version).toBe('1.0');
+        expect(metadata?.description).toBe('Test workflow for decorator functionality');
+        expect(metadata?.entry).toBe('step1');
+    });
+    test('should extract node metadatas', () => {
+        const nodes = getNodeMetadatas(TestWorkflow.prototype);
+        expect(nodes).toHaveLength(4);
+        // Check step1
+        const step1 = nodes.find(n => n.nodeId === 'step1');
+        expect(step1).toBeDefined();
+        expect(step1?.nodeType).toBe('tool');
+        expect(step1?.dependsOn).toEqual([]);
+        expect(step1?.methodName).toBe('step1');
+        // Check step2 (depends on step1)
+        const step2 = nodes.find(n => n.nodeId === 'step2');
+        expect(step2).toBeDefined();
+        expect(step2?.dependsOn).toEqual(['step1']);
+        // Check step4 (depends on step2 and step3)
+        const step4 = nodes.find(n => n.nodeId === 'step4');
+        expect(step4).toBeDefined();
+        expect(step4?.dependsOn).toEqual(['step2', 'step3']);
+    });
+    test('should extract edge metadatas', () => {
+        const edges = getEdgeMetadatas(TestWorkflow);
+        expect(edges).toHaveLength(2);
+        expect(edges).toContainEqual({ from: 'step2', to: 'step3' });
+        expect(edges).toContainEqual({ from: 'step3', to: 'step4' });
+    });
+    test('should validate workflow class', () => {
+        const result = WorkflowConverter.validateWorkflowClass(TestWorkflow);
+        expect(result.valid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+    });
+    test('should convert to WorkflowDefinition', () => {
+        const workflow = createWorkflowFromClass(TestWorkflow);
+        expect(workflow.name).toBe('test-workflow');
+        expect(workflow.version).toBe('1.0');
+        expect(workflow.nodes).toHaveLength(4);
+        // Check nodes
+        const step1Node = workflow.nodes.find(n => n.id === 'step1');
+        expect(step1Node).toBeDefined();
+        expect(step1Node?.type).toBe('tool');
+        expect(step1Node?.depends_on).toEqual([]);
+        const step4Node = workflow.nodes.find(n => n.id === 'step4');
+        expect(step4Node).toBeDefined();
+        expect(step4Node?.depends_on).toContain('step2');
+        expect(step4Node?.depends_on).toContain('step3');
+    });
+    test('should validate missing entry node', () => {
+        let BrokenWorkflow = class BrokenWorkflow {
+            async step1() { return {}; }
+        };
+        __decorate([
+            NodeAs({ nodeId: 'step1' }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], BrokenWorkflow.prototype, "step1", null);
+        BrokenWorkflow = __decorate([
+            Workflow({ name: 'broken-workflow', entry: 'nonexistent' })
+        ], BrokenWorkflow);
+        const result = WorkflowConverter.validateWorkflowClass(BrokenWorkflow);
+        expect(result.valid).toBe(false);
+        expect(result.errors.some(e => e.includes("Entry node 'nonexistent' not found"))).toBe(true);
+    });
+    test('should validate missing dependency', () => {
+        let BrokenWorkflow2 = class BrokenWorkflow2 {
+            async step1() { return {}; }
+        };
+        __decorate([
+            NodeAs({ nodeId: 'step1', dependsOn: 'nonexistent' }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], BrokenWorkflow2.prototype, "step1", null);
+        BrokenWorkflow2 = __decorate([
+            Workflow({ name: 'broken-workflow-2' })
+        ], BrokenWorkflow2);
+        const result = WorkflowConverter.validateWorkflowClass(BrokenWorkflow2);
+        expect(result.valid).toBe(false);
+        expect(result.errors.some(e => e.includes("depends on non-existent node"))).toBe(true);
+    });
+    test('should validate cycle detection', () => {
+        let CyclicWorkflow = class CyclicWorkflow {
+            async a() { return {}; }
+            async b() { return {}; }
+            async c() { return {}; }
+        };
+        __decorate([
+            NodeAs({ nodeId: 'a', dependsOn: 'c' }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], CyclicWorkflow.prototype, "a", null);
+        __decorate([
+            NodeAs({ nodeId: 'b', dependsOn: 'a' }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], CyclicWorkflow.prototype, "b", null);
+        __decorate([
+            NodeAs({ nodeId: 'c', dependsOn: 'b' }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], CyclicWorkflow.prototype, "c", null);
+        CyclicWorkflow = __decorate([
+            Workflow({ name: 'cyclic-workflow' })
+        ], CyclicWorkflow);
+        const result = WorkflowConverter.validateWorkflowClass(CyclicWorkflow);
+        expect(result.valid).toBe(false);
+        expect(result.errors.some(e => e.includes('cycle'))).toBe(true);
+    });
+    test('should execute decorator node method', async () => {
+        const workflow = createWorkflowFromClass(TestWorkflow);
+        const step1Node = workflow.nodes.find(n => n.id === 'step1');
+        const result = await WorkflowConverter.executeNode(step1Node, { input: { message: 'hello' }, previousOutputs: new Map() });
+        expect(result.output).toEqual({ result: 'Step1: hello' });
+        expect(result.error).toBeUndefined();
+    });
+    test('should handle node execution with dependencies', async () => {
+        const workflow = createWorkflowFromClass(TestWorkflow);
+        const step4Node = workflow.nodes.find(n => n.id === 'step4');
+        const previousOutputs = new Map([
+            ['step2', { result: 'Step2: data2' }],
+            ['step3', { result: 'Step3: data3' }]
+        ]);
+        const result = await WorkflowConverter.executeNode(step4Node, { input: {}, previousOutputs });
+        expect(result.output).toEqual({
+            result: 'Step4: Step2: data2 & Step3: data3'
+        });
+    });
+});
+//# sourceMappingURL=decorator.test.js.map

package/dist/core/src/env/workflow/decorators/edge.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @Edge 和 @WorkflowEdges 装饰器
+ *
+ * 用于显式声明节点之间的边关系
+ */
+import 'reflect-metadata';
+import type { EdgeMetadata, EdgeOptions } from '../types/decorators-types';
+/**
+ * 声明一条边 (from -> to)
+ *
+ * 这是一个方法装饰器，用于在方法上声明边关系
+ *
+ * @param from - 起始节点 ID
+ * @param to - 目标节点 ID
+ *
+ * @example
+ * ```typescript
+ * @Edge('nodeA', 'nodeB')
+ * static __edge_nodeA_to_nodeB__ = null;
+ * ```
+ */
+export declare function Edge(from: string, to: string): MethodDecorator;
+/**
+ * 类级别装饰器，声明多条边
+ *
+ * @param edges - 边数组
+ *
+ * @example
+ * ```typescript
+ * @WorkflowEdges([
+ *   { from: 'A', to: 'B' },
+ *   { from: 'B', to: 'C' }
+ * ])
+ * @Workflow({ name: 'test' })
+ * class TestWorkflow { }
+ * ```
+ */
+export declare function WorkflowEdges(edges: EdgeOptions[]): ClassDecorator;
+/**
+ * 获取类上的所有边元数据
+ */
+export declare function getEdgeMetadatas(target: Function): EdgeMetadata[];
+//# sourceMappingURL=edge.d.ts.map

package/dist/core/src/env/workflow/decorators/edge.js

@@ -0,0 +1,68 @@
+/**
+ * @Edge 和 @WorkflowEdges 装饰器
+ *
+ * 用于显式声明节点之间的边关系
+ */
+import 'reflect-metadata';
+import { EDGE_METADATA_KEY } from "../metadata/keys.js";
+/**
+ * 声明一条边 (from -> to)
+ *
+ * 这是一个方法装饰器，用于在方法上声明边关系
+ *
+ * @param from - 起始节点 ID
+ * @param to - 目标节点 ID
+ *
+ * @example
+ * ```typescript
+ * @Edge('nodeA', 'nodeB')
+ * static __edge_nodeA_to_nodeB__ = null;
+ * ```
+ */
+export function Edge(from, to) {
+    return function (target, propertyKey, descriptor) {
+        const edge = { from, to };
+        // 获取已存在的边元数据列表
+        const existingEdges = Reflect.getMetadata(EDGE_METADATA_KEY, target) || [];
+        // 添加新边
+        existingEdges.push(edge);
+        // 存储元数据
+        Reflect.defineMetadata(EDGE_METADATA_KEY, existingEdges, target);
+        return descriptor;
+    };
+}
+/**
+ * 类级别装饰器，声明多条边
+ *
+ * @param edges - 边数组
+ *
+ * @example
+ * ```typescript
+ * @WorkflowEdges([
+ *   { from: 'A', to: 'B' },
+ *   { from: 'B', to: 'C' }
+ * ])
+ * @Workflow({ name: 'test' })
+ * class TestWorkflow { }
+ * ```
+ */
+export function WorkflowEdges(edges) {
+    return function (target) {
+        // 将 EdgeOptions[] 转换为 EdgeMetadata[]
+        const edgeMetadatas = edges.map(edge => ({
+            from: edge.from,
+            to: edge.to,
+            condition: edge.condition,
+        }));
+        // 存储元数据
+        Reflect.defineMetadata(EDGE_METADATA_KEY, edgeMetadatas, target);
+        return target;
+    };
+}
+/**
+ * 获取类上的所有边元数据
+ */
+export function getEdgeMetadatas(target) {
+    return Reflect.getMetadata(EDGE_METADATA_KEY, target) || [];
+}
+//# sourceMappingURL=edge.js.map

package/dist/core/src/env/workflow/decorators/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @fileoverview Workflow Decorators Index
+ *
+ * 导出所有装饰器相关的 API
+ */
+export { Workflow, getWorkflowMetadata } from './workflow';
+export { NodeAs, getNodeMetadatas } from './node-as';
+export { Edge, WorkflowEdges, getEdgeMetadatas } from './edge';
+export { DecoratorNode } from './decorator-node';
+export type { DecoratorNodeConfig } from './decorator-node';
+export { WorkflowConverter } from '../extractor/workflow-converter';
+export { createWorkflowFromClass } from '../utils/create-workflow';
+export type { WorkflowOptions, NodeAsOptions, EdgeOptions, WorkflowMetadata, NodeMetadata, EdgeMetadata, ValidationResult, ConvertedWorkflowDefinition, ConvertedNodeDefinition, } from '../types/decorators-types';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/src/env/workflow/decorators/index.js

@@ -0,0 +1,15 @@
+/**
+ * @fileoverview Workflow Decorators Index
+ *
+ * 导出所有装饰器相关的 API
+ */
+// Decorators
+export { Workflow, getWorkflowMetadata } from "./workflow.js";
+export { NodeAs, getNodeMetadatas } from "./node-as.js";
+export { Edge, WorkflowEdges, getEdgeMetadatas } from "./edge.js";
+// Node
+export { DecoratorNode } from "./decorator-node.js";
+// Converter (需要单独导入，避免循环依赖)
+export { WorkflowConverter } from "../extractor/workflow-converter.js";
+export { createWorkflowFromClass } from "../utils/create-workflow.js";
+//# sourceMappingURL=index.js.map

package/dist/core/src/env/workflow/decorators/node-as.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @NodeAs 装饰器
+ *
+ * 用于将类方法声明为 Workflow 的 Node
+ */
+import 'reflect-metadata';
+import type { NodeAsOptions, NodeMetadata } from '../types/decorators-types';
+/**
+ * 将方法声明为 Workflow 的 Node
+ *
+ * @param options - Node 配置选项
+ *
+ * @example
+ * ```typescript
+ * @Workflow({ name: 'my-workflow', entry: 'fetch' })
+ * class MyWorkflow {
+ *   @NodeAs({
+ *     nodeId: 'fetch',
+ *     nodeType: 'tool',
+ *     config: { tool: 'web_search' }
+ *   })
+ *   async fetch(input: { query: string }) {
+ *     return { data: [] };
+ *   }
+ *
+ *   @NodeAs({
+ *     nodeId: 'process',
+ *     dependsOn: 'fetch'
+ *   })
+ *   async process(input: { data: any }) {
+ *     return { result: {} };
+ *   }
+ * }
+ * ```
+ */
+export declare function NodeAs(options?: NodeAsOptions): MethodDecorator;
+/**
+ * 获取类上所有方法的 Node 元数据
+ */
+export declare function getNodeMetadatas(target: Object): NodeMetadata[];
+//# sourceMappingURL=node-as.d.ts.map