@quan-erp/shared-backend-core 1.0.1

package/dist/types/0d45f5fd/ba35bfca.d.ts

@@ -0,0 +1,36 @@
+export declare const INJECT_METADATA_KEY = "inject";
+type InjectOptions = {
+    class: any;
+    plugin: string;
+    name: string;
+};
+/**
+ * Property decorator to inject a class instance or service into a property.
+ *
+ * Stores metadata on the target property indicating which class should be injected,
+ * along with optional plugin and instance name. This metadata can later be used
+ * by a dependency injection container or manager to resolve and set the property.
+ *
+ * @param cls - The class or constructor function to inject
+ * @param plugin - Optional plugin name or namespace for resolving the dependency
+ * @param name - Optional instance name (default is `Manager.DEFAULT_NAME`)
+ *
+ * @example
+ * ```ts
+ * class UserService {}
+ * @Controller()
+ * class UserController {
+ *   @Inject(UserService)
+ *   service!: UserService;
+ * }
+ *
+ * @Controller()
+ * class PluginController {
+ *   @Inject(UserService, 'my-plugin', 'primary')
+ *   service!: UserService;
+ * }
+ * ```
+ */
+export declare function Inject(cls: any, plugin?: string, name?: string): PropertyDecorator;
+export declare function getInject(target: any, propertyKey: string | symbol): InjectOptions | undefined;
+export {};

package/dist/types/0d45f5fd/d453df06.d.ts

@@ -0,0 +1,34 @@
+export interface IManager {
+}
+export type RegistryValue<I, M extends object = {}> = {
+    instance: I;
+    hashUniqueName?: string;
+} & M;
+/**
+ * Abstract base class for all resource and subsystem managers within the Quan ERP kernel.
+ *
+ * The `Manager` provides a consistent, plugin-aware registry pattern. It uses a
+ * two-tier hierarchical Map:
+ * 1. **Plugin Scope**: The top-level key is the name of the plugin (e.g., 'default', 'builtin', or a custom plugin name).
+ * 2. **Resource Name**: The secondary key is the specific name of the resource (e.g., 'default', 'analytics-db').
+ *
+ * This architecture ensures that resources (DataSources, Caches, Services, etc.)
+ * are strictly isolated by plugin boundaries while remaining discoverable.
+ *
+ * @template I - The type of the instance being managed (e.g., `DataSource`, `ICache`).
+ * @template M - The type of metadata associated with each instance.
+ */
+export declare class Manager<I, M extends object = {}> implements IManager {
+    static readonly DEFAULT_NAME = "default";
+    static readonly PROTECTED_PLUGINS: string[];
+    protected readonly registry: Map<string, Map<string, RegistryValue<I, M>>>;
+    static get DEFAULT_PLUGIN(): string;
+    static get BUILTIN_PLUGIN(): string;
+    size(): number;
+    register(instance: I, metadata?: Partial<M> & Record<string, any> | null, plugin?: string, name?: string): void;
+    deRegisterByScope(plugin: string, name?: string): void | Promise<void> | PromiseLike<void>;
+    findByPlugin(plugin?: string, name?: string): RegistryValue<I, M> | undefined | null;
+    getRegistry(): Map<string, Map<string, RegistryValue<I, M>>>;
+    protected getClassUniqueName(cls: any, length?: number): any;
+    protected isProtectedScope(plugin: string): boolean;
+}

package/dist/types/0d45f5fd/d9b4a449.d.ts

