@xpert-ai/plugin-sdk 0.0.1 → 0.0.2

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@xpert-ai/plugin-sdk",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "license": "AGPL-3.0",
   "dependencies": {},
-  "main": "./index.cjs",
-  "module": "./index.js",
+  "main": "./index.cjs.js",
+  "module": "./index.esm.js",
   "publishConfig": {
     "access": "public"
   }

package/src/index.d.ts

@@ -0,0 +1,12 @@
+export * from './lib/plugin';
+export * from './lib/plugin.interface';
+export * from './lib/plugin-metadata';
+export * from './lib/types';
+export * from './lib/logger';
+export * from './lib/knowledge';
+export * from './lib/integration/index';
+export * from './lib/workflow/index';
+export * from './lib/vectorstore/index';
+export * from './lib/rag/index';
+export * from './lib/toolset/index';
+export * from './lib/core/index';

package/src/lib/core/file-system.d.ts

@@ -0,0 +1,42 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { FileSystemPermission } from './permissions';
+/**
+ * Restricted FileSystem based on granted permissions
+ */
+export declare class XpFileSystem {
+    private basePath;
+    private baseUrl;
+    private allowedOps;
+    private scope;
+    constructor(permission: FileSystemPermission, basePath: string, baseUrl: string);
+    /**
+     * Check if operation is allowed
+     */
+    private ensureAllowed;
+    /**
+     * Check if path is within scope
+     */
+    private ensureInScope;
+    fullPath(filePath: string): string;
+    /**
+     * Read file contents
+     */
+    readFile(filePath: string, encoding?: BufferEncoding): Promise<Buffer>;
+    /**
+     * Write file contents
+     */
+    writeFile(filePath: string, content: string | Buffer): Promise<string>;
+    /**
+     * Delete a file
+     */
+    deleteFile(filePath: string): Promise<void>;
+    /**
+     * List directory contents
+     */
+    listDir(dirPath: string): Promise<string[]>;
+    /**
+     * Utility: check if a file or directory exists
+     */
+    exists(targetPath: string): Promise<boolean>;
+}

package/src/lib/core/index.d.ts

@@ -0,0 +1,3 @@
+export * from './file-system';
+export * from './permissions';
+export * from './schema';

package/src/lib/core/permissions.d.ts

@@ -0,0 +1,74 @@
+/**
+ * ===============================
+ * Unified Permissions Definition
+ * ===============================
+ * Used by Agent / Plugin developers to declare required capabilities.
+ * Core system will check and inject allowed resources accordingly.
+ */
+/**
+ * Base Permission type
+ */
+export interface BasePermission {
+    type: string;
+    description?: string;
+}
+/**
+ * 1. LLM Permission
+ * Example: { type: 'llm', provider: 'openai', capability: 'vision' }
+ */
+export interface LLMPermission extends BasePermission {
+    type: 'llm';
+    provider?: string;
+    capability: 'text' | 'chat' | 'vision' | 'embedding';
+    scope?: string[];
+    maxTokens?: number;
+    rateLimit?: {
+        rps: number;
+    };
+}
+/**
+ * 2. Vector Store Permission
+ * Example: { type: 'vectorstore', provider: 'pinecone', operations: ['insert', 'query'] }
+ */
+export interface VectorStorePermission extends BasePermission {
+    type: 'vectorstore';
+    provider: string;
+    operations: Array<'insert' | 'query' | 'delete'>;
+    scope?: string[];
+}
+/**
+ * 3. Knowledge Base Permission
+ * Example: { type: 'knowledge', operations: ['read', 'write'], scope: ['kb_123'] }
+ */
+export interface KnowledgePermission extends BasePermission {
+    type: 'knowledge';
+    operations: Array<'read' | 'write' | 'update' | 'delete'>;
+    scope?: string[];
+}
+/**
+ * 4. File System Permission
+ * Example: { type: 'filesystem', operations: ['read', 'write'], scope: ['/documents', '/images'] }
+ */
+export interface FileSystemPermission extends BasePermission {
+    type: 'filesystem';
+    operations: Array<'read' | 'write' | 'delete' | 'list'>;
+    scope?: string[];
+}
+/**
+ * 5. Integration Permission
+ * Example: { type: 'integration', service: 'feishu', operations: ['read', 'write'] }
+ */
+export interface IntegrationPermission extends BasePermission {
+    type: 'integration';
+    service: string;
+    operations?: Array<'read' | 'write' | 'update' | 'delete'>;
+    scope?: string[];
+}
+/**
+ * Union type for all permissions
+ */
+export type Permission = LLMPermission | VectorStorePermission | KnowledgePermission | FileSystemPermission | IntegrationPermission;
+/**
+ * Permissions array type
+ */
+export type Permissions = Permission[];

