@quan-erp/shared-backend-core 1.0.1

package/dist/types/0d45f5fd/262b0493.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Property decorator that injects the core `MigrationService` into the decorated property.
+ *
+ * This provides services or controllers with the ability to programmatically check,
+ * run, or rollback database migrations within the Quan ERP environment.
+ *
+ * @example
+ * ```ts
+ * @Service()
+ * class MyService {
+ *   @InjectMigrationManager()
+ *   private migrationManager: MigrationService;
+ *
+ *   async upgrade() {
+ *     await this.migrationManager.runMigrations('my-plugin', '1.0.0', [InitMigration]);
+ *   }
+ * }
+ * ```
+ */
+export declare function InjectMigrationManager(): (target: any, propertyKey: string | symbol) => void;
+export declare function getMigrationConfig(target: any, propertyKey: string | symbol): any;

package/dist/types/0d45f5fd/2881a088.d.ts

@@ -0,0 +1,26 @@
+import { Manager, RegistryValue } from "./d453df06.js";
+type ExposeOptions = {
+    serviceTagName: string;
+    version: string;
+};
+export declare function Expose(serviceTagName: string, version: string): (target: any) => void;
+export declare function getExposeConfig(target: any): ExposeOptions | undefined;
+type InjectOptions = {
+    class: any;
+    plugin: string;
+    name: string;
+};
+export declare function InjectExposeApi(cls: any, plugin?: string, name?: string): PropertyDecorator;
+export declare function getInjectExpose(target: any, propertyKey: string | symbol): InjectOptions | undefined;
+type ExposeAPIRegistryValue = {
+    serviceTagName: string;
+    version: string;
+};
+export declare class ExposeAPIManager extends Manager<any, ExposeAPIRegistryValue> {
+    static readonly DEFAULT_NAME: "default";
+    register(value: ExposeAPIRegistryValue, metadata?: (Partial<RegistryValue<ExposeAPIRegistryValue>> & Record<string, any>) | null, plugin?: string, name?: string): void;
+    registerFromClass(cls: any, instance: any, serviceTagName: string, version: string, plugin?: string, name?: string): void;
+    findByClass(cls: any, plugin: string): any;
+    protected getClassUniqueName(cls: any, length?: number): any;
+}
+export {};

package/dist/types/0d45f5fd/496c2854.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Manager responsible for tracking active background jobs and tasks.
+ *
+ * This manager provides a coordination point for the application to ensure that
+ * long-running operations (like plugin installations, database migrations, or
+ * heavy background tasks) are completed before the server process is shut down.
+ */
+export declare class GracefulJobManager {
+    private counter;
+    count(): void;
+    unCount(): void;
+    isSafeShutdown(pad?: number): boolean;
+    getRemaining(): number;
+}

package/dist/types/0d45f5fd/4b41f653.d.ts

@@ -0,0 +1,15 @@
+export interface TokenUserInfo {
+    id: number;
+    name: string;
+    role: {
+        id: number;
+        name: string;
+    };
+    username: string;
+    roleId: number;
+}
+export interface RequestedUser {
+    valid: boolean;
+    payload: TokenUserInfo;
+    error?: any;
+}

package/dist/types/0d45f5fd/4ced2577.d.ts

@@ -0,0 +1,28 @@
+import { HttpMethod } from "./1c59aca9.js";
+import { OpenAI as OpenAIClient } from 'openai';
+export type AIToolOption = {
+    requiredApiPermission: {
+        method: HttpMethod;
+        url: string;
+    }[];
+    argParser?: (args: any) => any;
+    toolDetail: OpenAIClient.Chat.Completions.ChatCompletionFunctionTool;
+};
+export type AIToolMetadata = AIToolOption & {
+    methodName: string;
+};
+/**
+ * Decorator to register a method as an AI tool.
+ *
+ * @description
+ * This decorator internally uses `@OnInit()` to register the tool function.
+ * Consequently, all AI tools will be registered only after the containing `@Module()` or modules class specified in the `module: []` property have been fully initialized.
+ *
+ * @param option - Configuration options for the AI tool, including required API permissions and tool details.
+ * @returns A method decorator that stores AI tool metadata on the class constructor.
+ */
+export declare function AITool(option: AIToolOption): MethodDecorator;
+/**
+ * Retrieves AI tool configurations for a given target (instance or constructor).
+ */
+export declare function getAIToolConfig(target: any): AIToolMetadata[];