@@ -0,0 +1,316 @@
+import { App } from "./4db5cc33.js";
+import { Manager } from "./d453df06.js";
+import * as express from "express";
+import { Response, Express } from "express";
+import { DataSourceManager } from "./78464d38.js";
+import { CacheManager } from "./9a2c73cf.js";
+import { LoggerManager } from "./4dd6b41d.js";
+import { ContainerRegistryManager } from "./885b723d.js";
+import { LifeCycleManager } from "./8e161648.js";
+import { ParamData, RouteManager } from "./1c59aca9.js";
+import { Middlewares as Middleware } from "./6559a8c1.js";
+import { ExposeAPIManager } from "./2881a088.js";
+import { IAppInstance, IPlugin } from "@quan-erp/shared-types";
+import { PluginEnvConfigManager } from "./b528e7a2.js";
+import { WebsocketManager } from "./a1a2ec11.js";
+import { APIInfoMetadata } from "../46b42b42/df62afb5.js";
+import { PluginManager, PluginRegistryValue } from "./ed08a5cd.js";
+import { GracefulJobManager } from "./496c2854.js";
+import { PluginServiceEventManager } from "./60dffdb5.js";
+import { PluginConfigOption } from "./b5020a96.js";
+import { WorkflowNodeManager } from "./da7f739f/fb5fafa3.js";
+export type AppEvents = 'stopped' | 'started' | 'new-plugin-installed' | 'plugin-uninstalled';
+export type AppEventCallback = () => void;
+/**
+ * The core application interface defining the public API for the Quan ERP kernel.
+ *
+ * This interface provides centralized access to all major management systems,
+ * including dependency injection (Registry), plugin lifecycle (Install/Uninstall),
+ * infrastructure (Database, Cache, Websocket), and application-wide events.
+ */
+export interface CoreApp {
+    /** @returns The manager responsible for the global dependency injection container. */
+    getRegistryManager(): ContainerRegistryManager;
+    /**
+     * Dynamically installs and initializes a plugin.
+     * @param pluginName - Name of the plugin.
+     * @param version - Version string.
+     * @param options - Installation parameters.
+     */
+    installPlugin(pluginName: string, version: string, options: {
+        network?: boolean;
+        callModuleReadyLifeCycle?: boolean;
+        ignoreAppReadiness?: boolean;
+        ignoreMigrations?: boolean;
+    }): Promise<void>;
+    /** Uninstalls and cleans up a plugin's resources. */
+    uninstallPlugin(pluginName: string): void;
+    /** @returns The manager for cross-plugin API exposure. */
+    getExportRegistryManager(): ExposeAPIManager;
+    /** @returns The manager for Express route registration. */
+    getRouteManager(): RouteManager;
+    /** @returns The manager for TypeORM data sources and migrations. */
+    getDataSourceManager(): DataSourceManager;
+    /** @returns The manager for cache clients (Redis/In-memory). */
+    getCacheManager(): CacheManager;
+    /** @returns The manager for application and plugin lifecycle hooks. */
+    getLifecycleManager(): LifeCycleManager;
+    /** @returns The manager for websocket server instances. */
+    getWebsocketManager(): WebsocketManager;
+    /** @returns The manager for plugin-scoped environment configurations. */
+    getPluginEnvConfigManager(): PluginEnvConfigManager;
+    /** @returns The manager for installed plugin metadata and status. */
+    getPluginManager(): PluginManager;
+    /** @returns The manager for loggers and logging levels. */
+    getLoggerManager(): LoggerManager;
+    /** @returns The manager for performance and request analytics. */
+    getAnalyticsManager(): Manager<(url: string, timetaken: number) => void>;
+    /** @returns The manager for tracking and awaiting long-running background jobs. */
+    getGracefulJobManager(): GracefulJobManager;
+    /** @returns The manager for cross-plugin event synchronization. */
+    getPluginServiceEventManager(): PluginServiceEventManager;
+    getWorkflowManager(): WorkflowNodeManager;
+    /** @returns An instance implementing the IAppInstance interface for safe plugin use. */
+    getAppInstance(): IAppInstance;
+    getPluginConfig(): PluginConfigOption | undefined;
+    /**
+     * Resolves a service instance from the container.
+     * @param cls - Class to resolve.
+     * @param plugin - Plugin scope.
+     * @param name - Registration name.
+     */
+    get<T>(cls: new (...args: any[]) => T, plugin: string, name?: string): T | undefined;
+    /** Logs debug information for all registered managers and components. */
+    logDebugInfo(): void;
+    /** Registers a listener for global application events. */
+    on(event: AppEvents, callback: AppEventCallback): void;
+    /** Removes a listener for global application events. */
+    off(event: AppEvents): void;
+    /** @returns The underlying Express application instance. */
+    getExpressApp(): Express;
+    /** @returns The main router instance for the application. */
+    getAppRouter(): express.Router;
+    /** @returns The version of the core kernel. */
+    getVersion(): string;
+    /** @returns The unique ID for this application instance. */
+    getAppId(): string;
+}
+export declare function setCoreApp(name: string, app: CoreApp): void;
+export declare function getCoreApp(name?: string): CoreApp;
+/**
+ * Converts a plain JavaScript object into an instance of the specified TargetClass (DTO).
+ *
+ * This transformation allows the application to use class decorators (e.g., for validation
+ * or computed properties) on data received from HTTP requests.
+ *
+ * Logic:
+ * 1. Uses `plainToInstance` for robust class transformation.
+ * 2. Falls back to manual instantiation and `Object.assign` if transformation fails.
+ *
+ * @param value - The raw data object to convert.
+ * @param TargetClass - The DTO class to instantiate.
+ * @returns An instance of the target class with data applied.
+ * @throws Error if instantiation fails.
+ */
+export declare function convertPayload(value: any, TargetClass: any): any;
+export declare const ModuleHelper: {
+    /**
+     * Orchestrates the complete processing and initialization of a module class.
+     *
+     * This method handles the extraction of metadata via `@Module` and performs the following:
+     * 1. **Static Files**: Sets up Express static file serving if configured.
+     * 2. **Entities**: Registers database entities with the `DataSourceManager`.
+     * 3. **Providers**: Resolves and initializes services (providers) via dependency injection.
+     * 4. **Exports**: Exposes specific services for cross-plugin consumption.
+     * 5. **Controllers**: Initializes controllers and registers their Express routes.
+     * 6. **Imports**: Recursively processes imported modules to maintain the hierarchy.
+     * 7. **Infrastructure**: Configures workflows, websockets, data sources, cache clients, and loggers.
+     * 8. **Middlewares**: Registers global exception filters and request filters.
+     * 9. **Migrations**: Executes any manual `up()` migrations defined on the module.
+     *
+     * @param app - The current `App` instance to register components into.
+     * @param moduleClass - The class decorated with `@Module` to process.
+     * @param plugin - The name of the plugin context (defaults to 'default').
+     * @throws Error if module resolution or initialization fails.
+     */
+    processModule(app: App, moduleClass: any, plugin?: string): Promise<void>;
+};
+export declare const PropertyInjectionHelper: {
+    /**
+     * Performs property-level dependency injection on a class instance by defining dynamic getters.
+     * It scans the class prototype for metadata decorators and bridges those properties
+     * to the corresponding managers in the global `CoreApp`.
+     *
+     * Supported Injections:
+     * - **`@InjectDatabaseSource`**: Maps to TypeORM DataSources.
+     * - **`@Inject`**: Maps to other services in the container.
+     * - **`@InjectWebsocketServer`**: Provides access to websocket server instances.
+     * - **`@CacheClient`**: Provides access to cache clients.
+     * - **`@InjectPluginServiceEventManager`**: Provides cross-plugin event synchronization.
+     * - **`@InjectEnv`**: Provides scoped environment configuration access.
+     * - **`@InjectLogger`**: Provides class-specific logging instances.
+     * - **`@InjectWorkflowRunnerFactory`**: Provides workflow execution capabilities.
+     * - **`@InjectMigrationManager`**: Provides access to the migration service.
+     * - **`@InjectAppInstance`**: Provides access to the core global app instance.
+     * - **`@InjectHealthCheck`**: Provides access to health check status setters.
+     *
+     * @param app - The current `CoreApp` context.
+     * @param instance - The target instance to perform injection on.
+     * @param plugin - The name of the current plugin scope.
+     * @param name - The registration name within the scope (defaults to 'default').
+     */
+    inject(app: CoreApp, instance: any, plugin: string, name?: string): void;
+};
+export declare const ResolverHelper: {
+    /**
+     * Resolves a module dependency (class) by instantiating it and processing its decorators.
+     *
+     * The resolution happens in several distinct phases:
+     * 1. **Singleton Check**: Returns the existing instance if the class/plugin combination is already in the container.
+     * 2. **Constructor Injection**: Recursively resolves and injects constructor parameters using TypeDoc metadata.
+     * 3. **Workflow & Cron**: Wraps triggerable workflows and schedules cron jobs defined on the class.
+     * 4. **Caching Proxy**: Wraps methods with `@CacheRoute` or `@DeleteCacheRoute` logic.
+     * 5. **Property Injection**: Injects DB sources, services, logs, and env configs into decorated class properties.
+     * 6. **Bean Resolution**: Executes methods marked with `@Bean` and registers their return values into the container.
+     * 7. **AI Tools**: Scans and registers methods marked with `@AITool` into the global `AIToolsService`.
+     * 8. **Lifecycle & Containerization**: Registers hooks, calls `onModuleInit`, and finally saves the instance to the container.
+     *
+     * @param cls - The class constructor to resolve.
+     * @param app - The current `CoreApp` instance.
+     * @param plugin - The name of the plugin context (defaults to 'default').
+     * @param options - Configure whether to auto-register and how to handle resolve errors.
+     * @returns The fully initialized and injected class instance.
+     * @throws Error if resolution fails and `silentOnResolveError` is false.
+     *
+     * @example
+     * \@Service()
+     * class MyService {
+     *   \@Inject(DatabaseSource) source: DataSource;
+     *
+     *   \@CronJob('0 0 * * *')
+     *   async handleTick() { ... }
+     *
+     *   \@AITool({ description: 'Get user info' })
+     *   getUser() { ... }
+     * }
+     *
+     * const instance = ResolverHelper.resolveModuleDependency(MyService, app, 'my-plugin');
+     */
+    resolveModuleDependency(cls: any, app: CoreApp, plugin?: string, options?: {
+        registerAutomaticallyIfNotFound: boolean;
+        silentOnResolveError: boolean;
+    }): any;
+    /**
+     * Resolves and maps HTTP request data to controller method arguments based on parameter metadata.
+     * This method handles various sources like route params, query strings, request bodies,
+     * headers, and specialized objects (User, Auth Token, API Info).
+     *
+     * It also performs automatic type conversion for primitive types, enums, and complex DTOs
+     * using the declared TypeScript types on the method parameters.
+     *
+     * @param paramMeta - Metadata describing the source and type of each parameter.
+     * @param req - The Express request object.
+     * @param res - The Express response object.
+     * @param nextFun - The Express next function.
+     * @param metadata - Optional additional metadata (e.g., API documentation context).
+     * @returns An array of arguments ready to be applied to the controller method.
+     *
+     * @example
+     * // For a method like: findOne(@Param('id') id: number, @Query('search') search: string)
+     * // paramMeta would be:
+     * // [
+     * //   { index: 0, type: 'param', name: 'id', dataType: Number },
+     * //   { index: 1, type: 'query', name: 'search', dataType: String }
+     * // ]
+     */
+    resolveControllerRouteParameter(paramMeta: ParamData<any>[], req: express.Request, res: Response, nextFun: express.NextFunction, metadata?: {
+        apiInfo?: APIInfoMetadata;
+    }): Promise<any[]>;
+    /**
+     * Resolves a middleware configuration into an Express request handler.
+     *
+     * Supports two types of middleware:
+     * 1. **Functional Middleware**: Returns the handler function directly.
+     * 2. **Class-based Middleware**: Resolves the `IMiddleware` class via `resolveModuleDependency`
+     *    and wraps its `handler` method to support dependency-injected parameters.
+     *
+     * @param app - The current `CoreApp` instance.
+     * @param plugin - The name of the plugin context.
+     * @param m - The middleware configuration (handler and metadata).
+     * @param metadata - Optional API information for parameter resolution.
+     * @returns An Express request handler function.
+     */
+    resolveMiddlewareHandler(app: CoreApp, plugin: string, m: Middleware, metadata?: {
+        apiInfo?: APIInfoMetadata;
+    }): express.RequestHandler;
+    /**
+     * Resolves a controller by instantiating it, injecting dependencies, and registering its Express routes.
+     *
+     * Key responsibilities:
+     * 1. **Instantiation & Injection**: Resolves the controller via `resolveModuleDependency` and injects properties.
+     * 2. **Path Calculation**: Determines the base URL path (prefixed by plugin name for non-system plugins).
+     * 3. **Middleware Layering**: Combines controller-level and route-level middlewares.
+     * 4. **Route Registration**: Maps HTTP methods and paths to controller handlers.
+     * 5. **Execution Wrapper**: Wraps handlers to support:
+     *    - Automatic caching and cache invalidation.
+     *    - Request parameter resolution and type conversion.
+     *    - Standardized response formatting.
+     *    - Analytics and performance tracking.
+     *
+     * @param Controller - The controller class to resolve and register.
+     * @param app - The current `CoreApp` instance.
+     * @param plugin - The name of the plugin context (defaults to 'default').
+     */
+    resolveController(Controller: any, app: CoreApp, plugin?: string): void;
+    /**
+     * Resolves and registers classes that are marked for cross-plugin export.
+     *
+     * This method ensures that services intended for use by other plugins are correctly
+     * instantiated with all dependencies resolved and registered in the global export registry.
+     *
+     * process:
+     * 1. Checks if already exported.
+     * 2. Verifies `@Expose` configuration.
+     * 3. Resolves constructor and property dependencies.
+     * 4. Registers with the specified service tag and version.
+     *
+     * @param cls - The class to resolve and export.
+     * @param app - The current `CoreApp` instance.
+     * @param plugin - The name of the source plugin.
+     * @param name - The registration name within the scope.
+     */
+    resolveExports(cls: any, app: CoreApp, plugin?: string, name?: string): any;
+};
+export declare const ResponseFormatter: {
+    /**
+     * Standardizes the way responses are sent to the client based on the returned value type.
+     *
+     * Logic:
+     * - **`ResponseDto`**: Extracts status code (`code`) and sends as JSON.
+     * - **Object**: Sends as JSON (`res.json`).
+     * - **String/Number**: Sends as raw text.
+     * - **null/undefined**: Ends the response with no content.
+     *
+     * It also prevents double-sending by checking `res.headersSent`.
+     *
+     * @param result - The data returned by the controller or middleware.
+     * @param res - The Express response object.
+     */
+    sendInFormat(result: any, res: Response): express.Response<any, Record<string, any>> | undefined;
+};
+/**
+ * Identifies and validates all installed plugins that depend on the specified plugin.
+ *
+ * This is primarily used during uninstallation to prevent breaking the dependency tree,
+ * ensuring that a plugin is not removed if others rely on it.
+ *
+ * @param plugin - The target plugin to check for dependents.
+ * @param installedPlugins - A map of all currently registered plugins.
+ * @returns An array of dependency information, including whether version constraints are satisfied.
+ */
+export declare function getDependents(plugin: IPlugin, installedPlugins: Map<string, PluginRegistryValue>): {
+    plugin: string;
+    requiredRange: string;
+    installedVersion: string | undefined;
+    isSatisfied: boolean;
+}[];