package/src/lib/core/schema.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 通用 UI Schema 字段定义
+ */
+export interface ISchemaUIBase {
+    component: string;
+    label?: string;
+    description?: string;
+    placeholder?: string;
+    order?: number;
+    required?: boolean;
+    visibleWhen?: Record<string, any>;
+    enabledWhen?: Record<string, any>;
+}
+/**
+ * Secret 字段扩展
+ */
+export interface ISchemaSecretField extends ISchemaUIBase {
+    component: 'secretInput';
+    revealable?: boolean;
+    maskSymbol?: string;
+    persist?: boolean;
+}

package/src/lib/integration/index.d.ts

@@ -0,0 +1,3 @@
+export * from './strategy.decorator';
+export * from './strategy.interface';
+export * from './strategy.registry';

package/src/lib/integration/strategy.decorator.d.ts

@@ -0,0 +1,2 @@
+export declare const INTEGRATION_STRATEGY = "INTEGRATION_STRATEGY";
+export declare const IntegrationStrategyKey: (provider: string) => import("@nestjs/common").CustomDecorator<string>;

package/src/lib/integration/{strategy.interface.ts → strategy.interface.d.ts}

@@ -1,10 +1,8 @@
-import { IIntegration, TIntegrationProvider } from '@metad/contracts'
-
+import { IIntegration, TIntegrationProvider } from '@metad/contracts';
 export type TIntegrationStrategyParams = {
-  query: string
-}
-
+    query: string;
+};
 export interface IntegrationStrategy<T = unknown> {
-  meta: TIntegrationProvider
-  execute(integration: IIntegration<T>, payload: TIntegrationStrategyParams): Promise<any>
+    meta: TIntegrationProvider;
+    execute(integration: IIntegration<T>, payload: TIntegrationStrategyParams): Promise<any>;
 }

package/src/lib/integration/strategy.registry.d.ts

@@ -0,0 +1,6 @@
+import { DiscoveryService, Reflector } from '@nestjs/core';
+import { BaseStrategyRegistry } from '../strategy';
+import { IntegrationStrategy } from './strategy.interface';
+export declare class IntegrationStrategyRegistry extends BaseStrategyRegistry<IntegrationStrategy> {
+    constructor(discoveryService: DiscoveryService, reflector: Reflector);
+}

package/src/lib/knowledge/index.d.ts

@@ -0,0 +1,3 @@
+export * from './knowledge-strategy.decorator';
+export * from './knowledge-strategy.interface';
+export * from './knowledge-strategy.registry';

package/src/lib/knowledge/knowledge-strategy.decorator.d.ts

@@ -0,0 +1,2 @@
+export declare const KNOWLEDGE_STRATEGY = "KNOWLEDGE_STRATEGY";
+export declare const KnowledgeStrategyKey: (provider: string) => import("@nestjs/common").CustomDecorator<string>;

package/src/lib/knowledge/knowledge-strategy.interface.d.ts

@@ -0,0 +1,15 @@
+import { IIntegration } from '@metad/contracts';
+import { Document } from 'langchain/document';
+export type TKnowledgeStrategyParams = {
+    query: string;
+    k: number;
+    filter: Record<string, any>;
+    options: {
+        knowledgebaseId: string;
+    };
+};
+export interface KnowledgeStrategy {
+    execute(integration: IIntegration, payload: TKnowledgeStrategyParams): Promise<{
+        chunks: [Document, number][];
+    }>;
+}

package/src/lib/knowledge/knowledge-strategy.registry.d.ts

