@xpert-ai/plugin-sdk 3.6.0 → 3.6.1

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,31 @@
+import { DocumentInterface } from '@langchain/core/documents';
+import { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import { IDocumentUnderstandingProvider, IKnowledgeDocument } from '@metad/contracts';
+import { Permissions, XpFileSystem } from '../../core/index';
+import { ChunkMetadata } from '../types';
+export type TImageUnderstandingConfig = {
+    stage: 'test' | 'prod';
+    visionModel: BaseChatModel;
+    permissions?: {
+        fileSystem?: XpFileSystem;
+    };
+};
+export type TImageUnderstandingResult = {
+    chunks: DocumentInterface<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(doc: IKnowledgeDocument<ChunkMetadata>, 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,7 @@
+export * from './textsplitter/index';
+export * from './source/index';
+export * from './transformer/index';
+export * from './retriever/index';
+export * from './types';
+export * from './image/index';
+export * from './knowledge/index';

package/src/lib/rag/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/rag/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/rag/knowledge/knowledge-strategy.interface.d.ts

@@ -0,0 +1,15 @@
+import { IIntegration } from '@metad/contracts';
+import { Document } from '@langchain/core/documents';
+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/rag/knowledge/knowledge-strategy.registry.d.ts

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

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/core/documents';
+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,36 @@
+import { IDocumentSourceProvider, IIntegration } from '@metad/contracts';
+import { Document } from '@langchain/core/documents';
+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[]>;
+    /**
+     * Load a single document by its ID
+     *
+     * @deprecated Planning
+     * @param documentId
+     * @param context
+     */
+    loadDocument?(document: Document, 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,23 @@
+import { IDocumentChunkerProvider, KnowledgeStructureEnum } from '@metad/contracts';
+import { DocumentInterface } from '@langchain/core/documents';
+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: DocumentInterface[], options?: TConfig): Promise<{
+        chunks: DocumentInterface<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,26 @@
+import { IDocumentProcessorProvider, IIntegration, IKnowledgeDocument } from '@metad/contracts';
+import { Permissions, XpFileSystem } from '../../core/index';
+import { ChunkMetadata } from '../types';
+export type TDocumentTransformerConfig = {
+    stage: 'test' | 'prod';
+    tempDir?: string;
+    permissions?: {
+        fileSystem?: XpFileSystem;
+        integration?: IIntegration;
+    };
+};
+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: Partial<IKnowledgeDocument>[], config: TConfig): Promise<Partial<IKnowledgeDocument<ChunkMetadata>>[]>;
+}

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);
+}

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

@@ -0,0 +1,18 @@
+import { DocumentInterface } from '@langchain/core/documents';
+import { IDocChunkMetadata } from '@metad/contracts';
+export { TDocumentAsset } from '@metad/contracts';
+export interface ChunkMetadata extends IDocChunkMetadata {
+    startOffset?: number;
+    endOffset?: number;
+    type?: 'parent' | 'child';
+    [key: string]: any;
+}
+/**
+ * Merge parent chunks with their child chunks based on metadata (parentId and chunkId)
+ *
+ * @deprecated use buildChunkTreeAndFindLeaves instead
+ */
+export declare function mergeParentChildChunks(chunks: DocumentInterface<ChunkMetadata>[], // Parent chunks
+children: DocumentInterface<ChunkMetadata>[]): DocumentInterface<ChunkMetadata>[];
+export declare function isRemoteFile(path: string): boolean;
+export declare function downloadRemoteFile(url: string, dest: string): Promise<string>;

package/src/lib/strategy.d.ts

@@ -0,0 +1,12 @@
+import { OnModuleInit } from "@nestjs/common";
+import { DiscoveryService, Reflector } from "@nestjs/core";
+export declare class BaseStrategyRegistry<S> implements OnModuleInit {
+    protected readonly strategyKey: string;
+    protected discoveryService: DiscoveryService;
+    protected reflector: Reflector;
+    protected strategies: Map<string, S>;
+    constructor(strategyKey: string, discoveryService: DiscoveryService, reflector: Reflector);
+    onModuleInit(): void;
+    get(type: string): S;
+    list(): S[];
+}

package/src/lib/toolset/builtin.d.ts

@@ -0,0 +1,54 @@
+import { StructuredToolInterface } from '@langchain/core/tools';
+import { BaseStore } from '@langchain/langgraph';
+import { I18nObject, IXpertToolset, ToolProviderCredentials, TToolCredentials, TToolsetParams, XpertToolsetCategoryEnum } from '@metad/contracts';
+import { Logger } from '@nestjs/common';
+import { CommandBus, QueryBus } from '@nestjs/cqrs';
+import { BaseToolset } from './toolset';
+/**
+ * The context params of creating toolset
+ */
+export type TBuiltinToolsetParams = TToolsetParams & {
+    commandBus: CommandBus;
+    queryBus: QueryBus;
+    store?: BaseStore;
+};
+export interface IBuiltinToolset {
+    validateCredentials(credentials: TToolCredentials): Promise<void>;
+}
+export declare abstract class BuiltinToolset<T extends StructuredToolInterface = StructuredToolInterface, C = TToolCredentials> extends BaseToolset<T> implements IBuiltinToolset {
+    providerName: string;
+    protected toolset?: IXpertToolset;
+    protected params?: TBuiltinToolsetParams;
+    static provider: string;
+    protected logger: Logger;
+    providerType: XpertToolsetCategoryEnum.BUILTIN;
+    credentialsSchema?: {
+        [key: string]: ToolProviderCredentials;
+    };
+    get tenantId(): string;
+    get organizationId(): string;
+    get commandBus(): CommandBus<import("@nestjs/cqrs").ICommand>;
+    get queryBus(): QueryBus<import("@nestjs/cqrs").IQuery>;
+    get xpertId(): string;
+    constructor(providerName: string, toolset?: IXpertToolset, params?: TBuiltinToolsetParams);
+    validateCredentials(credentials: C): Promise<void>;
+    _validateCredentials(credentials: C): Promise<void>;
+    getId(): string;
+    getCredentials(): C;
+    getToolTitle(name: string): string | I18nObject;
+    /**
+     * Get credentials schema
+     *
+     * @returns Credentials schema
+     */
+    getCredentialsSchema(): {
+        [key: string]: ToolProviderCredentials;
+    };
+    /**
+     * Get toolset entity
+     *
+     * @returns XpertToolset
+     */
+    getToolset(): IXpertToolset;
+    getName(): string;
+}

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

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

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

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