package/dist/types/0d45f5fd/da7f739f/06cc432b/06650bfd.d.ts

@@ -0,0 +1,13 @@
+import { ExecutionContext } from "../597ef69e.js";
+import { IWorkflowNode, NodeResultType, PropsType, PromisableReturn, SchemaToType, WorkflowNodeDefination } from "../a588a26e.js";
+declare const inputSchema: PropsType;
+type Props = SchemaToType<typeof inputSchema>;
+declare const returnSchema: PropsType;
+type ReturnType = SchemaToType<typeof returnSchema>;
+export declare class WaitForWorkflowNode implements IWorkflowNode<Props, ReturnType, any> {
+    static NODE_ID: string;
+    process(context: ExecutionContext, uid: string, props: Props, args: any): Promise<NodeResultType<ReturnType>>;
+    nextToExecute(context: ExecutionContext, uid: string, args: NodeResultType<ReturnType>): PromisableReturn<string[]> | PromisableReturn<null>;
+    getDefination(): WorkflowNodeDefination;
+}
+export {};

package/dist/types/0d45f5fd/da7f739f/06cc432b/228cff9f.d.ts

@@ -0,0 +1,13 @@
+import { ExecutionContext } from "../597ef69e.js";
+import { IWorkflowNode, NodeResultType, PropsType, PromisableReturn, SchemaToType, WorkflowNodeDefination } from "../a588a26e.js";
+declare const inputSchema: PropsType;
+type Props = SchemaToType<typeof inputSchema>;
+declare const returnSchema: PropsType;
+type ReturnType = SchemaToType<typeof returnSchema>;
+export declare class IfWorkflowNode implements IWorkflowNode<Props, ReturnType, any> {
+    static NODE_ID: string;
+    process(context: ExecutionContext, uid: string, props: Props, args: any): PromisableReturn<NodeResultType<ReturnType>>;
+    nextToExecute(context: ExecutionContext, uid: string, args: NodeResultType<ReturnType>): PromisableReturn<string[]> | PromisableReturn<null>;
+    getDefination(): WorkflowNodeDefination;
+}
+export {};