@@ -0,0 +1,12 @@
+import { KnowledgeProviderEnum } from '@metad/contracts';
+import { OnModuleInit } from '@nestjs/common';
+import { DiscoveryService, Reflector } from '@nestjs/core';
+import { KnowledgeStrategy } from './knowledge-strategy.interface';
+export declare class KnowledgeStrategyRegistry implements OnModuleInit {
+    private discoveryService;
+    private reflector;
+    private strategies;
+    constructor(discoveryService: DiscoveryService, reflector: Reflector);
+    onModuleInit(): void;
+    get(type: KnowledgeProviderEnum): KnowledgeStrategy;
+}

package/src/lib/logger.d.ts

@@ -0,0 +1,2 @@
+import type { PluginLogger } from './types';
+export declare function createPluginLogger(scope: string, baseMeta?: Record<string, any>): PluginLogger;

package/src/lib/plugin-metadata.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Metadata keys used in plugins for defining various aspects like entities, subscribers, and configurations.
+ */
+export declare const PLUGIN_METADATA: {
+    /**
+     * Key representing the entities registered within the plugin.
+     */
+    readonly ENTITIES: "entities";
+    /**
+     * Key representing event subscribers within the plugin.
+     */
+    readonly SUBSCRIBERS: "subscribers";
+};
+/**
+ * Type definition for valid plugin metadata keys.
+ */
+export type PluginMetadataKey = (typeof PLUGIN_METADATA)[keyof typeof PLUGIN_METADATA];

package/src/lib/plugin.d.ts

@@ -0,0 +1,8 @@
+import { PluginMetadata } from './plugin.interface';
+/**
+ * Decorator function for extending NestJS features with additional metadata.
+ *
+ * @param pluginMetadata Metadata to be applied to the target class.
+ * @returns Class decorator function.
+ */
+export declare function XpertServerPlugin(pluginMetadata: PluginMetadata): ClassDecorator;

package/src/lib/{plugin.hook.ts → plugin.hook.d.ts}

@@ -8,7 +8,6 @@ export interface IOnPluginBootstrap {
      */
     onPluginBootstrap(): void | Promise<void>;
 }
-
 /**
  * Interface for plugins with a destroy lifecycle method.
  */
@@ -19,7 +18,6 @@ export interface IOnPluginDestroy {
      */
     onPluginDestroy(): void | Promise<void>;
 }
-
 /**
  * Interface for plugins supporting basic seed operations.
  */
@@ -30,7 +28,6 @@ export interface IOnPluginWithBasicSeed {
      */
     onPluginBasicSeed(): void | Promise<void>;
 }
-
 /**
  * Interface for plugins supporting default seed operations.
  */
@@ -41,7 +38,6 @@ export interface IOnPluginWithDefaultSeed {
      */
     onPluginDefaultSeed(): void | Promise<void>;
 }
-
 /**
  * Interface for plugins supporting random seed operations.
  */

package/src/lib/plugin.interface.d.ts

@@ -0,0 +1,59 @@
+import { ModuleMetadata, Type } from '@nestjs/common';
+/**
+ * Metadata definition for a plugin in NestJS.
+ */
+export interface PluginMetadata extends ModuleMetadata {
+    /**
+     * List of entities injected by the plugin.
+     */
+    entities?: Array<Type<any>> | (() => Array<Type<any>>);
+    /**
+     * List of subscribers injected by the plugin.
+     */
+    subscribers?: Array<Type<any>> | (() => Array<Type<any>>);
+}
+/**
+ * Interface for plugins with a bootstrap lifecycle method.
+ */
+export interface IOnPluginBootstrap {
+    /**
+     * Called when the plugin is being initialized.
+     * @returns A void or a Promise representing the completion of the operation.
+     */
+    onPluginBootstrap(): void | Promise<void>;
+}
+/**
+ * Interface for plugins with a destroy lifecycle method.
+ */
+export interface IOnPluginDestroy {
+    /**
+     * Called when the plugin is being destroyed.
+     * @returns A void or a Promise representing the completion of the operation.
+     */
+    onPluginDestroy(): void | Promise<void>;
+}
+/**
+ * Interface for plugins supporting various seed operations.
+ */
+export interface IOnPluginSeedable {
+    /**
+     * Invoked when seeding basic plugin data.
+     * @returns A void or a Promise representing the completion of the operation.
+     */
+    onPluginBasicSeed?(): void | Promise<void>;
+    /**
+     * Invoked when seeding default plugin data.
+     * @returns A void or a Promise representing the completion of the operation.
+     */
+    onPluginDefaultSeed?(): void | Promise<void>;
+    /**
+     * Invoked when seeding random plugin data.
+     * @returns A void or a Promise representing the completion of the operation.
+     */
+    onPluginRandomSeed?(): void | Promise<void>;
+}
+/**
+ * Represents the combined lifecycle methods for a plugin.
+ * This type combines interfaces for initializing and destroying a plugin.
+ */
+export type PluginLifecycleMethods = IOnPluginBootstrap & IOnPluginDestroy & IOnPluginSeedable;

