@requence/task 1.0.0-alpha.4 → 1.0.0-alpha.40

package/build/types/helpers/src/protocol/command.d.ts

@@ -0,0 +1,489 @@
+import { z } from 'zod/v4';
+export declare const abortCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"ABORT">;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AbortCommand = z.infer<typeof abortCommandSchema>;
+export declare const createCommandSchema: z.ZodPipe<z.ZodObject<{
+    type: z.ZodLiteral<"CREATE">;
+    treeList: z.ZodObject<{
+        tree: z.ZodObject<{
+            nodes: z.ZodArray<z.ZodAny>;
+            edges: z.ZodArray<z.ZodAny>;
+        }, z.core.$strip>;
+        references: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+        schemas: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, z.core.$strip>;
+    input: z.ZodAny;
+    options: z.ZodObject<{
+        maxExecutions: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        compliance: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+            MCP_TOOL: "MCP_TOOL";
+        }>>>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            LINEAR: "LINEAR";
+            CONTINUOUS: "CONTINUOUS";
+        }>>;
+        priority: z.ZodDefault<z.ZodInt>;
+        uploadUrl: z.ZodOptional<z.ZodString>;
+        streamUrl: z.ZodOptional<z.ZodString>;
+        referencedBy: z.ZodOptional<z.ZodObject<{
+            rootTaskId: z.ZodUUID;
+            taskId: z.ZodUUID;
+            nodeId: z.ZodUUID;
+            messageId: z.ZodUUID;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodTransform<{
+    treeList: {
+        tree: {
+            nodes: ({
+                id: string;
+                type: "entry";
+                inputSchema: import("json-schema").JSONSchema7;
+                alias?: string | undefined;
+            } | {
+                id: string;
+                type: "service";
+                inputSchema: ({
+                    type: "object";
+                } & import("json-schema").JSONSchema7) | {
+                    type: "null";
+                } | ({
+                    $ref: string;
+                } & import("json-schema").JSONSchema7);
+                name: string;
+                version: string;
+                configurationSchema: import("json-schema").JSONSchema7;
+                outputs: {
+                    name: string | null;
+                    schema: import("json-schema").JSONSchema7 | null;
+                }[];
+                alias?: string | undefined;
+                configuration?: any;
+                ttl?: number | undefined;
+                retry?: number | undefined;
+                retryDelay?: number | undefined;
+            } | {
+                id: string;
+                type: "logic";
+                script: string;
+                concurrency: boolean;
+                language: "javascript" | "python" | "typescript";
+                maxExecutionTime: number;
+                outputs: {
+                    name: string | null;
+                    schema: import("json-schema").JSONSchema7 | null;
+                }[];
+                alias?: string | undefined;
+            } | {
+                id: string;
+                type: "or";
+                alias?: string | undefined;
+            } | {
+                id: string;
+                type: "reference";
+                reference: string;
+                inputSchema: ({
+                    type: "object";
+                } & import("json-schema").JSONSchema7) | {
+                    type: "null";
+                } | ({
+                    $ref: string;
+                } & import("json-schema").JSONSchema7);
+                outputs: {
+                    name: string | null;
+                    schema: import("json-schema").JSONSchema7 | null;
+                }[];
+                alias?: string | undefined;
+            } | {
+                id: string;
+                type: "exit";
+                alias?: string | undefined;
+            } | {
+                id: string;
+                type: "comment";
+                text: string;
+                alias?: string | undefined;
+            })[];
+            edges: {
+                id: string;
+                source: string;
+                sourceHandle: string | null;
+                target: string;
+            }[];
+        };
+        references?: {
+            id: string;
+            options: {
+                maxExecutions: number;
+                compliance: "MCP_TOOL" | null;
+                mode: "LINEAR" | "CONTINUOUS";
+            };
+            tree: {
+                nodes: ({
+                    id: string;
+                    type: "entry";
+                    inputSchema: import("json-schema").JSONSchema7;
+                    alias?: string | undefined;
+                } | {
+                    id: string;
+                    type: "service";
+                    inputSchema: ({
+                        type: "object";
+                    } & import("json-schema").JSONSchema7) | {
+                        type: "null";
+                    } | ({
+                        $ref: string;
+                    } & import("json-schema").JSONSchema7);
+                    name: string;
+                    version: string;
+                    configurationSchema: import("json-schema").JSONSchema7;
+                    outputs: {
+                        name: string | null;
+                        schema: import("json-schema").JSONSchema7 | null;
+                    }[];
+                    alias?: string | undefined;
+                    configuration?: any;
+                    ttl?: number | undefined;
+                    retry?: number | undefined;
+                    retryDelay?: number | undefined;
+                } | {
+                    id: string;
+                    type: "logic";
+                    script: string;
+                    concurrency: boolean;
+                    language: "javascript" | "python" | "typescript";
+                    maxExecutionTime: number;
+                    outputs: {
+                        name: string | null;
+                        schema: import("json-schema").JSONSchema7 | null;
+                    }[];
+                    alias?: string | undefined;
+                } | {
+                    id: string;
+                    type: "or";
+                    alias?: string | undefined;
+                } | {
+                    id: string;
+                    type: "reference";
+                    reference: string;
+                    inputSchema: ({
+                        type: "object";
+                    } & import("json-schema").JSONSchema7) | {
+                        type: "null";
+                    } | ({
+                        $ref: string;
+                    } & import("json-schema").JSONSchema7);
+                    outputs: {
+                        name: string | null;
+                        schema: import("json-schema").JSONSchema7 | null;
+                    }[];
+                    alias?: string | undefined;
+                } | {
+                    id: string;
+                    type: "exit";
+                    alias?: string | undefined;
+                } | {
+                    id: string;
+                    type: "comment";
+                    text: string;
+                    alias?: string | undefined;
+                })[];
+                edges: {
+                    id: string;
+                    source: string;
+                    sourceHandle: string | null;
+                    target: string;
+                }[];
+            };
+        }[] | undefined;
+        schemas?: Record<string, import("json-schema").JSONSchema7> | undefined;
+    };
+    type: "CREATE";
+    input: any;
+    options: {
+        maxExecutions: number;
+        compliance: "MCP_TOOL" | null;
+        mode: "LINEAR" | "CONTINUOUS";
+        priority: number;
+        uploadUrl?: string | undefined;
+        streamUrl?: string | undefined;
+        referencedBy?: {
+            rootTaskId: string;
+            taskId: string;
+            nodeId: string;
+            messageId: string;
+        } | undefined;
+    };
+}, {
+    type: "CREATE";
+    treeList: {
+        tree: {
+            nodes: any[];
+            edges: any[];
+        };
+        references?: any[] | undefined;
+        schemas?: Record<string, any> | undefined;
+    };
+    input: any;
+    options: {
+        maxExecutions: number;
+        compliance: "MCP_TOOL" | null;
+        mode: "LINEAR" | "CONTINUOUS";
+        priority: number;
+        uploadUrl?: string | undefined;
+        streamUrl?: string | undefined;
+        referencedBy?: {
+            rootTaskId: string;
+            taskId: string;
+            nodeId: string;
+            messageId: string;
+        } | undefined;
+    };
+}>>;
+export type CreateCommand = z.infer<typeof createCommandSchema>;
+export declare const commandSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"ABORT">;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodPipe<z.ZodObject<{
+    type: z.ZodLiteral<"CREATE">;
+    treeList: z.ZodObject<{
+        tree: z.ZodObject<{
+            nodes: z.ZodArray<z.ZodAny>;
+            edges: z.ZodArray<z.ZodAny>;
+        }, z.core.$strip>;
+        references: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+        schemas: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, z.core.$strip>;
+    input: z.ZodAny;
+    options: z.ZodObject<{
+        maxExecutions: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        compliance: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+            MCP_TOOL: "MCP_TOOL";
+        }>>>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            LINEAR: "LINEAR";
+            CONTINUOUS: "CONTINUOUS";
+        }>>;
+        priority: z.ZodDefault<z.ZodInt>;
+        uploadUrl: z.ZodOptional<z.ZodString>;
+        streamUrl: z.ZodOptional<z.ZodString>;
+        referencedBy: z.ZodOptional<z.ZodObject<{
+            rootTaskId: z.ZodUUID;
+            taskId: z.ZodUUID;
+            nodeId: z.ZodUUID;
+            messageId: z.ZodUUID;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodTransform<{
+    treeList: {
+        tree: {
+            nodes: ({
+                id: string;
+                type: "entry";
+                inputSchema: import("json-schema").JSONSchema7;
+                alias?: string | undefined;
+            } | {
+                id: string;
+                type: "service";
+                inputSchema: ({
+                    type: "object";
+                } & import("json-schema").JSONSchema7) | {
+                    type: "null";
+                } | ({
+                    $ref: string;
+                } & import("json-schema").JSONSchema7);
+                name: string;
+                version: string;
+                configurationSchema: import("json-schema").JSONSchema7;
+                outputs: {
+                    name: string | null;
+                    schema: import("json-schema").JSONSchema7 | null;
+                }[];
+                alias?: string | undefined;
+                configuration?: any;
+                ttl?: number | undefined;
+                retry?: number | undefined;
+                retryDelay?: number | undefined;
+            } | {
+                id: string;
+                type: "logic";
+                script: string;
+                concurrency: boolean;
+                language: "javascript" | "python" | "typescript";
+                maxExecutionTime: number;
+                outputs: {
+                    name: string | null;
+                    schema: import("json-schema").JSONSchema7 | null;
+                }[];
+                alias?: string | undefined;
+            } | {
+                id: string;
+                type: "or";
+                alias?: string | undefined;
+            } | {
+                id: string;
+                type: "reference";
+                reference: string;
+                inputSchema: ({
+                    type: "object";
+                } & import("json-schema").JSONSchema7) | {
+                    type: "null";
+                } | ({
+                    $ref: string;
+                } & import("json-schema").JSONSchema7);
+                outputs: {
+                    name: string | null;
+                    schema: import("json-schema").JSONSchema7 | null;
+                }[];
+                alias?: string | undefined;
+            } | {
+                id: string;
+                type: "exit";
+                alias?: string | undefined;
+            } | {
+                id: string;
+                type: "comment";
+                text: string;
+                alias?: string | undefined;
+            })[];
+            edges: {
+                id: string;
+                source: string;
+                sourceHandle: string | null;
+                target: string;
+            }[];
+        };
+        references?: {
+            id: string;
+            options: {
+                maxExecutions: number;
+                compliance: "MCP_TOOL" | null;
+                mode: "LINEAR" | "CONTINUOUS";
+            };
+            tree: {
+                nodes: ({
+                    id: string;
+                    type: "entry";
+                    inputSchema: import("json-schema").JSONSchema7;
+                    alias?: string | undefined;
+                } | {
+                    id: string;
+                    type: "service";
+                    inputSchema: ({
+                        type: "object";
+                    } & import("json-schema").JSONSchema7) | {
+                        type: "null";
+                    } | ({
+                        $ref: string;
+                    } & import("json-schema").JSONSchema7);
+                    name: string;
+                    version: string;
+                    configurationSchema: import("json-schema").JSONSchema7;
+                    outputs: {
+                        name: string | null;
+                        schema: import("json-schema").JSONSchema7 | null;
+                    }[];
+                    alias?: string | undefined;
+                    configuration?: any;
+                    ttl?: number | undefined;
+                    retry?: number | undefined;
+                    retryDelay?: number | undefined;
+                } | {
+                    id: string;
+                    type: "logic";
+                    script: string;
+                    concurrency: boolean;
+                    language: "javascript" | "python" | "typescript";
+                    maxExecutionTime: number;
+                    outputs: {
+                        name: string | null;
+                        schema: import("json-schema").JSONSchema7 | null;
+                    }[];
+                    alias?: string | undefined;
+                } | {
+                    id: string;
+                    type: "or";
+                    alias?: string | undefined;
+                } | {
+                    id: string;
+                    type: "reference";
+                    reference: string;
+                    inputSchema: ({
+                        type: "object";
+                    } & import("json-schema").JSONSchema7) | {
+                        type: "null";
+                    } | ({
+                        $ref: string;
+                    } & import("json-schema").JSONSchema7);
+                    outputs: {
+                        name: string | null;
+                        schema: import("json-schema").JSONSchema7 | null;
+                    }[];
+                    alias?: string | undefined;
+                } | {
+                    id: string;
+                    type: "exit";
+                    alias?: string | undefined;
+                } | {
+                    id: string;
+                    type: "comment";
+                    text: string;
+                    alias?: string | undefined;
+                })[];
+                edges: {
+                    id: string;
+                    source: string;
+                    sourceHandle: string | null;
+                    target: string;
+                }[];
+            };
+        }[] | undefined;
+        schemas?: Record<string, import("json-schema").JSONSchema7> | undefined;
+    };
+    type: "CREATE";
+    input: any;
+    options: {
+        maxExecutions: number;
+        compliance: "MCP_TOOL" | null;
+        mode: "LINEAR" | "CONTINUOUS";
+        priority: number;
+        uploadUrl?: string | undefined;
+        streamUrl?: string | undefined;
+        referencedBy?: {
+            rootTaskId: string;
+            taskId: string;
+            nodeId: string;
+            messageId: string;
+        } | undefined;
+    };
+}, {
+    type: "CREATE";
+    treeList: {
+        tree: {
+            nodes: any[];
+            edges: any[];
+        };
+        references?: any[] | undefined;
+        schemas?: Record<string, any> | undefined;
+    };
+    input: any;
+    options: {
+        maxExecutions: number;
+        compliance: "MCP_TOOL" | null;
+        mode: "LINEAR" | "CONTINUOUS";
+        priority: number;
+        uploadUrl?: string | undefined;
+        streamUrl?: string | undefined;
+        referencedBy?: {
+            rootTaskId: string;
+            taskId: string;
+            nodeId: string;
+            messageId: string;
+        } | undefined;
+    };
+}>>]>;
+export type Command = z.infer<typeof commandSchema>;
+export type CommandInput = z.input<typeof commandSchema>;
+//# sourceMappingURL=command.d.ts.map

package/build/types/helpers/src/protocol/command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAK1B,eAAO,MAAM,kBAAkB;;;iBAG7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuB3B,CAAA;AAEL,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAAqD,CAAA;AAC/E,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AACnD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA"}

package/build/types/helpers/src/protocol/helpers.d.ts

@@ -0,0 +1,7 @@
+import type { z } from 'zod/v4';
+export declare class NodeTransformError extends Error {
+    readonly nodeId?: string | undefined;
+    constructor(message: string, nodeId?: string | undefined);
+}
+export declare function safeTransform<T extends () => any>(ctx: z.RefinementCtx, handler: T): ReturnType<T>;
+//# sourceMappingURL=helpers.d.ts.map

package/build/types/helpers/src/protocol/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE/B,qBAAa,kBAAmB,SAAQ,KAAK;aAGzB,MAAM,CAAC,EAAE,MAAM;gBAD/B,OAAO,EAAE,MAAM,EACC,MAAM,CAAC,EAAE,MAAM,YAAA;CAIlC;AAED,wBAAgB,aAAa,CAAC,CAAC,SAAS,MAAM,GAAG,EAC/C,GAAG,EAAE,CAAC,CAAC,aAAa,EACpB,OAAO,EAAE,CAAC,GACT,UAAU,CAAC,CAAC,CAAC,CAkBf"}

package/build/types/helpers/src/protocol/index.d.ts

@@ -0,0 +1,8 @@
+export * from './command.ts';
+export * from './nodeType.ts';
+export * from './update.ts';
+export * from './treeNodes.ts';
+export * from './NodeTree.ts';
+export * from './taskOptions.ts';
+export * from './templateNodeTypes.ts';
+//# sourceMappingURL=index.d.ts.map

package/build/types/helpers/src/protocol/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,eAAe,CAAA;AAC7B,cAAc,aAAa,CAAA;AAC3B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,eAAe,CAAA;AAC7B,cAAc,kBAAkB,CAAA;AAChC,cAAc,wBAAwB,CAAA"}

package/build/types/helpers/src/protocol/nodeType.d.ts

@@ -0,0 +1,169 @@
+import { z } from 'zod/v4';
+export declare const entryNodeSchema: z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"entry">;
+    alias: z.ZodOptional<z.ZodString>;
+    inputSchema: z.ZodDefault<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+}, z.core.$strict>;
+export type EntryNode = z.output<typeof entryNodeSchema>;
+export declare const serviceNodeSchema: z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"service">;
+    alias: z.ZodOptional<z.ZodString>;
+    inputSchema: z.ZodDefault<z.ZodUnion<readonly [z.ZodIntersection<z.ZodObject<{
+        type: z.ZodLiteral<"object">;
+    }, z.core.$strip>, z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>, z.ZodObject<{
+        type: z.ZodLiteral<"null">;
+    }, z.core.$strip>, z.ZodIntersection<z.ZodObject<{
+        $ref: z.ZodString;
+    }, z.core.$strip>, z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>]>>;
+    name: z.ZodString;
+    version: z.ZodString;
+    configuration: z.ZodOptional<z.ZodAny>;
+    configurationSchema: z.ZodDefault<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    ttl: z.ZodOptional<z.ZodNumber>;
+    retry: z.ZodOptional<z.ZodNumber>;
+    retryDelay: z.ZodOptional<z.ZodNumber>;
+    outputs: z.ZodArray<z.ZodObject<{
+        name: z.ZodNullable<z.ZodString>;
+        schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+export type ServiceNode = z.output<typeof serviceNodeSchema>;
+export declare const logicNodeSchema: z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"logic">;
+    alias: z.ZodOptional<z.ZodString>;
+    script: z.ZodString;
+    concurrency: z.ZodDefault<z.ZodBoolean>;
+    language: z.ZodDefault<z.ZodEnum<{
+        javascript: "javascript";
+        python: "python";
+        typescript: "typescript";
+    }>>;
+    maxExecutionTime: z.ZodDefault<z.ZodNumber>;
+    outputs: z.ZodArray<z.ZodObject<{
+        name: z.ZodNullable<z.ZodString>;
+        schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+export type LogicNode = z.output<typeof logicNodeSchema>;
+export declare const orNodeSchema: z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"or">;
+    alias: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type OrNode = z.output<typeof orNodeSchema>;
+export declare const referenceNodeSchema: z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"reference">;
+    alias: z.ZodOptional<z.ZodString>;
+    reference: z.ZodString;
+    inputSchema: z.ZodDefault<z.ZodUnion<readonly [z.ZodIntersection<z.ZodObject<{
+        type: z.ZodLiteral<"object">;
+    }, z.core.$strip>, z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>, z.ZodObject<{
+        type: z.ZodLiteral<"null">;
+    }, z.core.$strip>, z.ZodIntersection<z.ZodObject<{
+        $ref: z.ZodString;
+    }, z.core.$strip>, z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>]>>;
+    outputs: z.ZodArray<z.ZodObject<{
+        name: z.ZodNullable<z.ZodString>;
+        schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+export type ReferenceNode = z.output<typeof referenceNodeSchema>;
+export declare const exitNodeSchema: z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"exit">;
+    alias: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ExitNode = z.output<typeof exitNodeSchema>;
+export declare const commentNodeSchema: z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"comment">;
+    text: z.ZodDefault<z.ZodString>;
+    alias: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CommentNode = z.output<typeof commentNodeSchema>;
+export declare const nodeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"entry">;
+    alias: z.ZodOptional<z.ZodString>;
+    inputSchema: z.ZodDefault<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"service">;
+    alias: z.ZodOptional<z.ZodString>;
+    inputSchema: z.ZodDefault<z.ZodUnion<readonly [z.ZodIntersection<z.ZodObject<{
+        type: z.ZodLiteral<"object">;
+    }, z.core.$strip>, z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>, z.ZodObject<{
+        type: z.ZodLiteral<"null">;
+    }, z.core.$strip>, z.ZodIntersection<z.ZodObject<{
+        $ref: z.ZodString;
+    }, z.core.$strip>, z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>]>>;
+    name: z.ZodString;
+    version: z.ZodString;
+    configuration: z.ZodOptional<z.ZodAny>;
+    configurationSchema: z.ZodDefault<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    ttl: z.ZodOptional<z.ZodNumber>;
+    retry: z.ZodOptional<z.ZodNumber>;
+    retryDelay: z.ZodOptional<z.ZodNumber>;
+    outputs: z.ZodArray<z.ZodObject<{
+        name: z.ZodNullable<z.ZodString>;
+        schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    }, z.core.$strip>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"logic">;
+    alias: z.ZodOptional<z.ZodString>;
+    script: z.ZodString;
+    concurrency: z.ZodDefault<z.ZodBoolean>;
+    language: z.ZodDefault<z.ZodEnum<{
+        javascript: "javascript";
+        python: "python";
+        typescript: "typescript";
+    }>>;
+    maxExecutionTime: z.ZodDefault<z.ZodNumber>;
+    outputs: z.ZodArray<z.ZodObject<{
+        name: z.ZodNullable<z.ZodString>;
+        schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    }, z.core.$strip>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"or">;
+    alias: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"reference">;
+    alias: z.ZodOptional<z.ZodString>;
+    reference: z.ZodString;
+    inputSchema: z.ZodDefault<z.ZodUnion<readonly [z.ZodIntersection<z.ZodObject<{
+        type: z.ZodLiteral<"object">;
+    }, z.core.$strip>, z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>, z.ZodObject<{
+        type: z.ZodLiteral<"null">;
+    }, z.core.$strip>, z.ZodIntersection<z.ZodObject<{
+        $ref: z.ZodString;
+    }, z.core.$strip>, z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>]>>;
+    outputs: z.ZodArray<z.ZodObject<{
+        name: z.ZodNullable<z.ZodString>;
+        schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    }, z.core.$strip>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"exit">;
+    alias: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"comment">;
+    text: z.ZodDefault<z.ZodString>;
+    alias: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "type">;
+export declare const edgeSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    source: z.ZodUUID;
+    sourceHandle: z.ZodNullable<z.ZodString>;
+    target: z.ZodUUID;
+}, z.core.$strip>;
+export type Edge = z.output<typeof edgeSchema>;
+export type Node = z.output<typeof nodeSchema>;
+//# sourceMappingURL=nodeType.d.ts.map