package/dist/types/0d45f5fd/da7f739f/06cc432b/2a8ae20e.d.ts

@@ -0,0 +1,13 @@
+import { ExecutionContext } from "../597ef69e.js";
+import { IWorkflowNode, NodeResultType, PropsType, PromisableReturn, SchemaToType, WorkflowNodeDefination } from "../a588a26e.js";
+declare const inputSchema: PropsType;
+type Props = SchemaToType<typeof inputSchema>;
+declare const returnSchema: PropsType;
+type ReturnType = SchemaToType<typeof returnSchema>;
+export declare class LoopWorkflowNode implements IWorkflowNode<Props, ReturnType, any> {
+    static NODE_ID: string;
+    process(context: ExecutionContext, uid: string, props: Props, args: any): Promise<NodeResultType<ReturnType>> | NodeResultType<ReturnType>;
+    nextToExecute(context: ExecutionContext, uid: string, args: NodeResultType<ReturnType>): PromisableReturn<string[]> | PromisableReturn<null>;
+    getDefination(): WorkflowNodeDefination;
+}
+export {};

package/dist/types/0d45f5fd/da7f739f/06cc432b/3110d02c.d.ts

@@ -0,0 +1,13 @@
+import { ExecutionContext } from "../597ef69e.js";
+import { IWorkflowNode, NodeResultType, PropsType, PromisableReturn, SchemaToType, WorkflowNodeDefination } from "../a588a26e.js";
+declare const inputSchema: PropsType;
+type Props = SchemaToType<typeof inputSchema>;
+declare const returnSchema: PropsType;
+type ReturnType = SchemaToType<typeof returnSchema>;
+export declare class MergeWorkflowNode implements IWorkflowNode<Props, ReturnType, any> {
+    static NODE_ID: string;
+    process(context: ExecutionContext, uid: string, props: Props, args: any): Promise<NodeResultType<ReturnType>> | NodeResultType<ReturnType>;
+    nextToExecute(context: ExecutionContext, uid: string, args: NodeResultType<ReturnType>): PromisableReturn<string[]> | PromisableReturn<null>;
+    getDefination(): WorkflowNodeDefination;
+}
+export {};

