@quan-erp/shared-backend-core 1.0.1

package/dist/types/0d45f5fd/da7f739f/06cc432b/5f1c4d9b.d.ts

@@ -0,0 +1,48 @@
+import { NotificationService } from "../../../2ad56231/1242ab99/21beedc5.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 roleId: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "number";
+            };
+        };
+        readonly userId: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "number";
+            };
+        };
+        readonly title: {
+            readonly type: "string";
+        };
+        readonly subTitle: {
+            readonly type: "string";
+        };
+        readonly body: {
+            readonly type: "string";
+            readonly isMultiline: true;
+        };
+        readonly url: {
+            readonly type: "string";
+        };
+        readonly topic: {
+            readonly type: "string";
+        };
+    };
+};
+type Props = SchemaToType<typeof inputSchema>;
+declare const returnSchema: PropsType;
+type ReturnType = SchemaToType<typeof returnSchema>;
+type Arg = {};
+export declare class SendNotificationWorkflowNode implements IWorkflowNode<Props, ReturnType, any> {
+    notificationService: NotificationService;
+    static NODE_ID: string;
+    process(context: ExecutionContext, uid: string, props: Props, args: Arg): Promise<NodeResultType<ReturnType>>;
+    nextToExecute(context: ExecutionContext, uid: string, args: NodeResultType<ReturnType>): PromisableReturn<string[]> | PromisableReturn<null>;
+    getDefination(): WorkflowNodeDefination;
+}
+export {};

package/dist/types/0d45f5fd/da7f739f/06cc432b/8db0fea5.d.ts

@@ -0,0 +1,15 @@
+import { Loggable } from "../../4dd6b41d.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;
+type ReturnType = SchemaToType<typeof returnSchema>;
+export declare class DatabaseWorkflowNode implements IWorkflowNode<Props, ReturnType, any> {
+    logger: Loggable;
+    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/a10395b5.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 SetVariableWorkflowNode 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/aabb6337.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 GetVariableWorkflowNode 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/b16083fb.d.ts

@@ -0,0 +1,29 @@
+import { AIModelService, AIOptions, OnToolCallCallback } from "../../../6610c73e/b96961ed.js";
+import { ExecutionContext } from "../597ef69e.js";
+import { IWorkflowNode, NodeResultType, PromisableReturn, SchemaToType, WorkflowNodeDefination } from "../a588a26e.js";
+declare const inputSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly model: {
+            readonly type: "string";
+        };
+    };
+};
+type Props = SchemaToType<typeof inputSchema>;
+declare const returnSchema: {
+    readonly type: "string";
+};
+export type ReturnType = SchemaToType<typeof returnSchema>;
+export type Args = {
+    prompt: string;
+    options: AIOptions<any>;
+    onToolCall: OnToolCallCallback;
+};
+export declare class AIModelWorkflowNode implements IWorkflowNode<Props, ReturnType, Args> {
+    static NODE_ID: string;
+    aiModelService: AIModelService;
+    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/b5784cae.d.ts

@@ -0,0 +1,38 @@
+import { Env } from "../../b528e7a2.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 apiKey: {
+            readonly type: "string";
+        };
+        readonly apiSecret: {
+            readonly type: "string";
+        };
+        readonly apiUrl: {
+            readonly type: "string";
+        };
+        readonly messageContent: {
+            readonly type: "string";
+            readonly isMultiline: true;
+        };
+        readonly to: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+    };
+};
+type Props = SchemaToType<typeof inputSchema>;
+declare const returnSchema: PropsType;
+type ReturnType = SchemaToType<typeof returnSchema>;
+export declare class SendSMSWorkflowNode implements IWorkflowNode<Props, ReturnType, any> {
+    env: Env;
+    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/b69d1169.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 RunJSScriptWorkflowNode 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/b9a7f4ad.d.ts

@@ -0,0 +1,20 @@
+import { ExecutionContext } from "../597ef69e.js";
+import { IWorkflowNode, NodeResultType, PropsType, PromisableReturn, SchemaToType, WorkflowNodeDefination } from "../a588a26e.js";
+declare const inputSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly fileUrl: {
+            readonly type: "string";
+        };
+    };
+};
+type Props = SchemaToType<typeof inputSchema>;
+declare const returnSchema: PropsType;
+type ReturnType = SchemaToType<typeof returnSchema>;
+export declare class ReadFileWorkflowNode 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/c794fb87.d.ts