package/dist/types/0d45f5fd/4db5cc33.d.ts

@@ -0,0 +1,165 @@
+import "reflect-metadata";
+import express, { Express } from 'express';
+import type { IAppInstance } from '@quan-erp/shared-types';
+import { DataSourceManager } from "./78464d38.js";
+import { CacheManager } from "./9a2c73cf.js";
+import { RouteManager } from "./1c59aca9.js";
+import { WebsocketManager } from "./a1a2ec11.js";
+import { ContainerRegistryManager } from "./885b723d.js";
+import { LoggerManager } from "./4dd6b41d.js";
+import { LifeCycleManager } from "./8e161648.js";
+import { PluginEnvConfigManager } from "./b528e7a2.js";
+import { PluginConfigOption } from "./b5020a96.js";
+import { ExposeAPIManager } from "./2881a088.js";
+import { AppEventCallback, AppEvents, CoreApp } from "./d9b4a449.js";
+import { GlobalMiddlewareManager, IMiddleware, MiddlewarePosition } from "./6559a8c1.js";
+import { AnalyticsManager } from "./a45e63d6.js";
+import { PluginManager } from "./ed08a5cd.js";
+import { GracefulJobManager } from "./496c2854.js";
+import { PluginServiceEventManager } from "./60dffdb5.js";
+import { WorkflowNodeManager } from "./da7f739f/fb5fafa3.js";
+export declare function GetAppInstance(): IAppInstance | null;
+export declare class App implements CoreApp {
+    private readonly pluginManager;
+    private readonly registryManager;
+    private readonly pluginExposeAPIManager;
+    private readonly datasourceManager;
+    private readonly cacheManager;
+    private readonly queueManager;
+    private readonly websocketManager;
+    private readonly routeManager;
+    private readonly loggerManager;
+    private readonly configManager;
+    private readonly workflowManager;
+    private readonly pluginEnvConfigManager;
+    private readonly lifecycleManager;
+    private readonly globalMiddlewareManager;
+    private readonly appEventHandler;
+    private readonly analyticsManager;
+    private readonly gracefuljobManager;
+    private readonly pluginServiceEventManager;
+    private readonly appId;
+    private pluginConfig;
+    private expressApp?;
+    private readonly appRouter;
+    private readonly readiness;
+    private readonly appVersion;
+    private readonly availablePluginSecretKey;
+    set express(value: Express);
+    get express(): Express | undefined;
+    on(event: AppEvents, callback: AppEventCallback): void;
+    off(event: AppEvents): void;
+    /**
+     * Bootstraps and starts the Quan ERP application.
+     *
+     * This is the main entry point that orchestrates the entire application lifecycle.
+     * It performs the following orchestration in sequence:
+     * 1.  **Kernel Initialization**: Sets up Express, the core Logger, and the global container.
+     * 2.  **Security & Basics**: Applies CORS, body parsing, and session-level middlewares.
+     * 3.  **Real-time Layer**: Configures the HTTP server to handle Websocket upgrades.
+     * 4.  **Global Pipeline**: Sets up readiness gates and global request/exception middlewares.
+     * 5.  **Infrastructure Bootstrap**: Initializes the built-in database (PostgreSQL) and loads Environment configs.
+     * 6.  **Module Loading**: Processes `builtinModules`, the `rootServerClass`, and custom `modules`.
+     * 7.  **Plugin Engine**: Configures local plugin storage and provides endpoints for plugin asset serving.
+     * 8.  **Workflow Engine**: Initializes the workflow runner and loads flows from the filesystem.
+     * 9.  **Migrations**: Executes system-level migrations for built-in services.
+     * 10. **Lifecycle Phase I**: Executes all `OnInit` hooks across all loaded modules.
+     * 11. **Plugin Restoration**: Dynamically re-installs all plugins previously marked as installed in the DB.
+     * 12. **Lifecycle Phase II**: Executes `OnAllModuleLoaded` hooks.
+     * 13. **Networking**: Starts the HTTP listener and triggers `OnHttpServerStartListening`.
+     *
+     * @param rootServerClass - The main class decorated with `@Server` defining the app configuration.
+     * @returns A promise resolving to the fully initialized `App` instance.
+     * @throws Error if the server is already running or if critical configuration is missing.
+     */
+    static run(rootServerClass: any): Promise<App>;
+    /**
+     * Dynamically installs and initializes a plugin into the running application.
+     *
+     * This complex orchestration includes:
+     * 1.  **Network Resolution**: Optionally downloads and unzips plugin packages.
+     * 2.  **Dependency Validation**: Verifies base kernel version and required plugin dependencies.
+     * 3.  **Import Rewriting**: Dynamically patches JS `import` statements to resolve `@quan-erp-plugins/` aliases.
+     * 4.  **Database Integration**: Executes plugin migrations and reloads all data sources.
+     * 5.  **Module Resolution**: Processes the plugin's root module via the dependency injector.
+     * 6.  **Lifecycle Management**: Triggers `onInstall`, `onReady`, and scoped `OnInit` hooks.
+     * 7.  **Atomic Rollback**: Automatically cleans up files and rolls back DB migrations on failure.
+     *
+     * @param pluginName - Unique identifier for the plugin.
+     * @param version - Version string (e.g., '1.0.0').
+     * @param options - Configuration for network downloads, lifecycle triggers, and migration behavior.
+     * @throws Error if dependencies are missing, versions are incompatible, or instantiation fails.
+     */
+    installPlugin(pluginName: string, version: string, options?: {
+        network?: boolean;
+        callReadyLifeCycle?: boolean;
+        ignoreAppReadiness?: boolean;
+        ignoreMigrations?: boolean;
+    }): Promise<void>;
+    /**
+     * Uninstalls a plugin and systematically cleans up all associated resources.
+     *
+     * The uninstallation process ensures system integrity by:
+     * 1.  **Dependency Guard**: Preventing the removal of plugins that others depend on.
+     * 2.  **Lifecycle Termination**: Executing `OnUninstall` and `OnShutdown` hooks.
+     * 3.  **Registry Cleanup**: Removing all instances and definitions from the DI container.
+     * 4.  **Networking & API**: Deregistering Express routes and Websocket servers.
+     * 5.  **Database Decoupling**: Removing entities, closing data sources, and reloading the ORM state.
+     * 6.  **Subsystem Purge**: Clearing associated caches, queues, workflows, and middlewares.
+     * 7.  **Storage Cleanup**: Physically deleting the plugin's code and assets from disk.
+     *
+     * @param pluginName - Unique identifier for the plugin to uninstall.
+     * @throws Error if the plugin is a system plugin or if other plugins rely on it.
+     */
+    uninstallPlugin(pluginName: string): Promise<void>;
+    private startHealthCheckConfig;
+    private isAllReady;
+    private isAllHealthy;
+    private isAllWorkingProperly;
+    getRegistryManager(): ContainerRegistryManager;
+    getExportRegistryManager(): ExposeAPIManager;
+    getRouteManager(): RouteManager;
+    getDataSourceManager(): DataSourceManager;
+    getCacheManager(): CacheManager;
+    getExpressApp(): Express;
+    getLifecycleManager(): LifeCycleManager;
+    getPluginEnvConfigManager(): PluginEnvConfigManager;
+    getLoggerManager(): LoggerManager;
+    getGlobalMiddlewareManager(): GlobalMiddlewareManager;
+    getWebsocketManager(): WebsocketManager;
+    getAppInstance(): IAppInstance;
+    getAnalyticsManager(): AnalyticsManager;
+    getPluginServiceEventManager(): PluginServiceEventManager;
+    getWorkflowManager(): WorkflowNodeManager;
+    getAppRouter(): express.Router;
+    getVersion(): string;
+    getAppId(): string;
+    getPluginManager(): PluginManager;
+    get<T>(cls: new (...args: any[]) => T, plugin?: string, name?: string): T | undefined;
+    /**
+     * Registers a global middleware filter into the application's processing pipeline.
+     *
+     * @param middleware - The middleware class (implementing `IMiddleware`) to instantiate.
+     * @param pluginName - The name of the plugin registering this filter.
+     * @param position - The relative position in the middleware stack (default: AFTER_ROOT_ROUTE).
+     */
+    addGlobalFilter(middleware: new () => IMiddleware, pluginName: string, position?: MiddlewarePosition): void;
+    /**
+     * Registers a global exception filter to handle errors during the request lifecycle.
+     *
+     * @param middleware - The exception filter class (implementing `IMiddleware`) to instantiate.
+     * @param pluginName - The name of the plugin registering this filter.
+     */
+    addGlobalExceptionFilter(middleware: new () => IMiddleware, pluginName: string): void;
+    /**
+     * @returns The manager responsible for tracking long-running background jobs
+     *          to ensure graceful server shutdown.
+     */
+    getGracefulJobManager(): GracefulJobManager;
+    getPluginConfig(): PluginConfigOption | undefined;
+    /**
+     * Logs comprehensive debug information for all kernel subsystems.
+     * The output is controlled by the `DEBUG_LOG` environment variable (comma-separated).
+     */
+    logDebugInfo(): void;
+}