package/dist/types/0d45f5fd/da7f739f/06cc432b/3d168b1c.d.ts

@@ -0,0 +1,22 @@
+import { ChatCompletionMessageParam } from "openai/resources";
+import { AIMemoryService } from "../../../6610c73e/87f29211/00282ba1/da49a2f9.js";
+import { ExecutionContext } from "../597ef69e.js";
+import { IWorkflowNode, NodeResultType, PropsType, PromisableReturn, SchemaToType, WorkflowNodeDefination } from "../a588a26e.js";
+declare const inputSchema: PropsType;
+type Props = SchemaToType<typeof inputSchema>;
+declare const returnSchema: PropsType;
+export type ReturnType = SchemaToType<typeof returnSchema>;
+export type Args = {
+    method: 'GET';
+} | {
+    method: 'APPEND_ALL';
+    messages: ChatCompletionMessageParam[];
+};
+export declare class AIMemoryWorkflowNode implements IWorkflowNode<Props, ReturnType, Args> {
+    static NODE_ID: string;
+    aiMemoryService: AIMemoryService;
+    process(context: ExecutionContext, uid: string, props: Props, args: Args): Promise<NodeResultType<ReturnType>>;
+    nextToExecute(context: ExecutionContext, uid: string, args: NodeResultType<ReturnType>): PromisableReturn<string[]> | PromisableReturn<null>;
+    getDefination(): WorkflowNodeDefination;
+}
+export {};