@@ -0,0 +1,27 @@
+import { CronJobService } from "../../../6610c73e/c374eea5/4f55037c.js";
+import { ExecutionContext } from "../597ef69e.js";
+import { IWorkflowNode, NodeResultType, PromisableReturn, SchemaToType, WorkflowNodeDefination } from "../a588a26e.js";
+declare const inputSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly expression: {
+            readonly type: "string";
+        };
+        readonly startTime: {
+            readonly type: "date";
+        };
+    };
+};
+export type Props = SchemaToType<typeof inputSchema>;
+declare const returnSchema: {
+    readonly type: "number";
+};
+type ReturnType = SchemaToType<typeof returnSchema>;
+export declare class CronJobWorkflowNode implements IWorkflowNode<Props, ReturnType, any> {
+    static NODE_ID: string;
+    cronJobService: CronJobService;
+    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/d1eb6a2a.d.ts

@@ -0,0 +1,40 @@
+import { AIMemoryService } from "../../../6610c73e/87f29211/00282ba1/da49a2f9.js";
+import { AIModelService, AIToolsService } from "../../../6610c73e/b96961ed.js";
+import { WorkflowService } from "../../../6610c73e/da7f739f/e016487a.js";
+import { Loggable } from "../../4dd6b41d.js";
+import { IWorkflowNode, NodeResultType, PropsType, PromisableReturn, SchemaToType, WorkflowNodeDefination } from "../a588a26e.js";
+import { ExecutionContext } from "../597ef69e.js";
+declare const inputSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly systemPrompt: {
+            readonly type: "string";
+            readonly isMultiline: true;
+        };
+        readonly userPrompt: {
+            readonly type: "string";
+            readonly isMultiline: true;
+        };
+        readonly temperature: {
+            readonly type: "number";
+        };
+        readonly maxCompletionTokens: {
+            readonly type: "number";
+        };
+    };
+};
+type Props = SchemaToType<typeof inputSchema>;
+declare const returnSchema: PropsType;
+type ReturnType = SchemaToType<typeof returnSchema>;
+export declare class AIAgentWorkflowNode implements IWorkflowNode<Props, ReturnType, any> {
+    logger: Loggable;
+    aiMemoryService: AIMemoryService;
+    aiModelService: AIModelService;
+    toolService: AIToolsService;
+    workflowService: WorkflowService;
+    static NODE_ID: string;
+    process(context: ExecutionContext, id: 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/d5ee1c94.d.ts

@@ -0,0 +1,36 @@
+import { ExecutionContext } from "../597ef69e.js";
+import { IWorkflowNode, NodeResultType, PropsType, PromisableReturn, SchemaToType, WorkflowNodeDefination } from "../a588a26e.js";
+declare const inputSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly url: {
+            readonly type: "string";
+        };
+        readonly method: {
+            readonly type: "enum";
+            readonly values: readonly ["GET", "POST", "PUT", "DELETE", "PATCH"];
+        };
+        readonly params: {
+            readonly type: "object";
+            readonly properties: "any";
+        };
+        readonly body: {
+            readonly type: "object";
+            readonly properties: "any";
+        };
+        readonly headers: {
+            readonly type: "object";
+            readonly properties: "any";
+        };
+    };
+};
+type Props = SchemaToType<typeof inputSchema>;
+declare const returnSchema: PropsType;
+type ReturnType = SchemaToType<typeof returnSchema>;
+export declare class HttpRequestWorkflowNode 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/d6e89c7c.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 SendEmailWorkflowNode 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/d8b70efb.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 SwitchWorkflowNode 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/e2a08a0c.d.ts