package/dist/types/0d45f5fd/4dd6b41d.d.ts

@@ -0,0 +1,80 @@
+import 'reflect-metadata';
+import { BuiltinLogger } from "../abe2c417/7e2c18ef.js";
+import { Manager, RegistryValue } from "./d453df06.js";
+/**
+ * Standard interface for all logging implementations in the Quan ERP kernel.
+ *
+ * Each method accepts a `message` (data to log) and an optional `instance`
+ * to provide context (e.g., the class or object where the log was triggered).
+ */
+export interface Loggable {
+    /** Logs general operational information. */
+    log(message: any, instance?: any): void;
+    /** Logs technical errors, typically followed by stack traces. */
+    error(message: any, instance?: any): void;
+    /** Logs potentially harmful situations or deprecation warnings. */
+    warn(message: any, instance?: any): void;
+    /** Logs verbose information useful for debugging. */
+    debug(message: any, instance?: any): void;
+    /** Logs high-level informational messages. */
+    info(message: any, instance?: any): void;
+    /** Logs highly detailed flow information (e.g., DB queries). */
+    trace(message: any, instance?: any): void;
+    /** Logs critical errors that may cause application failure. */
+    fatal(message: any, instance?: any): void;
+}
+/**
+ * @function Logger
+ *
+ * Class decorator to attach logging capabilities to a class.
+ * Allows specifying one or more logger implementations that
+ * will be associated with the class via metadata.
+ *
+ * Metadata is stored under the `LOGGER_CLASS_KEY` symbol.
+ *
+ * @param LoggerClass - Constructor of a class implementing `Loggable`.
+ *                       Defaults to `DefaultLogger`.
+ * @param name        - Optional name to identify the logger instance.
+ *
+ * Usage Example:
+ * ```ts
+ * @Logger(MyCustomLogger, "custom")
+ * class MyService {
+ *   doSomething() {
+ *     // MyCustomLogger will be available for logging this class
+ *   }
+ * }
+ * ```
+ *
+ * Multiple loggers can be added by calling the decorator multiple times
+ * or by attaching multiple logger classes with different names.
+ */
+export declare function Logger(LoggerClass?: new () => Loggable, name?: string): ClassDecorator;
+export declare function getLoggerConfig(target: any): {
+    name?: string;
+    cls: (new () => Loggable);
+}[];
+type InjectLoggerOptions = {
+    cls: string;
+};
+/**
+ * Property decorator to inject a logger instance into a class property.
+ *
+ * @param cls - The logger class constructor to inject. Usually a class that implements the `Loggable` interface.
+ *
+ * @returns PropertyDecorator - Applies metadata to the property for dependency injection.
+ */
+export declare function InjectLogger(cls: new () => any): PropertyDecorator;
+export declare function getInjectLogger(target: any, propertyKey: string | symbol): InjectLoggerOptions | undefined;
+export declare function getDefaultLogger(): BuiltinLogger;
+export declare class LoggerManager extends Manager<Loggable> {
+    constructor();
+    static get default(): BuiltinLogger;
+    getDefaultLogger(): Loggable | undefined;
+    register(instance: Loggable, metadata?: (Partial<{}> & Record<string, any>) | null, plugin?: string, name?: string): void;
+    registerFromClass(cls: any, instance: any, plugin?: string, name?: string): void;
+    findByClass(cls: any, plugin?: string): RegistryValue<Loggable> | undefined;
+    protected getClassUniqueName(cls: any, length?: number): any;
+    logDebugInfo(): void;
+}
+export {};