package/dist/types/0d45f5fd/da7f739f/06cc432b/4650afb2.d.ts

@@ -0,0 +1,13 @@
+import { ExecutionContext } from "../597ef69e.js";
+import { IWorkflowNode, NodeResultType, PropsType, PromisableReturn, SchemaToType, WorkflowNodeDefination } from "../a588a26e.js";
+declare const inputSchema: PropsType;
+type Props = SchemaToType<typeof inputSchema>;
+declare const returnSchema: PropsType;
+type ReturnType = SchemaToType<typeof returnSchema>;
+export declare class EndWorkflowNode implements IWorkflowNode<Props, ReturnType, any> {
+    static NODE_ID: string;
+    process(context: ExecutionContext, uid: string, props: Props, args: any): Promise<NodeResultType<ReturnType>> | NodeResultType<ReturnType>;
+    nextToExecute(context: ExecutionContext, uid: string, args: NodeResultType<ReturnType>): PromisableReturn<string[]> | PromisableReturn<null>;
+    getDefination(): WorkflowNodeDefination;
+}
+export {};

package/dist/types/0d45f5fd/da7f739f/06cc432b/483335d4.d.ts

@@ -0,0 +1,37 @@
+import { ExecutionContext } from "../597ef69e.js";
+import { IWorkflowNode, NodeResultType, PromisableReturn, SchemaToType, WorkflowNodeDefination } from "../a588a26e.js";
+declare const inputSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly statusCode: {
+            readonly type: "number";
+        };
+        readonly body: {
+            readonly type: "object";
+            readonly properties: "any";
+        };
+    };
+};
+type Props = SchemaToType<typeof inputSchema>;
+declare const returnSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly statusCode: {
+            readonly type: "number";
+        };
+        readonly body: {
+            readonly type: "object";
+            readonly properties: "any";
+        };
+    };
+};
+type ReturnType = SchemaToType<typeof returnSchema>;
+export declare class HttpResponseJsonWorkflowNode implements IWorkflowNode<Props, ReturnType, any> {
+    static NODE_ID: string;
+    static PRIVATE_VARIABLE_KEY: string;
+    private resolve;
+    process(context: ExecutionContext, uid: string, props: Props, args: any): Promise<NodeResultType<ReturnType>> | NodeResultType<ReturnType>;
+    nextToExecute(context: ExecutionContext, uid: string, args: NodeResultType<ReturnType>): PromisableReturn<string[]> | PromisableReturn<null>;
+    getDefination(): WorkflowNodeDefination;
+}
+export {};

