@requence/task 1.0.0-alpha.5 → 1.0.0-alpha.51

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

@@ -0,0 +1 @@
+{"version":3,"file":"treeNodes.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/treeNodes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAQ1B,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAGrB,CAAA;AAEF,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,UAAU,CAAC,CAAA;AAE9C,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEtB,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE/D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0Q/B,CAAA;AACD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAU9B,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAEhE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqBvB,CAAA;AAEJ,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,cAAc,CAAC,CAAA;AACtD,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA"}

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

@@ -0,0 +1,406 @@
+import { z } from 'zod/v4';
+declare const nodeInitUpdateSchema: z.ZodObject<{
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
+    node: z.ZodObject<{
+        id: z.ZodUUID;
+        type: z.ZodEnum<{
+            service: "service";
+            logic: "logic";
+            or: "or";
+            reference: "reference";
+        }>;
+        alias: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    type: z.ZodLiteral<"NODE_INIT">;
+    subTaskId: z.ZodDefault<z.ZodNullable<z.ZodUUID>>;
+    triggers: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type NodeInitUpdate = z.infer<typeof nodeInitUpdateSchema>;
+declare const nodeStartUpdateSchema: z.ZodObject<{
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
+    node: z.ZodObject<{
+        id: z.ZodUUID;
+        type: z.ZodEnum<{
+            service: "service";
+            logic: "logic";
+            or: "or";
+            reference: "reference";
+        }>;
+        alias: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    type: z.ZodLiteral<"NODE_START">;
+    libVersion: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    triggers: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type NodeStartUpdate = z.infer<typeof nodeStartUpdateSchema>;
+declare const nodeErrorUpdateSchema: z.ZodObject<{
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
+    node: z.ZodObject<{
+        id: z.ZodUUID;
+        type: z.ZodEnum<{
+            service: "service";
+            logic: "logic";
+            or: "or";
+            reference: "reference";
+        }>;
+        alias: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    type: z.ZodLiteral<"NODE_ERROR">;
+    error: z.ZodString;
+}, z.core.$strip>;
+export type NodeErrorUpdate = z.infer<typeof nodeErrorUpdateSchema>;
+declare const nodeUpdateSchema: z.ZodObject<{
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
+    node: z.ZodObject<{
+        id: z.ZodUUID;
+        type: z.ZodEnum<{
+            service: "service";
+            logic: "logic";
+            or: "or";
+            reference: "reference";
+        }>;
+        alias: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    type: z.ZodLiteral<"NODE_UPDATE">;
+    output: z.ZodNullable<z.ZodString>;
+    data: z.ZodUnknown;
+    overwrite: z.ZodBoolean;
+}, z.core.$strip>;
+export type NodeUpdate = z.infer<typeof nodeUpdateSchema>;
+declare const nodeCallbackSchema: z.ZodObject<{
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
+    node: z.ZodObject<{
+        id: z.ZodUUID;
+        type: z.ZodEnum<{
+            service: "service";
+            logic: "logic";
+            or: "or";
+            reference: "reference";
+        }>;
+        alias: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    type: z.ZodLiteral<"NODE_CALLBACK">;
+    targetNode: z.ZodObject<{
+        id: z.ZodUUID;
+        type: z.ZodEnum<{
+            service: "service";
+            logic: "logic";
+            or: "or";
+            reference: "reference";
+        }>;
+        alias: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    propertyPath: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    output: z.ZodNullable<z.ZodString>;
+    data: z.ZodUnknown;
+}, z.core.$strip>;
+export type NodeCallback = z.infer<typeof nodeCallbackSchema>;
+declare const nodeEndUpdateSchema: z.ZodObject<{
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
+    node: z.ZodObject<{
+        id: z.ZodUUID;
+        type: z.ZodEnum<{
+            service: "service";
+            logic: "logic";
+            or: "or";
+            reference: "reference";
+        }>;
+        alias: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    type: z.ZodLiteral<"NODE_END">;
+}, z.core.$strip>;
+export type NodeEndUpdate = z.infer<typeof nodeEndUpdateSchema>;
+declare const nodeDebugUpdateSchema: z.ZodObject<{
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
+    node: z.ZodObject<{
+        id: z.ZodUUID;
+        type: z.ZodEnum<{
+            service: "service";
+            logic: "logic";
+            or: "or";
+            reference: "reference";
+        }>;
+        alias: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    type: z.ZodLiteral<"NODE_DEBUG">;
+    severity: z.ZodEnum<{
+        error: "error";
+        log: "log";
+        warn: "warn";
+        info: "info";
+        system: "system";
+    }>;
+    data: z.ZodUnknown;
+}, z.core.$strip>;
+export type NodeDebugUpdate = z.infer<typeof nodeDebugUpdateSchema>;
+declare const nodeDeferUpdateSchema: z.ZodObject<{
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
+    node: z.ZodObject<{
+        id: z.ZodUUID;
+        type: z.ZodEnum<{
+            service: "service";
+            logic: "logic";
+            or: "or";
+            reference: "reference";
+        }>;
+        alias: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    type: z.ZodLiteral<"NODE_DEFER">;
+    reason: z.ZodUnknown;
+}, z.core.$strip>;
+export type NodeDeferUpdate = z.infer<typeof nodeDeferUpdateSchema>;
+declare const taskStartUpdateSchema: z.ZodObject<{
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
+    type: z.ZodLiteral<"TASK_START">;
+    parentTask: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        rootTaskId: z.ZodUUID;
+        taskId: z.ZodUUID;
+        nodeId: z.ZodUUID;
+        messageId: z.ZodUUID;
+    }, z.core.$strip>>>;
+    input: z.ZodUnknown;
+}, z.core.$strip>;
+export type TaskStartUpdate = z.infer<typeof taskStartUpdateSchema>;
+declare const taskErrorUpdateSchema: z.ZodObject<{
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
+    type: z.ZodLiteral<"TASK_ERROR">;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type TaskErrorUpdate = z.infer<typeof taskErrorUpdateSchema>;
+declare const taskEndUpdateSchema: z.ZodObject<{
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
+    type: z.ZodLiteral<"TASK_END">;
+    exitName: z.ZodNullable<z.ZodString>;
+    result: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export type TaskEndUpdate = z.infer<typeof taskEndUpdateSchema>;
+export declare const updateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
+    node: z.ZodObject<{
+        id: z.ZodUUID;
+        type: z.ZodEnum<{
+            service: "service";
+            logic: "logic";
+            or: "or";
+            reference: "reference";
+        }>;
+        alias: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    type: z.ZodLiteral<"NODE_INIT">;
+    subTaskId: z.ZodDefault<z.ZodNullable<z.ZodUUID>>;
+    triggers: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
+    node: z.ZodObject<{
+        id: z.ZodUUID;
+        type: z.ZodEnum<{
+            service: "service";
+            logic: "logic";
+            or: "or";
+            reference: "reference";
+        }>;
+        alias: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    type: z.ZodLiteral<"NODE_START">;
+    libVersion: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    triggers: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
+    node: z.ZodObject<{
+        id: z.ZodUUID;
+        type: z.ZodEnum<{
+            service: "service";
+            logic: "logic";
+            or: "or";
+            reference: "reference";
+        }>;
+        alias: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    type: z.ZodLiteral<"NODE_ERROR">;
+    error: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
+    node: z.ZodObject<{
+        id: z.ZodUUID;
+        type: z.ZodEnum<{
+            service: "service";
+            logic: "logic";
+            or: "or";
+            reference: "reference";
+        }>;
+        alias: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    type: z.ZodLiteral<"NODE_UPDATE">;
+    output: z.ZodNullable<z.ZodString>;
+    data: z.ZodUnknown;
+    overwrite: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
+    node: z.ZodObject<{
+        id: z.ZodUUID;
+        type: z.ZodEnum<{
+            service: "service";
+            logic: "logic";
+            or: "or";
+            reference: "reference";
+        }>;
+        alias: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    type: z.ZodLiteral<"NODE_CALLBACK">;
+    targetNode: z.ZodObject<{
+        id: z.ZodUUID;
+        type: z.ZodEnum<{
+            service: "service";
+            logic: "logic";
+            or: "or";
+            reference: "reference";
+        }>;
+        alias: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    propertyPath: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    output: z.ZodNullable<z.ZodString>;
+    data: z.ZodUnknown;
+}, z.core.$strip>, z.ZodObject<{
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
+    node: z.ZodObject<{
+        id: z.ZodUUID;
+        type: z.ZodEnum<{
+            service: "service";
+            logic: "logic";
+            or: "or";
+            reference: "reference";
+        }>;
+        alias: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    type: z.ZodLiteral<"NODE_END">;
+}, z.core.$strip>, z.ZodObject<{
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
+    node: z.ZodObject<{
+        id: z.ZodUUID;
+        type: z.ZodEnum<{
+            service: "service";
+            logic: "logic";
+            or: "or";
+            reference: "reference";
+        }>;
+        alias: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    type: z.ZodLiteral<"NODE_DEBUG">;
+    severity: z.ZodEnum<{
+        error: "error";
+        log: "log";
+        warn: "warn";
+        info: "info";
+        system: "system";
+    }>;
+    data: z.ZodUnknown;
+}, z.core.$strip>, z.ZodObject<{
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
+    node: z.ZodObject<{
+        id: z.ZodUUID;
+        type: z.ZodEnum<{
+            service: "service";
+            logic: "logic";
+            or: "or";
+            reference: "reference";
+        }>;
+        alias: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    type: z.ZodLiteral<"NODE_DEFER">;
+    reason: z.ZodUnknown;
+}, z.core.$strip>, z.ZodObject<{
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
+    type: z.ZodLiteral<"TASK_START">;
+    parentTask: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        rootTaskId: z.ZodUUID;
+        taskId: z.ZodUUID;
+        nodeId: z.ZodUUID;
+        messageId: z.ZodUUID;
+    }, z.core.$strip>>>;
+    input: z.ZodUnknown;
+}, z.core.$strip>, z.ZodObject<{
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
+    type: z.ZodLiteral<"TASK_ERROR">;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
+    type: z.ZodLiteral<"TASK_END">;
+    exitName: z.ZodNullable<z.ZodString>;
+    result: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
+    type: z.ZodLiteral<"TASK_ABORTED">;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "type">;
+export type Update = z.infer<typeof updateSchema>;
+export {};
+//# sourceMappingURL=update.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/update.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAoB1B,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;iBAIxB,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;iBAIzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;iBAGzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;iBAKpB,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEzD,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMtB,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;iBAEvB,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;iBAIzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;iBAGzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;iBAYzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,qBAAqB;;;;;;;iBAGzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,mBAAmB;;;;;;;;iBAIvB,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAO/D,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAavB,CAAA;AAEF,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA"}

package/build/types/helpers/src/utils/callbackToAsyncIterator.d.ts

@@ -0,0 +1,3 @@
+export declare function callbackToAsyncIterator<T>(subscribe: (push: (value: T) => void, fail: (error: Error) => void, end: () => void) => void | (() => void)): AsyncIterator<T>;
+export declare function callbackToAsyncIterable<T>(...args: Parameters<typeof callbackToAsyncIterator<T>>): AsyncIterable<T>;
+//# sourceMappingURL=callbackToAsyncIterator.d.ts.map

package/build/types/helpers/src/utils/callbackToAsyncIterator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callbackToAsyncIterator.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/utils/callbackToAsyncIterator.ts"],"names":[],"mappings":"AAEA,wBAAgB,uBAAuB,CAAC,CAAC,EACvC,SAAS,EAAE,CACT,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,EACxB,IAAI,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,EAC5B,GAAG,EAAE,MAAM,IAAI,KACZ,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,GACvB,aAAa,CAAC,CAAC,CAAC,CA2ElB;AAED,wBAAgB,uBAAuB,CAAC,CAAC,EACvC,GAAG,IAAI,EAAE,UAAU,CAAC,OAAO,uBAAuB,CAAC,CAAC,CAAC,CAAC,GACrD,aAAa,CAAC,CAAC,CAAC,CAMlB"}

package/build/types/helpers/src/utils/clone.d.ts

@@ -0,0 +1,3 @@
+export declare const CLONE_SYMBOL: unique symbol;
+export declare function clone(data: any): any;
+//# sourceMappingURL=clone.d.ts.map

package/build/types/helpers/src/utils/clone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clone.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/utils/clone.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,eAAqB,CAAA;AAE9C,wBAAgB,KAAK,CAAC,IAAI,EAAE,GAAG,GAAG,GAAG,CAiBpC"}

package/build/types/helpers/src/utils/createObjectProxy.d.ts

@@ -0,0 +1,2 @@
+export declare function createObjectProxy(obj: Record<string, unknown>, onChange: (newObj: Record<string, unknown>) => void): Record<string, unknown>;
+//# sourceMappingURL=createObjectProxy.d.ts.map

package/build/types/helpers/src/utils/createObjectProxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createObjectProxy.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/utils/createObjectProxy.ts"],"names":[],"mappings":"AAEA,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5B,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,2BA2BpD"}

package/build/types/helpers/src/utils/debounce.d.ts

@@ -0,0 +1,4 @@
+export declare function debounce<T extends (...args: any[]) => void>(fn: T, options?: {
+    delay?: number;
+}): (...args: Parameters<T>) => void;
+//# sourceMappingURL=debounce.d.ts.map

package/build/types/helpers/src/utils/debounce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debounce.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/utils/debounce.ts"],"names":[],"mappings":"AAAA,wBAAgB,QAAQ,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,EACzD,EAAE,EAAE,CAAC,EACL,OAAO,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,IAIpB,GAAG,MAAM,UAAU,CAAC,CAAC,CAAC,UAc/B"}

package/build/types/helpers/src/utils/guards.d.ts

@@ -0,0 +1,3 @@
+export declare function isRecord(data: unknown): data is Record<string, unknown>;
+export declare function isUuid(data: unknown): data is string;
+//# sourceMappingURL=guards.d.ts.map

package/build/types/helpers/src/utils/guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/utils/guards.ts"],"names":[],"mappings":"AAGA,wBAAgB,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEvE;AAGD,wBAAgB,MAAM,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,MAAM,CAEpD"}

package/build/types/helpers/src/utils/mapData.d.ts

@@ -0,0 +1,18 @@
+type DataVistor<T> = (data: T, path: Array<string | number>) => Promise<any> | any;
+interface DataVistors {
+    Null?: DataVistor<null>;
+    String?: DataVistor<string>;
+    Number?: DataVistor<number>;
+    Object?: DataVistor<object>;
+    Array?: DataVistor<Array<any>>;
+    Buffer?: DataVistor<Buffer>;
+    Function?: DataVistor<(...args: any[]) => any>;
+    Symbol?: DataVistor<symbol>;
+}
+type HasPromiseVistor<T extends DataVistors, Then, Else> = T[keyof T] extends (...args: any[]) => any ? Promise<any> extends ReturnType<T[keyof T]> ? Then : Else : Else;
+export declare function mapData<Output, Input = unknown, V extends DataVistors = DataVistors>(data: Input, visitors: V): HasPromiseVistor<V, Promise<unknown extends Output ? Input : Output>, unknown extends Output ? Input : Output>;
+export declare namespace mapData {
+    var abort: () => never;
+}
+export {};
+//# sourceMappingURL=mapData.d.ts.map

package/build/types/helpers/src/utils/mapData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapData.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/utils/mapData.ts"],"names":[],"mappings":"AAEA,KAAK,UAAU,CAAC,CAAC,IAAI,CACnB,IAAI,EAAE,CAAC,EACP,IAAI,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,KACzB,OAAO,CAAC,GAAG,CAAC,GAAG,GAAG,CAAA;AAEvB,UAAU,WAAW;IACnB,IAAI,CAAC,EAAE,UAAU,CAAC,IAAI,CAAC,CAAA;IACvB,MAAM,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,CAAA;IAC3B,MAAM,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,CAAA;IAC3B,MAAM,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,CAAA;IAC3B,KAAK,CAAC,EAAE,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAA;IAC9B,MAAM,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,CAAA;IAC3B,QAAQ,CAAC,EAAE,UAAU,CAAC,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC,CAAA;IAC9C,MAAM,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,CAAA;CAC5B;AAED,KAAK,gBAAgB,CAAC,CAAC,SAAS,WAAW,EAAE,IAAI,EAAE,IAAI,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,SAAS,CAC5E,GAAG,IAAI,EAAE,GAAG,EAAE,KACX,GAAG,GACJ,OAAO,CAAC,GAAG,CAAC,SAAS,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GACzC,IAAI,GACJ,IAAI,GACN,IAAI,CAAA;AAmBR,wBAAgB,OAAO,CACrB,MAAM,EACN,KAAK,GAAG,OAAO,EACf,CAAC,SAAS,WAAW,GAAG,WAAW,EAEnC,IAAI,EAAE,KAAK,EACX,QAAQ,EAAE,CAAC,GACV,gBAAgB,CACjB,CAAC,EACD,OAAO,CAAC,OAAO,SAAS,MAAM,GAAG,KAAK,GAAG,MAAM,CAAC,EAChD,OAAO,SAAS,MAAM,GAAG,KAAK,GAAG,MAAM,CACxC,CAiFA;yBA5Fe,OAAO"}

package/build/types/helpers/src/{utils.d.ts → utils/matchSchema.d.ts}

@@ -1,4 +1,4 @@
-import type { z } from 'zod';
+import type { z } from 'zod/v4';
 export declare function matchSchema<Schema extends z.ZodSchema>(schema: Schema, input: unknown): input is z.infer<Schema>;
 export declare function matchSchema<Schema extends z.ZodSchema>(schema: Schema): (input: unknown) => input is z.infer<Schema>;
-//# sourceMappingURL=utils.d.ts.map
+//# sourceMappingURL=matchSchema.d.ts.map

package/build/types/helpers/src/utils/matchSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchSchema.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/utils/matchSchema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE/B,wBAAgB,WAAW,CAAC,MAAM,SAAS,CAAC,CAAC,SAAS,EACpD,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA;AAC3B,wBAAgB,WAAW,CAAC,MAAM,SAAS,CAAC,CAAC,SAAS,EACpD,MAAM,EAAE,MAAM,GACb,CAAC,KAAK,EAAE,OAAO,KAAK,KAAK,IAAI,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA"}

package/build/types/helpers/src/utils/obfuscate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"obfuscate.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/utils/obfuscate.ts"],"names":[],"mappings":"AAUA,wBAAgB,SAAS,CAAC,GAAG,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,UA0BhD;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,UAU1C;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,YA4BtC"}

package/build/types/helpers/src/utils/obj.d.ts

@@ -0,0 +1,4 @@
+import dlv from 'dlv';
+export declare function setByPath<T extends Record<string, unknown>, U = T>(obj: T, keys: string | ArrayLike<string | number>, value: unknown): U;
+export declare const getByPath: typeof dlv;
+//# sourceMappingURL=obj.d.ts.map

package/build/types/helpers/src/utils/obj.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"obj.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/utils/obj.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,KAAK,CAAA;AAGrB,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,GAAG,CAAC,EAChE,GAAG,EAAE,CAAC,EACN,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EACzC,KAAK,EAAE,OAAO,GAIiB,CAAC,CACjC;AAED,eAAO,MAAM,SAAS,YAAM,CAAA"}

package/build/types/helpers/src/utils/requenceCallback.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod/v4';
+declare const callbackObjectSchema: z.ZodObject<{
+    sourceId: z.ZodString;
+    outputName: z.ZodNullable<z.ZodString>;
+    propertyPath: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodInt]>>;
+    callbackId: z.ZodUUID;
+    __REQUENCE_type: z.ZodLiteral<"RequenceCallback">;
+}, z.core.$strip>;
+export type CallbackObject = z.infer<typeof callbackObjectSchema>;
+export declare function isCallbackObject(data: unknown): data is CallbackObject;
+export type RequenceCallback<T> = (arg: T) => void;
+export type WrappedRequenceCallback<T> = RequenceCallback<T> & {
+    response(): Promise<T>;
+};
+export declare function createCallback<T>(callback?: (arg: T) => void): WrappedRequenceCallback<T>;
+export {};
+//# sourceMappingURL=requenceCallback.d.ts.map

package/build/types/helpers/src/utils/requenceCallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requenceCallback.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/utils/requenceCallback.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,QAAA,MAAM,oBAAoB;;;;;;iBAMxB,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,cAAc,CAEtE;AAED,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI,CAAA;AAClD,MAAM,MAAM,uBAAuB,CAAC,CAAC,IAAI,gBAAgB,CAAC,CAAC,CAAC,GAAG;IAC7D,QAAQ,IAAI,OAAO,CAAC,CAAC,CAAC,CAAA;CACvB,CAAA;AAED,wBAAgB,cAAc,CAAC,CAAC,EAC9B,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI,GAC1B,uBAAuB,CAAC,CAAC,CAAC,CAa5B"}

package/build/types/helpers/src/utils/resolveRequenceTypes.d.ts

@@ -0,0 +1,8 @@
+export declare function resolveRequenceTypes(data: any, onCallback?: (params: {
+    sourceId: string;
+    callbackId: string;
+    outputName: string | null;
+    propertyPath: (string | number)[];
+    arg: unknown;
+}) => void): any;
+//# sourceMappingURL=resolveRequenceTypes.d.ts.map

package/build/types/helpers/src/utils/resolveRequenceTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveRequenceTypes.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/utils/resolveRequenceTypes.ts"],"names":[],"mappings":"AASA,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,GAAG,EACT,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE;IACpB,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,YAAY,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAA;IACjC,GAAG,EAAE,OAAO,CAAA;CACb,KAAK,IAAI,OAmBX"}

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

@@ -0,0 +1,7 @@
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;
+export type MaybePromise<T> = T | Promise<T>;
+export type MaybeArray<T> = T | T[];
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/utils/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI;KACvB,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CACrB,GAAG,EAAE,CAAA;AAEN,MAAM,MAAM,gBAAgB,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,GAAG,IAAI,CAAC,SAAS,GAAG,GAChE,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GACV,KAAK,CAAA;AAET,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;AAC5C,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAA"}

package/build/types/task/src/abortTask.d.ts

@@ -0,0 +1,8 @@
+interface AbortTaskOptions {
+    accessToken?: string;
+    reason?: string;
+    taskId: string;
+}
+export declare function abortTask(options: AbortTaskOptions): Promise<void>;
+export {};
+//# sourceMappingURL=abortTask.d.ts.map

package/build/types/task/src/abortTask.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abortTask.d.ts","sourceRoot":"","sources":["../../../../src/abortTask.ts"],"names":[],"mappings":"AAWA,UAAU,gBAAgB;IACxB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;CACf;AACD,wBAAsB,SAAS,CAAC,OAAO,EAAE,gBAAgB,iBAgBxD"}

package/build/types/task/src/ackTask.d.ts

@@ -0,0 +1,7 @@
+interface AckTaskOptions {
+    taskId: string;
+    accessToken?: string;
+}
+export declare function ackTask(options: AckTaskOptions): Promise<void>;
+export {};
+//# sourceMappingURL=ackTask.d.ts.map

package/build/types/task/src/ackTask.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ackTask.d.ts","sourceRoot":"","sources":["../../../../src/ackTask.ts"],"names":[],"mappings":"AAEA,UAAU,cAAc;IACtB,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AAED,wBAAsB,OAAO,CAAC,OAAO,EAAE,cAAc,iBAepD"}