package/dist/types/0d45f5fd/5c6ee442.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Constant used to identify metadata properties set by Quan ERP decorators.
+ *
+ * This string serves as a unique key for storing and retrieving metadata
+ * (such as controller routes, service names, or plugin configurations)
+ * on class prototypes and properties via the Reflect API.
+ */
+export declare const ANNOTATION_NAME: string;
+/**
+ * Default URL route prefix for accessing installed plugins.
+ *
+ * When a plugin is loaded, its public assets (like frontend code) are typically
+ * served under this path, allowing the main application to route requests
+ * to the correct plugin module.
+ */
+export declare const INSTALLED_PLUGIN_ROUTE: string;
+/**
+ * Default URL route prefix for accessing available (but not yet installed) plugins.
+ *
+ * This route is used to expose a list of plugins that can be installed by the user.
+ * It allows the frontend to discover and fetch plugin metadata or assets from the
+ * local plugin repository.
+ */
+export declare const AVAILABLE_PLUGIN_ROUTE: string;

package/dist/types/0d45f5fd/60dffdb5.d.ts

@@ -0,0 +1,57 @@
+import { EntityManager } from "typeorm";
+import { Manager } from "./d453df06.js";
+export type Callback = (option: {
+    fromPluginName: string;
+    dataSourceManager: DatasourceInfo[];
+    data: any;
+}) => Promise<void> | PromiseLike<void> | void;
+export type DatasourceInfo = {
+    name: string;
+    pluginName: string;
+    sourceManager: EntityManager;
+};
+export type PluginServiceEmitOption = {
+    fromPluginName: string;
+    eventName: string;
+    dataSourceManager?: DatasourceInfo[];
+    data: any;
+};
+export type PluginServiceEventRegisterOption = {
+    pluginName: string;
+    eventName: string;
+    callback: Callback;
+};
+export type IPluginServiceEventManager = {
+    emit: (option: Omit<PluginServiceEmitOption, 'fromPluginName'>) => Promise<void>;
+    register: (option: Omit<PluginServiceEventRegisterOption, 'pluginName'>) => void;
+};
+/**
+ * Property decorator that injects the `PluginServiceEventManager` for cross-plugin communication.
+ *
+ * This provides services or controllers with an interface to:
+ * 1. **Emit Global Events**: Notify other plugins about specific state changes or actions.
+ * 2. **Register Listeners**: Subscribe to events emitted by other plugins.
+ *
+ * The injected manager is scoped, typically mapping to the `IPluginServiceEventManager` interface.
+ */
+export declare function InjectPluginServiceEventManager(): (target: any, propertyKey: string | symbol) => void;
+export declare function getInjectPluginServiceEventManager(target: any, propertyKey: string | symbol): boolean;
+/**
+ * Orchestrator for cross-plugin synchronous and asynchronous events.
+ *
+ * Unlike standard event emitters, the `PluginServiceEventManager` is designed
+ * for the Quan ERP modular architecture. It allows plugins to communicate without
+ * direct hard dependencies, passing along rich context like the source plugin's
+ * database entity managers via `DatasourceInfo`.
+ *
+ * Features:
+ * 1. **Event Caching**: Optimizes dispatch performance by maintaining a map of listeners per event name.
+ * 2. **Transactional Context**: Supports passing `EntityManager` references across plugin boundaries.
+ * 3. **Plugin Scoping**: Automatically tracks which plugin registered which handler.
+ */
+export declare class PluginServiceEventManager extends Manager<Callback> {
+    private cachedCallback;
+    register(instance: Callback, metadata?: (Partial<any> & Record<string, any>) | null, plugin?: string, evtName?: string): void;
+    emit(option: PluginServiceEmitOption): Promise<void>;
+    clearCache(): void;
+}