package/dist/types/0d45f5fd/da7f739f/06cc432b/5173b4f0.d.ts

@@ -0,0 +1,26 @@
+import { WorkflowService } from "../../../6610c73e/da7f739f/e016487a.js";
+import { ExecutionContext } from "../597ef69e.js";
+import { IWorkflowNode, NodeResultType, PropsType, PromisableReturn, SchemaToType, WorkflowNodeDefination } from "../a588a26e.js";
+declare const inputSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly workflowId: {
+            readonly type: "string";
+        };
+        readonly args: {
+            readonly type: "object";
+            readonly properties: "any";
+        };
+    };
+};
+type Props = SchemaToType<typeof inputSchema>;
+declare const returnSchema: PropsType;
+type ReturnType = SchemaToType<typeof returnSchema>;
+export declare class ExecuteAnotherWorkflowNode implements IWorkflowNode<Props, ReturnType, any> {
+    static NODE_ID: string;
+    service: WorkflowService;
+    process(context: ExecutionContext, uid: string, props: Props, args: any): Promise<NodeResultType<ReturnType>>;
+    nextToExecute(context: ExecutionContext, uid: string, args: NodeResultType<ReturnType>): PromisableReturn<string[]> | PromisableReturn<null>;
+    getDefination(): WorkflowNodeDefination;
+}
+export {};

