@requence/task 1.0.0-alpha.3 → 1.0.0-alpha.31

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

@@ -0,0 +1,354 @@
+import { z } from 'zod/v4';
+declare const nodeInitUpdateSchema: z.ZodObject<{
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    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">;
+    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;
+    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;
+    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;
+    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;
+}, 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;
+    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;
+    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;
+    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;
+    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;
+    type: z.ZodLiteral<"TASK_START">;
+    parentTask: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        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;
+    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;
+    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;
+    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">;
+    triggers: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    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;
+    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;
+    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;
+}, z.core.$strip>, z.ZodObject<{
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    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;
+    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;
+    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;
+    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;
+    type: z.ZodLiteral<"TASK_START">;
+    parentTask: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        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;
+    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;
+    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;
+    type: z.ZodLiteral<"TASK_ABORTED">;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>]>;
+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;AAkB1B,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;iBAGxB,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;;;;;;;;;;;;;;;;iBAIpB,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;;;;;;;;;;iBAWzB,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAavB,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): 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,GACR,aAAa,CAAC,CAAC,CAAC,CAgDlB;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/{createRemotePromise.d.ts → utils/createRemotePromise.d.ts}

@@ -1,4 +1,4 @@
-export default function createRemotePromise<T = void>(onAwait?: (resolve: (value: T) => void, reject: (error: any) => void) => void | Promise<void>): Promise<T> & {
+export declare function createRemotePromise<T = void>(onAwait?: (resolve: (value: T) => void, reject: (error: any) => void) => void | Promise<void>): Promise<T> & {
     resolve: (value: T | PromiseLike<T>) => void;
     reject: (reason?: any) => void;
     promise: Promise<T>;

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

@@ -0,0 +1 @@
+{"version":3,"file":"createRemotePromise.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/utils/createRemotePromise.ts"],"names":[],"mappings":"AAAA,wBAAgB,mBAAmB,CAAC,CAAC,GAAG,IAAI,EAC1C,OAAO,CAAC,EAAE,CACR,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,EAC3B,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,KACzB,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;qBAEI,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,KAAK,IAAI;sBAC1B,GAAG,KAAK,IAAI;;EAgC3C;AAED,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAA"}

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

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

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

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

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/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,CAgB5B"}

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,4 @@
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+//# 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"}

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/createTask.d.ts

@@ -3,108 +3,11 @@ export declare class TaskError extends Error {
     readonly taskTemplate: string;
     constructor(message: string, taskTemplate: string);
 }
-type TaskUpdateHandler = (update: Update) => void;
-export declare function createTask<T extends keyof Requence.TaskTemplate | (string & {})>(options: CreateTaskOptions<T>, onUpdate?: TaskUpdateHandler): Promise<Result<T>> & AsyncIterable<{
-    type: "taskStart";
-    timestamp: Date;
-    taskId: string;
-    input?: unknown;
-    meta?: unknown;
-} | {
-    type: "taskError";
-    timestamp: Date;
-    taskId: string;
-    error: string;
-} | {
-    type: "taskEnd";
-    timestamp: Date;
-    taskId: string;
-    result: Record<string, unknown>;
-    partialResults: {
-        timestamp: Date | null;
-        node: {
-            type: "service";
-            id: string;
-            service?: {
-                id: string;
-                name: string;
-                version: string;
-            } | undefined;
-            alias?: string | undefined;
-        } | {
-            type: "logic";
-            id: string;
-            alias?: string | undefined;
-            logic?: {
-                language: "typescript" | "javascript" | "python";
-            } | undefined;
-        };
-        error?: string | undefined;
-        data?: unknown;
-    }[];
-} | {
-    type: "nodeStart";
-    timestamp: Date;
-    taskId: string;
-    node: {
-        type: "service";
-        id: string;
-        service?: {
-            id: string;
-            name: string;
-            version: string;
-        } | undefined;
-        alias?: string | undefined;
-    } | {
-        type: "logic";
-        id: string;
-        alias?: string | undefined;
-        logic?: {
-            language: "typescript" | "javascript" | "python";
-        } | undefined;
-    };
-} | {
-    type: "nodeUpdate";
-    timestamp: Date;
-    taskId: string;
-    data?: unknown;
-} | {
-    type: "nodeError";
-    timestamp: Date;
-    taskId: string;
-    error: string;
-} | {
-    type: "nodeDefer";
-    timestamp: Date;
-    taskId: string;
-    reason?: string | undefined;
-} | {
-    type: "nodeEnd";
-    timestamp: Date;
-    taskId: string;
-    node: {
-        type: "service";
-        id: string;
-        service?: {
-            id: string;
-            name: string;
-            version: string;
-        } | undefined;
-        alias?: string | undefined;
-    } | {
-        type: "logic";
-        id: string;
-        alias?: string | undefined;
-        logic?: {
-            language: "typescript" | "javascript" | "python";
-        } | undefined;
-    };
-}> & {
-    getTaskId(): Promise<string> & {
-        resolve: (value: string | PromiseLike<string>) => void;
-        reject: (reason?: any) => void;
-        promise: Promise<string>;
-    };
+type TaskUpdateHandler<T> = (update: Update<T>) => void;
+export declare function createTask<T extends keyof RequenceTask.TaskTemplate | (string & {})>(options: CreateTaskOptions<T>, onUpdate?: TaskUpdateHandler<T>): Promise<Result<T>> & AsyncIterable<Update<T>> & {
+    getTaskId(): Promise<string>;
+    getTaskUrl(): Promise<string | null>;
+    abort(reason?: string): Promise<void>;
 };
 export {};
 //# sourceMappingURL=createTask.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"createTask.d.ts","sourceRoot":"","sources":["../../../../src/createTask.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,MAAM,EACX,KAAK,MAAM,EAEZ,MAAM,YAAY,CAAA;AAInB,qBAAa,SAAU,SAAQ,KAAK;aAGhB,YAAY,EAAE,MAAM;gBADpC,OAAO,EAAE,MAAM,EACC,YAAY,EAAE,MAAM;CAIvC;AAED,KAAK,iBAAiB,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;AAEjD,wBAAgB,UAAU,CACxB,CAAC,SAAS,MAAM,QAAQ,CAAC,YAAY,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,EACrD,OAAO,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,EAAE,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4K5D"}
+{"version":3,"file":"createTask.d.ts","sourceRoot":"","sources":["../../../../src/createTask.ts"],"names":[],"mappings":"AASA,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,MAAM,EACX,KAAK,MAAM,EAGZ,MAAM,YAAY,CAAA;AAGnB,qBAAa,SAAU,SAAQ,KAAK;aAGhB,YAAY,EAAE,MAAM;gBADpC,OAAO,EAAE,MAAM,EACC,YAAY,EAAE,MAAM;CAIvC;AAED,KAAK,iBAAiB,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,KAAK,IAAI,CAAA;AAEvD,wBAAgB,UAAU,CACxB,CAAC,SAAS,MAAM,YAAY,CAAC,YAAY,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,EACzD,OAAO,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,EAAE,iBAAiB,CAAC,CAAC,CAAC;;;mBAyPvC,MAAM;EAS9B"}

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

@@ -0,0 +1,22 @@
+interface GetTaskOptions {
+    accessToken?: string;
+    taskId: string;
+}
+export declare function getTask(taskIdOrOptions: string | GetTaskOptions): Promise<{
+    status: "successful" | "failed" | "idle" | "pending" | "running" | "stopped";
+    context: {
+        input: unknown;
+        taskId: string;
+        result: unknown;
+        getNodeData: <A extends string>(alias: A) => unknown;
+        getNodeError: (alias: string) => string | null;
+    } | {
+        input: unknown;
+        taskId: string;
+        result: unknown;
+        getNodeData: <A extends string>(alias: A) => unknown;
+        getNodeError: (alias: string) => string | null;
+    };
+}>;
+export {};
+//# sourceMappingURL=getTask.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getTask.d.ts","sourceRoot":"","sources":["../../../../src/getTask.ts"],"names":[],"mappings":"AAqBA,UAAU,cAAc;IACtB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,MAAM,EAAE,MAAM,CAAA;CACf;AAED,wBAAsB,OAAO,CAAC,eAAe,EAAE,MAAM,GAAG,cAAc;;;;;;;;;;;;;;;GA2CrE"}

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

@@ -1,3 +1,7 @@
 export { createTask } from './createTask.ts';
 export { watchTasks } from './watchTasks.ts';
+export { abortTask } from './abortTask.ts';
+export { getTask } from './getTask.ts';
+export { RequenceFile, RequenceStream } from '../../helpers/src/files/index.js';
+export { type RequenceCallback } from '../../helpers/src/index.js';
 //# sourceMappingURL=index.d.ts.map