package/src/lib/rag/image/index.d.ts

@@ -0,0 +1,3 @@
+export * from './strategy.decorator';
+export * from './strategy.interface';
+export * from './strategy.registry';

package/src/lib/rag/image/strategy.decorator.d.ts

@@ -0,0 +1,5 @@
+export declare const IMAGE_UNDERSTANDING_STRATEGY = "IMAGE_UNDERSTANDING_STRATEGY";
+/**
+ * Decorator to mark a provider as an Image Understanding Strategy
+ */
+export declare const ImageUnderstandingStrategy: (provider: string) => import("@nestjs/common").CustomDecorator<string>;

package/src/lib/rag/image/strategy.interface.d.ts

@@ -0,0 +1,36 @@
+import { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import { IDocumentUnderstandingProvider } from '@metad/contracts';
+import { Document } from 'langchain/document';
+import { Permissions, XpFileSystem } from '../../core/index';
+import { ChunkMetadata, TDocumentAsset } from '../types';
+export type TImageUnderstandingConfig = {
+    stage: 'test' | 'prod';
+    visionModel: BaseChatModel;
+    permissions?: {
+        fileSystem?: XpFileSystem;
+    };
+};
+export type TImageUnderstandingInput = {
+    chunks: Document<ChunkMetadata>[];
+    files: TDocumentAsset[];
+};
+export type TImageUnderstandingResult = {
+    chunks: Document<Partial<ChunkMetadata>>[];
+    pages?: Document<Partial<ChunkMetadata>>[];
+    metadata: any;
+};
+export interface IImageUnderstandingStrategy<TConfig extends TImageUnderstandingConfig = TImageUnderstandingConfig> {
+    readonly permissions: Permissions;
+    /**
+     * Metadata about this strategy
+     */
+    readonly meta: IDocumentUnderstandingProvider;
+    /**
+     * Validate the configuration
+     */
+    validateConfig(config: TConfig): Promise<void>;
+    /**
+     * Understand image files (e.g., OCR, VLM, Chart Parsing)
+     */
+    understandImages(params: TImageUnderstandingInput, config: TConfig): Promise<TImageUnderstandingResult>;
+}

package/src/lib/rag/image/strategy.registry.d.ts

@@ -0,0 +1,6 @@
+import { DiscoveryService, Reflector } from '@nestjs/core';
+import { BaseStrategyRegistry } from '../../strategy';
+import { IImageUnderstandingStrategy, TImageUnderstandingConfig } from './strategy.interface';
+export declare class ImageUnderstandingRegistry<TConfig extends TImageUnderstandingConfig = TImageUnderstandingConfig> extends BaseStrategyRegistry<IImageUnderstandingStrategy<TConfig>> {
+    constructor(discoveryService: DiscoveryService, reflector: Reflector);
+}

package/src/lib/rag/index.d.ts

@@ -0,0 +1,6 @@
+export * from './textsplitter/index';
+export * from './source/index';
+export * from './transformer/index';
+export * from './retriever/index';
+export * from './types';
+export * from './image/index';

package/src/lib/rag/retriever/index.d.ts

@@ -0,0 +1,3 @@
+export * from './strategy.decorator';
+export * from './strategy.interface';
+export * from './strategy.registry';

package/src/lib/rag/retriever/strategy.decorator.d.ts

@@ -0,0 +1,5 @@
+export declare const RETRIEVER_STRATEGY = "RETRIEVER_STRATEGY";
+/**
+ * Decorator to mark a provider as a Retriever Strategy
+ */
+export declare const RetrieverStrategy: (provider: string) => import("@nestjs/common").CustomDecorator<string>;

package/src/lib/rag/retriever/strategy.interface.d.ts

@@ -0,0 +1,30 @@
+import { VectorStore } from '@langchain/core/vectorstores';
+import { I18nObject } from '@metad/contracts';
+import { Document } from 'langchain/document';
+export type TRetrieverConfig = {
+    vectorStore: VectorStore;
+};
+export interface IRetrieverStrategy<TConfig extends TRetrieverConfig = TRetrieverConfig> {
+    /**
+     * Metadata about this retriever
+     */
+    readonly meta: {
+        name: string;
+        label: I18nObject;
+        configSchema: any;
+        icon: {
+            svg?: string;
+            color?: string;
+        };
+    };
+    /**
+     * Validate the configuration
+     */
+    validateConfig(config: TConfig): Promise<void>;
+    /**
+     * Retrieve relevant documents for a given query
+     */
+    retrieve(query: string, options?: TConfig): Promise<{
+        documents: Document[];
+    }>;
+}

package/src/lib/rag/retriever/strategy.registry.d.ts

@@ -0,0 +1,6 @@
+import { DiscoveryService, Reflector } from '@nestjs/core';
+import { BaseStrategyRegistry } from '../../strategy';
+import { IRetrieverStrategy } from './strategy.interface';
+export declare class RetrieverRegistry extends BaseStrategyRegistry<IRetrieverStrategy> {
+    constructor(discoveryService: DiscoveryService, reflector: Reflector);
+}

package/src/lib/rag/source/index.d.ts

@@ -0,0 +1,3 @@
+export * from './strategy.decorator';
+export * from './strategy.interface';
+export * from './strategy.registry';

package/src/lib/rag/source/strategy.decorator.d.ts

@@ -0,0 +1,5 @@
+export declare const DOCUMENT_SOURCE_STRATEGY = "DOCUMENT_SOURCE_STRATEGY";
+/**
+ * Decorator to mark a provider as a Document Source Strategy
+ */
+export declare const DocumentSourceStrategy: (provider: string) => import("@nestjs/common").CustomDecorator<string>;

package/src/lib/rag/source/strategy.interface.d.ts

@@ -0,0 +1,26 @@
+import { IDocumentSourceProvider, IIntegration } from '@metad/contracts';
+import { Document } from 'langchain/document';
+import { Permissions } from '../../core';
+export interface IDocumentSourceStrategy<TConfig = any> {
+    readonly permissions: Permissions;
+    /**
+     * Metadata about this document source
+     */
+    readonly meta: IDocumentSourceProvider;
+    /**
+     * Validate the configuration
+     */
+    validateConfig(config: TConfig): Promise<void>;
+    /**
+     * Test the connection to the source
+     *
+     * @param config
+     */
+    test(config: TConfig): Promise<any>;
+    /**
+     * Load documents from the source
+     */
+    loadDocuments(config: TConfig, context?: {
+        integration?: IIntegration;
+    }): Promise<Document[]>;
+}

package/src/lib/rag/source/strategy.registry.d.ts

@@ -0,0 +1,6 @@
+import { DiscoveryService, Reflector } from '@nestjs/core';
+import { BaseStrategyRegistry } from '../../strategy';
+import { IDocumentSourceStrategy } from './strategy.interface';
+export declare class DocumentSourceRegistry<TConfig = any> extends BaseStrategyRegistry<IDocumentSourceStrategy<TConfig>> {
+    constructor(discoveryService: DiscoveryService, reflector: Reflector);
+}

package/src/lib/rag/textsplitter/index.d.ts

@@ -0,0 +1,3 @@
+export * from './strategy.decorator';
+export * from './strategy.interface';
+export * from './strategy.registry';

package/src/lib/rag/textsplitter/strategy.decorator.d.ts

@@ -0,0 +1,2 @@
+export declare const TEXT_SPLITTER_STRATEGY = "TEXT_SPLITTER_STRATEGY";
+export declare const TextSplitterStrategy: (provider: string) => import("@nestjs/common").CustomDecorator<string>;

package/src/lib/rag/textsplitter/strategy.interface.d.ts

@@ -0,0 +1,24 @@
+import { IDocumentChunkerProvider, KnowledgeStructureEnum } from '@metad/contracts';
+import { Document } from 'langchain/document';
+import { ChunkMetadata } from '../types';
+/**
+ * Split text content into chunks for embedding and retrieval
+ */
+export interface ITextSplitterStrategy<TConfig = any> {
+    /**
+     * Metadata about this splitter
+     */
+    readonly meta: IDocumentChunkerProvider;
+    readonly structure: KnowledgeStructureEnum;
+    /**
+     * Validate the configuration
+     */
+    validateConfig(config: TConfig): Promise<void>;
+    /**
+     * Split a text into chunks and pages (if applicable)
+     */
+    splitDocuments(documents: Document[], options?: TConfig): Promise<{
+        chunks: Document<ChunkMetadata>[];
+        pages?: Document<ChunkMetadata>[];
+    }>;
+}

package/src/lib/rag/textsplitter/strategy.registry.d.ts

@@ -0,0 +1,6 @@
+import { DiscoveryService, Reflector } from '@nestjs/core';
+import { BaseStrategyRegistry } from '../../strategy';
+import { ITextSplitterStrategy } from './strategy.interface';
+export declare class TextSplitterRegistry<TConfig = any> extends BaseStrategyRegistry<ITextSplitterStrategy<TConfig>> {
+    constructor(discoveryService: DiscoveryService, reflector: Reflector);
+}

package/src/lib/rag/transformer/index.d.ts

@@ -0,0 +1,3 @@
+export * from './strategy.decorator';
+export * from './strategy.interface';
+export * from './strategy.registry';

package/src/lib/rag/transformer/strategy.decorator.d.ts

@@ -0,0 +1,5 @@
+export declare const DOCUMENT_TRANSFORMER_STRATEGY = "DOCUMENT_TRANSFORMER_STRATEGY";
+/**
+ * Decorator to mark a provider as a Document Transformer Strategy
+ */
+export declare const DocumentTransformerStrategy: (provider: string) => import("@nestjs/common").CustomDecorator<string>;

package/src/lib/rag/transformer/strategy.interface.d.ts

@@ -0,0 +1,40 @@
+import { DocumentInterface } from '@langchain/core/documents';
+import { _TFile, IDocumentProcessorProvider, IIntegration } from '@metad/contracts';
+import { Permissions, XpFileSystem } from '../../core/index';
+import { ChunkMetadata, TDocumentAsset } from '../types';
+export type TDocumentTransformerConfig = {
+    stage: 'test' | 'prod';
+    tempDir?: string;
+    permissions?: {
+        fileSystem?: XpFileSystem;
+        integration?: IIntegration;
+    };
+};
+export type TDocumentTransformerFile = _TFile & {
+    id?: string;
+    filename: string;
+    extension: string | undefined;
+};
+export type TDocumentTransformerInput = TDocumentTransformerFile[] | string | string[];
+export type TDocumentTransformerResult = {
+    id?: string;
+    chunks: DocumentInterface<ChunkMetadata>[];
+    metadata: {
+        assets?: TDocumentAsset[];
+    };
+};
+export interface IDocumentTransformerStrategy<TConfig extends TDocumentTransformerConfig = TDocumentTransformerConfig> {
+    /**
+     * Metadata about this transformer
+     */
+    readonly meta: IDocumentProcessorProvider;
+    readonly permissions: Permissions;
+    /**
+     * Validate the configuration
+     */
+    validateConfig(config: TConfig): Promise<void>;
+    /**
+     * Transform documents (e.g., extract, OCR, normalize, enrich metadata)
+     */
+    transformDocuments(files: TDocumentTransformerInput, config: TConfig): Promise<TDocumentTransformerResult[]>;
+}

package/src/lib/rag/transformer/strategy.registry.d.ts

@@ -0,0 +1,6 @@
+import { DiscoveryService, Reflector } from '@nestjs/core';
+import { BaseStrategyRegistry } from '../../strategy';
+import { IDocumentTransformerStrategy, TDocumentTransformerConfig } from './strategy.interface';
+export declare class DocumentTransformerRegistry<TConfig extends TDocumentTransformerConfig = TDocumentTransformerConfig> extends BaseStrategyRegistry<IDocumentTransformerStrategy<TConfig>> {
+    constructor(discoveryService: DiscoveryService, reflector: Reflector);
+}