package/dist/types/0d45f5fd/da7f739f/06cc432b/539f31f2.d.ts

@@ -0,0 +1,25 @@
+import { ExecutionContext } from "../597ef69e.js";
+import { IWorkflowNode, NodeResultType, PropsType, PromisableReturn, SchemaToType, WorkflowNodeDefination } from "../a588a26e.js";
+declare const inputSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly toolName: {
+            readonly type: "string";
+        };
+        readonly description: {
+            readonly type: "string";
+            readonly isMultiline: true;
+        };
+    };
+};
+export type Props = SchemaToType<typeof inputSchema>;
+declare const returnSchema: PropsType;
+type ReturnType = SchemaToType<typeof returnSchema>;
+export declare class AIToolWorkflowNode implements IWorkflowNode<Props, ReturnType, any> {
+    static NODE_ID: string;
+    private toolService;
+    process(context: ExecutionContext, uid: string, props: Props, args: any): Promise<NodeResultType<ReturnType>>;
+    nextToExecute(context: ExecutionContext, uid: string, args: NodeResultType<ReturnType>): PromisableReturn<string[]> | PromisableReturn<null>;
+    getDefination(): WorkflowNodeDefination;
+}
+export {};

package/dist/types/0d45f5fd/da7f739f/06cc432b/546ed991.d.ts

@@ -0,0 +1,43 @@
+import { ExecutionContext } from "../597ef69e.js";
+import { IWorkflowNode, NodeResultType, PromisableReturn, SchemaToType, WorkflowNodeDefination } from "../a588a26e.js";
+declare const inputSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly route: {
+            readonly type: "string";
+        };
+        readonly method: {
+            readonly type: "enum";
+            readonly values: readonly ["POST", "PUT", "GET", "DELETE"];
+        };
+    };
+};
+type Props = SchemaToType<typeof inputSchema>;
+declare const returnSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly body: {
+            readonly type: "object";
+            readonly properties: "any";
+        };
+        readonly params: {
+            readonly type: "object";
+            readonly properties: "any";
+        };
+        readonly route: {
+            readonly type: "string";
+        };
+        readonly method: {
+            readonly type: "enum";
+            readonly values: readonly ["POST", "PUT", "GET", "DELETE"];
+        };
+    };
+};
+type ReturnType = SchemaToType<typeof returnSchema>;
+export declare class ListenHttpWorkflowNode implements IWorkflowNode<Props, ReturnType, any> {
+    static NODE_ID: string;
+    process(context: ExecutionContext, uid: string, props: Props, args: any): Promise<NodeResultType<ReturnType>> | NodeResultType<ReturnType>;
+    nextToExecute(context: ExecutionContext, uid: string, args: NodeResultType<ReturnType>): PromisableReturn<string[]> | PromisableReturn<null>;
+    getDefination(): WorkflowNodeDefination;
+}
+export {};