package/dist/types/0d45f5fd/6559a8c1.d.ts

@@ -0,0 +1,104 @@
+import 'reflect-metadata';
+import express, { NextFunction, Request, Response } from 'express';
+import { Manager } from "./d453df06.js";
+export declare const MIDDLEWARE_KEY = "middleware";
+export declare enum MiddlewareType {
+    CLASS_HANDLER = 0,
+    HANDLER = 1
+}
+export declare enum MiddlewarePosition {
+    BEFORE_ROUTE = "BEFORE_ROUTE",
+    BEFORE_ROOT_ROUTE = "BEFORE_ROOT",
+    AFTER_ROOT_ROUTE = "AFTER_ROOT"
+}
+export type GlobalMiddleWarePosition = Exclude<MiddlewarePosition, MiddlewarePosition.BEFORE_ROUTE>;
+export type MiddlewareHandler = (express.RequestHandler | (new () => IMiddleware));
+export type MiddlewareHandlerInstanceType = (express.RequestHandler | IMiddleware);
+export type MiddlewareExceptionHandler = (express.RequestHandler | (new () => IExceptionMiddleware));
+export type MiddlewareExceptionHandlerInstanceType = (express.ErrorRequestHandler | IExceptionMiddleware);
+export type Middlewares = {
+    type: MiddlewareType;
+    handler: MiddlewareHandler;
+    position: MiddlewarePosition;
+};
+type MiddlewareMetadata = {
+    /** The plugin this middleware belongs to. */
+    plugin: string;
+    /** Optional name for the middleware. */
+    name?: string;
+};
+/**
+ * Class decorator to define metadata for a middleware class.
+ *
+ * @param props - Metadata properties:
+ *   - `plugin` (string): The plugin this middleware belongs to.
+ *   - `name` (string): Optional name for the middleware.
+ *
+ * @returns ClassDecorator - Applies the metadata to the target middleware class.
+ */
+export declare function MiddlewareMetadata(props: MiddlewareMetadata): (target: any) => void;
+export declare function getMiddlewareMetadata(target: any): MiddlewareMetadata | null;
+/**
+ * @function Middleware
+ *
+ * Class and method decorator to attach middleware to Express routes.
+ * Supports both function-based request handlers and class-based middleware
+ * implementing the `IMiddleware` interface.
+ *
+ * Middleware can be applied:
+ * - At the class level (applies to all routes in the class)
+ * - At the method level (applies to a specific route)
+ *
+ * @param position   - Position where the middleware should execute:
+ *                     `BEFORE_ROUTE` or `AFTER_ROUTE`.
+ * @param middleware - One or more middleware handlers:
+ *                     - Function: `(req, res, next) => void` (Express RequestHandler)
+ *                     - Class: A class implementing `IMiddleware` with a `.handler` method
+ *
+ * Middleware are stored in metadata under the `MIDDLEWARE_KEY` symbol.
+ *
+ * Usage Example:
+ * ```ts
+ * @Middleware(authMiddleware)
+ * class UserController {
+ *
+ *   @Middleware(logMiddleware)
+ *   getUser(req: Request, res: Response) {
+ *     res.send("Hello");
+ *   }
+ * }
+ * ```
+ *
+ * Notes:
+ * - Throws an error if a middleware is neither a valid function nor a class implementing `IMiddleware`.
+ * - Method-level middleware is merged with any existing metadata for the same method.
+ * - Class-level middleware is merged with any existing metadata for the class prototype.
+ */
+export declare function Middleware(...middleware: MiddlewareHandler[]): ClassDecorator & MethodDecorator;
+export declare function getMiddleware(controller: any, handler?: any): Middlewares[];
+export declare const DEFAULT_MIDDLEWARE_HANDLER_NAME: string;
+export interface IMiddleware {
+    handler(...args: any[]): any;
+}
+export interface IExceptionMiddleware extends IMiddleware {
+    handler(error: Error, req: Request, res: Response, next: NextFunction): any;
+}
+export interface IExpressMiddleware extends IMiddleware {
+    handler(req: Request, res: Response, next: NextFunction): any;
+}
+type GlobalMiddlewareMetadata = {
+    position: MiddlewarePosition;
+};
+export declare class GlobalMiddlewareManager extends Manager<MiddlewareHandlerInstanceType, GlobalMiddlewareMetadata> {
+    private exceptionHandlerMiddleware;
+    private cachedExceptionHandlerMiddlewares;
+    private cachedMiddleware;
+    register(instance: MiddlewareHandlerInstanceType, metadata?: (Partial<GlobalMiddlewareMetadata> & Record<string, any>) | null, plugin?: string, name?: string): void;
+    registerGlobalExceptionHandler(middleware: MiddlewareExceptionHandlerInstanceType, pluginName: string): void;
+    getAllHandler(): MiddlewareHandlerInstanceType[];
+    getAllExceptionHandlers(): MiddlewareExceptionHandlerInstanceType[];
+    deRegisterByScope(plugin: string, name?: string): void | Promise<void> | PromiseLike<void>;
+    invalidateCache(): void;
+    logDebugInfo(): void;
+}
+export {};