package/src/lib/toolset/strategy.interface.d.ts

@@ -0,0 +1,28 @@
+import { DynamicStructuredTool } from '@langchain/core/tools';
+import { I18nObject } from '@metad/contracts';
+import { ZodSchema } from 'zod';
+import { BuiltinToolset } from './builtin';
+export interface IToolsetStrategy<TConfig = any> {
+    /**
+     * Metadata about this toolset
+     */
+    readonly meta: {
+        author: string;
+        tags: string[];
+        name: string;
+        label: I18nObject;
+        description?: I18nObject;
+        configSchema: any;
+        icon?: {
+            svg?: string;
+            png?: string;
+            color?: string;
+        };
+    };
+    /**
+     * Validate the configuration
+     */
+    validateConfig(config: TConfig): Promise<void>;
+    create(config: TConfig): Promise<BuiltinToolset>;
+    createTools(): DynamicStructuredTool<ZodSchema>[];
+}

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

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

package/src/lib/toolset/toolset.d.ts

@@ -0,0 +1,53 @@
+import { BaseToolkit, StructuredTool, StructuredToolInterface } from "@langchain/core/tools";
+import { I18nObject, TStateVariable, TToolsetParams } from "@metad/contracts";
+import { z } from 'zod';
+type ZodObjectAny = z.ZodObject<any, any, any, any>;
+/**
+ * Base ability for all toolsets
+ */
+export declare abstract class BaseToolset<T extends StructuredToolInterface = StructuredToolInterface> extends BaseToolkit {
+    protected params?: TToolsetParams;
+    abstract providerName: string;
+    tools: T[];
+    stateVariables: TStateVariable[];
+    constructor(params?: TToolsetParams);
+    /**
+     * Async init tools
+     *
+     * @returns
+     */
+    initTools(): Promise<T[]>;
+    /**
+     * Get ID of the toolset
+     */
+    abstract getId(): string;
+    /**
+     * Get name of the toolset
+     */
+    abstract getName(): string;
+    /**
+     * Get one tool
+     *
+     * @param toolName
+     * @returns
+     */
+    getTool(toolName: string): StructuredToolInterface<import("@langchain/core/tools").ToolSchemaBase, any, any>;
+    /**
+     * Get state variables config
+     *
+     * @returns State variables
+     */
+    getVariables(): Promise<TStateVariable[]>;
+    /**
+     * Get title of tool
+     */
+    abstract getToolTitle(name: string): string | I18nObject;
+    /**
+     * Close all (connections).
+     */
+    close(): Promise<void>;
+}
+export declare abstract class BaseTool<T extends ZodObjectAny = ZodObjectAny> extends StructuredTool<T> {
+    schema: any;
+}
+export {};

package/src/lib/types.d.ts

@@ -0,0 +1,47 @@
+import { PluginMeta } from '@metad/contracts';
+import type { DynamicModule, INestApplicationContext } from '@nestjs/common';
+import type { ZodSchema } from 'zod';
+export interface PluginLifecycle {
+    /** Called after module registration but before application startup */
+    onInit?(ctx: PluginContext): Promise<void> | void;
+    /** Called after application startup (can start serving externally) */
+    onStart?(ctx: PluginContext): Promise<void> | void;
+    /** Called during graceful shutdown */
+    onStop?(ctx: PluginContext): Promise<void> | void;
+}
+export interface PluginHealth {
+    /** Returns health status and optional dependency check details */
+    checkHealth?(ctx: PluginContext): Promise<{
+        status: 'up' | 'down';
+        details?: any;
+    }> | {
+        status: 'up' | 'down';
+        details?: any;
+    };
+}
+export interface PluginConfigSpec<T extends object = any> {
+    /** Zod validation schema for plugin-level config (optional) */
+    schema?: ZodSchema<T>;
+    /** Default configuration */
+    defaults?: Partial<T>;
+}
+export interface XpertPlugin<TConfig extends object = any> extends PluginLifecycle, PluginHealth {
+    meta: PluginMeta;
+    config?: PluginConfigSpec<TConfig>;
+    /** Returns the DynamicModule to be mounted to the main application (can be set as global) */
+    register(ctx: PluginContext<TConfig>): DynamicModule;
+}
+export interface PluginContext<TConfig extends object = any> {
+    app: INestApplicationContext;
+    logger: PluginLogger;
+    config: TConfig;
+    /** Helper method to access other Providers in the container */
+    resolve<TInput = any, TResult = TInput>(token: any): TResult;
+}
+export interface PluginLogger {
+    child(meta: Record<string, any>): PluginLogger;
+    debug(msg: string, meta?: any): void;
+    log(msg: string, meta?: any): void;
+    warn(msg: string, meta?: any): void;
+    error(msg: string, meta?: any): void;
+}

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

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

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

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