@@ -0,0 +1,27 @@
+import { Loggable } from "../../4dd6b41d.js";
+import { ExecutionContext } from "../597ef69e.js";
+import { IWorkflowNode, NodeResultType, PropsType, PromisableReturn, SchemaToType, WorkflowNodeDefination } from "../a588a26e.js";
+import { AIChatAssistantService } from "../../../6610c73e/87f29211/3681c247/d3e02bcf.js";
+declare const inputSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly conversationId: {
+            readonly type: "number";
+        };
+        readonly assistantShortId: {
+            readonly type: "string";
+        };
+    };
+};
+type Props = SchemaToType<typeof inputSchema>;
+declare const returnSchema: PropsType;
+type ReturnType = SchemaToType<typeof returnSchema>;
+export declare class AIAssistantWorkflowNode implements IWorkflowNode<Props, ReturnType, any> {
+    logger: Loggable;
+    aiChatAssistantService: AIChatAssistantService;
+    static NODE_ID: string;
+    process(context: ExecutionContext, id: 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/079fe83d.d.ts

@@ -0,0 +1,14 @@
+import { WorkflowNodeManager } from "./fb5fafa3.js";
+import { Workflow } from "./f7427a8d.js";
+import { ExecutionContext } from "./597ef69e.js";
+export declare class WorkflowExecutor {
+    manager: WorkflowNodeManager;
+    constructor(manager: WorkflowNodeManager);
+    execute(props: {
+        workflow: Workflow;
+        args?: any;
+        initialNodeId?: string;
+        privateVariables?: Map<string, any>;
+    }): Promise<ExecutionContext>;
+    private recursiveExecute;
+}

package/dist/types/0d45f5fd/da7f739f/2a1fe862.d.ts

@@ -0,0 +1,26 @@
+import { Workflow, WorkflowScheme } from "./f7427a8d.js";
+export declare class WorkflowBuilder {
+    private workflow;
+    constructor(id: number, name: string);
+    setDisplayName(displayName: string): this;
+    setDescription(description: string): this;
+    setInit(uid: string): this;
+    setMaxRunDuration(ms: number): this;
+    setMaxRetry(retries: number): this;
+    addNode(node: Omit<WorkflowScheme, 'next' | 'inputJoins' | 'joins'> & {
+        inputJoins?: {
+            type: string;
+            id: string;
+        }[];
+        joins?: {
+            type: string;
+            id: string;
+        }[];
+    }): this;
+    addLink(sourceUid: string, targetUid: string): this;
+    addJoin(sourceUid: string, targetUid: string): this;
+    addInputJoin(sourceUid: string, targetUid: string): this;
+    active(): this;
+    inactive(): this;
+    build(): Workflow;
+}

package/dist/types/0d45f5fd/da7f739f/2d25ebcf.d.ts

@@ -0,0 +1,8 @@
+import { NodeResultType } from "./a588a26e.js";
+export declare class PipeData {
+    #private;
+    add<T extends any>(nodeId: string, uid: string, result: NodeResultType<T>): void;
+    get(uid: string): NodeResultType<any> | undefined;
+    static buildTemplate(id: string, field: string): string;
+    resolve(template: any): any;
+}

package/dist/types/0d45f5fd/da7f739f/3e71dc06.d.ts

@@ -0,0 +1,4 @@
+export * from "./f7427a8d.js";
+export * from "./a588a26e.js";
+export * from "./2a1fe862.js";
+export * from "./597ef69e.js";

package/dist/types/0d45f5fd/da7f739f/597ef69e.d.ts

@@ -0,0 +1,90 @@
+import { NodeResultType } from "./a588a26e.js";
+import { PipeData } from "./2d25ebcf.js";
+import { Workflow, WorkflowScheme } from "./f7427a8d.js";
+type ExecutionError = {
+    nodeId: string;
+    plugin: string;
+    uid: string;
+    error: any;
+};
+export type ExecutionEvent = 'onExecutingNode';
+export type ExecutionCallback = (id: string) => void;
+export type ExecutionHistoryData = {
+    operation: 'execute';
+    id: string;
+    type: string;
+    props: any;
+    args: any;
+} | {
+    operation: 'return';
+    id: string;
+    type: string;
+    return: any;
+} | {
+    operation: 'next';
+    id: string;
+    type: string;
+    next: string[] | null;
+} | {
+    operation: 'error';
+    id: string;
+    type: string;
+    error: any;
+} | {
+    operation: 'set-variable';
+    setVariables: {
+        key: string;
+        value: any;
+    };
+};
+export type ExecutionHistory = ExecutionHistoryData & {
+    timestamp: Date;
+};
+export declare class ExecutionContext {
+    private readonly id;
+    private startExecurationTime;
+    private readonly workflow;
+    private error;
+    private _pipeData;
+    private currentRunningNodeId;
+    private executeCallback;
+    private events;
+    private variables;
+    private privateVariables;
+    private executionHistory;
+    constructor(option: {
+        workflow: Workflow;
+        privateVariables?: Map<string, any>;
+        executeCallback: (uid: string, args: any) => Promise<any>;
+    });
+    getExecutionContextId(): string;
+    start(): void;
+    isExecuationTimeOut(): boolean;
+    setError(uid: string, plugin: string, error: any): void;
+    hasError(): boolean;
+    getError(): ExecutionError | null;
+    get pipeData(): PipeData;
+    setCurrentRunningNodeUid(id: string | null): void;
+    getCurrentRunningNodeId(): string | null;
+    getCurrentWorklow(): Workflow;
+    findWorkflowNodeById(id: string): WorkflowScheme | null;
+    execute<A, R extends any>(uid: string, args: A): Promise<NodeResultType<R>>;
+    on(type: ExecutionEvent, callback: ExecutionCallback): void;
+    emit(type: ExecutionEvent, emitFromId: string): void;
+    addHistory(history: ExecutionHistoryData): void;
+    getHistory(): ExecutionHistory[];
+    export(): {
+        id: string;
+        history: ExecutionHistory[];
+        workflow: Workflow;
+        variables: Map<string, any>;
+    };
+    setVariable(key: string, value: any): void;
+    getVariable(key: string): any;
+    getVariables(): Map<string, any>;
+    setPrivateVariable(key: string, value: any): void;
+    getPrivateVariable(key: string): any;
+    getPrivateVariables(): Map<string, any>;
+    getNode(id: string): WorkflowScheme | null;
+}
+export {};

package/dist/types/0d45f5fd/da7f739f/a588a26e.d.ts

@@ -0,0 +1,80 @@
+import { ExecutionContext } from "./597ef69e.js";
+export type NodeResultType<T extends any> = T[];
+export declare class NodeResult {
+    static none(): never[];
+    static single<T extends any>(obj: T): NodeResultType<T>;
+    static getSingle<T extends any>(objs: NodeResultType<T>): T;
+    static multiple<T extends any>(objs: T[]): NodeResultType<T>;
+}
+export type PropsType = {
+    type: 'string';
+} | {
+    type: 'string';
+    isMultiline: true;
+} | {
+    type: 'number';
+} | {
+    type: 'boolean';
+} | {
+    type: 'date';
+} | {
+    type: 'any';
+} | {
+    type: 'array';
+    items: PropsType;
+} | {
+    type: 'array';
+    items: PropsType[];
+} | {
+    type: 'object';
+    properties: Record<string, PropsType | PropsType[]>;
+} | {
+    type: 'object';
+    properties: 'any';
+} | {
+    type: 'enum';
+    values: readonly string[];
+};
+export type WorkflowNodeDefination = {
+    type: string;
+    group: string[] | ['any'] | ['any', ...string[]];
+    displayName?: string;
+    description?: string;
+    props: PropsType;
+    isTriggerable: boolean;
+    returnType?: {
+        type: 'array';
+        items: PropsType | PropsType[];
+    };
+};
+export type PromisableReturn<T> = Promise<T> | T;
+export interface IWorkflowNode<P, R, A> {
+    process(context: ExecutionContext, id: string, props: P, args: A): PromisableReturn<NodeResultType<R>>;
+    nextToExecute(context: ExecutionContext, uid: string, args: NodeResultType<R>): PromisableReturn<string[]> | PromisableReturn<null>;
+    getDefination(): WorkflowNodeDefination;
+}
+export type SchemaToType<T> = T extends {
+    type: 'any';
+} ? any : T extends {
+    type: 'string';
+} ? string : T extends {
+    type: 'number';
+} ? number : T extends {
+    type: 'boolean';
+} ? boolean : T extends {
+    type: 'date';
+} ? Date : T extends {
+    type: 'enum';
+    values: readonly (infer V)[];
+} ? V : T extends {
+    type: 'array';
+    items: infer I;
+} ? I extends PropsType ? SchemaToType<I>[] : never : T extends {
+    type: 'object';
+    properties: 'any';
+} ? Record<string, any> : T extends {
+    type: 'object';
+    properties: infer P;
+} ? {
+    [K in keyof P]: P[K] extends PropsType[] ? SchemaToType<P[K][number]> : SchemaToType<P[K]>;
+} : never;

package/dist/types/0d45f5fd/da7f739f/f7427a8d.d.ts

@@ -0,0 +1,33 @@
+import { PropsType, SchemaToType } from "./a588a26e.js";
+export type WorkflowNodeInfo = {
+    type: string;
+    id: string;
+};
+export type WorkflowScheme = {
+    id: string;
+    type: string;
+    label?: string;
+    props?: SchemaToType<PropsType>;
+    args?: any;
+    metadata?: {
+        position: {
+            x: number;
+            y: number;
+        };
+    };
+    inputJoins: WorkflowNodeInfo[];
+    joins: WorkflowNodeInfo[];
+    next?: WorkflowNodeInfo[];
+};
+export type Workflow = {
+    id: number;
+    name: string;
+    displayName: string;
+    description: string;
+    init: string;
+    flows: WorkflowScheme[];
+    additionalCanvasItems: any[];
+    maxRunDurationInMillisecond?: number;
+    maxRetry?: number;
+    activate: boolean;
+};

package/dist/types/0d45f5fd/da7f739f/fb5fafa3.d.ts

@@ -0,0 +1,12 @@
+import { Manager } from "../d453df06.js";
+import { WorkflowExecutor } from "./079fe83d.js";
+import { IWorkflowNode, WorkflowNodeDefination } from "./a588a26e.js";
+export declare class WorkflowNodeManager extends Manager<IWorkflowNode<any, any, any>> {
+    private execuator;
+    getWorkflowNodesArray(): IWorkflowNode<any, any, any>[];
+    getWorkflowNodes(): Record<string, Record<string, IWorkflowNode<any, any, any>>>;
+    getWorkflowNodesDefinations(): Record<string, Record<string, WorkflowNodeDefination>>;
+    register(instance: IWorkflowNode<any, any, any>, metadata?: (Partial<{}> & Record<string, any>) | null, plugin?: string, id?: string): void;
+    getExecutor(): WorkflowExecutor;
+    logDebugInfo(): void;
+}