package/dist/types/0d45f5fd/6d626690.d.ts

@@ -0,0 +1,66 @@
+type AIEntityMetadataOption = {
+    description: string;
+};
+/**
+ * Class decorator that provides metadata about a database entity to the AI assistant.
+ *
+ * This decorator allows developers to describe the purpose of an entity (table)
+ * and its relationships in a way that the AI assistant can understand, enabling
+ * more accurate data querying and reasoning.
+ *
+ * @param options - Configuration including descriptions and field-level metadata for the AI.
+ *
+ * @example
+ * ```ts
+ * @AIEntityInfo({
+ *   description: 'Stores user profile information and authentication settings.'
+ * })
+ * @Entity()
+ * class UserEntity { ... }
+ * ```
+ */
+export declare function AIEntityInfo(options: AIEntityMetadataOption): ClassDecorator;
+export declare function getAIEntityInfo(target: Function): AIEntityMetadataOption | undefined;
+type AIColumnMetadataOption = {
+    description: string;
+};
+/**
+ * Property decorator that provides metadata about a specific entity column to the AI assistant.
+ *
+ * This decorator allows developers to define field-level semantics, such as:
+ * 1. **Description**: Explaining what the field stores (e.g., 'The unique email address of the user').
+ * 2. **Context**: Providing hints for the AI on how to interpret the data.
+ *
+ * @param options - Configuration including the field description for the AI.
+ *
+ * @example
+ * ```ts
+ * @Entity()
+ * class UserEntity {
+ *   @AIColumnInfo({
+ *     description: 'The preferred language/locale of the user.'
+ *   })
+ *   @Column()
+ *   locale: string;
+ * }
+ * ```
+ */
+export declare function AIColumnInfo(options: AIColumnMetadataOption): PropertyDecorator;
+export declare function getAIColumnInfo(target: Function, propertyKey: string): AIColumnMetadataOption | undefined;
+/**
+ * Class decorator that explicitly excludes a database entity from the AI assistant's visibility.
+ *
+ * Use this for tables containing sensitive information, internal system state,
+ * or data that is not relevant for AI-powered querying and reporting.
+ */
+export declare function AIExcludeEntity(): ClassDecorator;
+export declare function getAIExcludeEntity(target: Function): boolean | undefined;
+/**
+ * Property decorator that explicitly excludes a specific column from the AI assistant's visibility.
+ *
+ * Use this for fields containing sensitive data (e.g., passwords, internal keys)
+ * or internal metadata that should not be exposed through the AI assistant interface.
+ */
+export declare function AIExcludeColumn(): (target: Object, propertyKey: string) => void;
+export declare function getAIExcludeColumn(target: any, propertyKey: string): boolean;
+export {};