@hatchet-dev/typescript-sdk 0.20.2 → 1.0.0-alpha0

package/v1/client/worker.js

@@ -0,0 +1,125 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Worker = void 0;
+exports.toV0Workflow = toV0Workflow;
+const workflow_1 = require("../workflow");
+/**
+ * HatchetWorker class for workflow execution runtime
+ */
+class Worker {
+    /**
+     * Creates a new HatchetWorker instance
+     * @param v0 - The V0 worker implementation
+     */
+    constructor(v0) {
+        this.v0 = v0;
+    }
+    /**
+     * Creates and initializes a new HatchetWorker
+     * @param v0 - The HatchetClient instance
+     * @param options - Worker creation options
+     * @returns A new HatchetWorker instance
+     */
+    static create(v0, name, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const v0worker = yield v0.worker(name, Object.assign(Object.assign({}, options), { maxRuns: options.slots || options.maxRuns }));
+            const worker = new Worker(v0worker);
+            yield worker.registerWorkflows(options.workflows);
+            return worker;
+        });
+    }
+    /**
+     * Registers workflows with the worker
+     * @param workflows - Array of workflows to register
+     * @returns Array of registered workflow promises
+     */
+    registerWorkflows(workflows) {
+        return workflows === null || workflows === void 0 ? void 0 : workflows.map((wf) => {
+            return this.v0.registerWorkflow(toV0Workflow(wf));
+        });
+    }
+    /**
+     * Registers a single workflow with the worker
+     * @param workflow - The workflow to register
+     * @returns A promise that resolves when the workflow is registered
+     * @deprecated use registerWorkflows instead
+     */
+    registerWorkflow(workflow) {
+        return this.registerWorkflows([workflow]);
+    }
+    /**
+     * Starts the worker
+     * @returns Promise that resolves when the worker is stopped or killed
+     */
+    start() {
+        return this.v0.start();
+    }
+    /**
+     * Stops the worker
+     * @returns Promise that resolves when the worker stops
+     */
+    stop() {
+        return this.v0.stop();
+    }
+    /**
+     * Updates or inserts worker labels
+     * @param labels - Worker labels to update
+     * @returns Promise that resolves when labels are updated
+     */
+    upsertLabels(labels) {
+        return this.v0.upsertLabels(labels);
+    }
+    /**
+     * Get the labels for the worker
+     * @returns The labels for the worker
+     */
+    getLabels() {
+        return this.v0.labels;
+    }
+    /**
+     * Register a webhook with the worker
+     * @param webhook - The webhook to register
+     * @returns A promise that resolves when the webhook is registered
+     */
+    registerWebhook(webhook) {
+        return this.v0.registerWebhook(webhook);
+    }
+}
+exports.Worker = Worker;
+function toV0Workflow(wf) {
+    if (wf instanceof workflow_1.Workflow) {
+        const { definition } = wf;
+        return {
+            id: definition.name,
+            description: definition.description || '',
+            version: definition.version || '',
+            sticky: definition.sticky,
+            scheduleTimeout: definition.scheduleTimeout,
+            on: definition.on,
+            concurrency: definition.concurrency,
+            steps: definition.tasks.map((task) => {
+                var _a;
+                return ({
+                    name: task.name,
+                    parents: (_a = task.parents) === null || _a === void 0 ? void 0 : _a.map((p) => p.name),
+                    run: (ctx) => task.fn(ctx.workflowInput(), ctx),
+                    timeout: task.timeout,
+                    retries: task.retries,
+                    rate_limits: task.rateLimits,
+                    worker_labels: task.workerLabels,
+                    backoff: task.backoff,
+                });
+            }),
+        };
+    }
+    return wf;
+}

package/v1/examples/child_workflows/run.d.ts

@@ -0,0 +1 @@
+export {};

package/v1/examples/child_workflows/run.js

@@ -0,0 +1,30 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const res = yield workflow_1.parent.run({
+            N: 10,
+        });
+        // eslint-disable-next-line no-console
+        console.log(res.sum.Result);
+    });
+}
+if (require.main === module) {
+    main()
+        .then(() => process.exit(0))
+        .catch((error) => {
+        // eslint-disable-next-line no-console
+        console.error('Error:', error);
+        process.exit(1);
+    });
+}

package/v1/examples/child_workflows/worker.d.ts

@@ -0,0 +1 @@
+export {};

package/v1/examples/child_workflows/worker.js

@@ -0,0 +1,24 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("../client");
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield client_1.hatchet.worker('child-workflow-worker', {
+            workflows: [workflow_1.parent, workflow_1.child],
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}

package/v1/examples/child_workflows/workflow.d.ts

@@ -0,0 +1,19 @@
+type ChildInput = {
+    N: number;
+};
+type ChildOutput = {
+    value: {
+        Value: number;
+    };
+};
+export declare const child: import("../../workflow").Workflow<ChildInput, ChildOutput>;
+type ParentInput = {
+    N: number;
+};
+type ParentOutput = {
+    sum: {
+        Result: number;
+    };
+};
+export declare const parent: import("../../workflow").Workflow<ParentInput, ParentOutput>;
+export {};

package/v1/examples/child_workflows/workflow.js

@@ -0,0 +1,43 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parent = exports.child = void 0;
+const client_1 = require("../client");
+exports.child = client_1.hatchet.workflow({
+    name: 'child',
+});
+exports.child.task({
+    name: 'value',
+    fn: (input) => {
+        return {
+            Value: input.N,
+        };
+    },
+});
+exports.parent = client_1.hatchet.workflow({
+    name: 'parent',
+});
+exports.parent.task({
+    name: 'sum',
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const n = input.N;
+        const promises = [];
+        // eslint-disable-next-line no-plusplus
+        for (let i = 0; i < n; i++) {
+            promises.push(ctx.runChild(exports.child, { N: i }));
+        }
+        const childRes = yield Promise.all(promises);
+        const sum = childRes.reduce((acc, curr) => acc + curr.value.Value, 0);
+        return {
+            Result: sum,
+        };
+    }),
+});

package/v1/examples/client.d.ts

@@ -0,0 +1,2 @@
+import { HatchetClient } from '../client/client';
+export declare const hatchet: HatchetClient;

package/v1/examples/client.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hatchet = void 0;
+const client_1 = require("../client/client");
+exports.hatchet = client_1.HatchetClient.init();

package/v1/examples/concurrency-rr/load.d.ts

@@ -0,0 +1 @@
+export {};

package/v1/examples/concurrency-rr/load.js

@@ -0,0 +1,54 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-plusplus */
+const client_1 = require("../client");
+const workflow_1 = require("./workflow");
+function generateRandomString(length) {
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+        result += characters.charAt(Math.floor(Math.random() * characters.length));
+    }
+    return result;
+}
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const groupCount = 2;
+        const runsPerGroup = 20000;
+        const BATCH_SIZE = 400;
+        const workflowRuns = [];
+        for (let i = 0; i < groupCount; i++) {
+            for (let j = 0; j < runsPerGroup; j++) {
+                workflowRuns.push({
+                    workflowName: workflow_1.simpleConcurrency.definition.name,
+                    input: {
+                        Message: generateRandomString(10),
+                        GroupKey: `group-${i}`,
+                    },
+                });
+            }
+        }
+        // Shuffle the workflow runs array
+        for (let i = workflowRuns.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [workflowRuns[i], workflowRuns[j]] = [workflowRuns[j], workflowRuns[i]];
+        }
+        // Process workflows in batches
+        for (let i = 0; i < workflowRuns.length; i += BATCH_SIZE) {
+            const batch = workflowRuns.slice(i, i + BATCH_SIZE);
+            yield client_1.hatchet.admin.runWorkflows(batch);
+        }
+    });
+}
+if (require.main === module) {
+    main().then(() => process.exit(0));
+}

package/v1/examples/concurrency-rr/run.d.ts

@@ -0,0 +1 @@
+export {};

package/v1/examples/concurrency-rr/run.js

@@ -0,0 +1,39 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const res = yield workflow_1.simpleConcurrency.run([
+            {
+                Message: 'Hello World',
+                GroupKey: 'A',
+            },
+            {
+                Message: 'Goodbye Moon',
+                GroupKey: 'A',
+            },
+            {
+                Message: 'Hello World B',
+                GroupKey: 'B',
+            },
+        ]);
+        // eslint-disable-next-line no-console
+        console.log(res[0]['to-lower'].TransformedMessage);
+        // eslint-disable-next-line no-console
+        console.log(res[1]['to-lower'].TransformedMessage);
+        // eslint-disable-next-line no-console
+        console.log(res[2]['to-lower'].TransformedMessage);
+    });
+}
+if (require.main === module) {
+    main().then(() => process.exit(0));
+}

package/v1/examples/concurrency-rr/worker.d.ts

@@ -0,0 +1 @@
+export {};

package/v1/examples/concurrency-rr/worker.js

@@ -0,0 +1,24 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("../client");
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield client_1.hatchet.worker('simple-concurrency-worker', {
+            workflows: [workflow_1.simpleConcurrency],
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}

package/v1/examples/concurrency-rr/workflow.d.ts

@@ -0,0 +1,11 @@
+type SimpleInput = {
+    Message: string;
+    GroupKey: string;
+};
+type SimpleOutput = {
+    'to-lower': {
+        TransformedMessage: string;
+    };
+};
+export declare const simpleConcurrency: import("../../workflow").Workflow<SimpleInput, SimpleOutput>;
+export {};

package/v1/examples/concurrency-rr/workflow.js

@@ -0,0 +1,35 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simpleConcurrency = void 0;
+const workflow_1 = require("../../../workflow");
+const client_1 = require("../client");
+const sleep = (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+});
+exports.simpleConcurrency = client_1.hatchet.workflow({
+    name: 'simple-concurrency',
+    concurrency: {
+        name: 'simple-concurrency',
+        maxRuns: 100,
+        limitStrategy: workflow_1.ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
+        expression: 'input.GroupKey',
+    },
+});
+exports.simpleConcurrency.task({
+    name: 'to-lower',
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        yield sleep(Math.floor(Math.random() * (1000 - 200 + 1)) + 200);
+        return {
+            TransformedMessage: input.Message.toLowerCase(),
+        };
+    }),
+});

package/v1/examples/dag/run.d.ts

@@ -0,0 +1 @@
+export {};

package/v1/examples/dag/run.js

@@ -0,0 +1,24 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const res = yield workflow_1.dag.run({
+            Message: 'hello world',
+        });
+        // eslint-disable-next-line no-console
+        console.log(res.reverse.Transformed);
+    });
+}
+if (require.main === module) {
+    main();
+}

package/v1/examples/dag/worker.d.ts

@@ -0,0 +1 @@
+export {};

package/v1/examples/dag/worker.js

@@ -0,0 +1,24 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("../client");
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield client_1.hatchet.worker('dag-worker', {
+            workflows: [workflow_1.dag],
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}

package/v1/examples/dag/workflow.d.ts

@@ -0,0 +1,11 @@
+type DagInput = {
+    Message: string;
+};
+type DagOutput = {
+    reverse: {
+        Original: string;
+        Transformed: string;
+    };
+};
+export declare const dag: import("../../workflow").Workflow<DagInput, DagOutput>;
+export {};

package/v1/examples/dag/workflow.js

@@ -0,0 +1,35 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dag = void 0;
+const client_1 = require("../client");
+exports.dag = client_1.hatchet.workflow({
+    name: 'simple',
+});
+const toLower = exports.dag.task({
+    name: 'to-lower',
+    fn: (input) => {
+        return {
+            TransformedMessage: input.Message.toLowerCase(),
+        };
+    },
+});
+exports.dag.task({
+    name: 'reverse',
+    parents: [toLower],
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const lower = yield ctx.parentData(toLower);
+        return {
+            Original: input.Message,
+            Transformed: lower.TransformedMessage.split('').reverse().join(''),
+        };
+    }),
+});

package/v1/examples/deep/run.d.ts

@@ -0,0 +1 @@
+export {};

package/v1/examples/deep/run.js

@@ -0,0 +1,28 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const res = yield workflow_1.parent.run({
+            Message: 'hello',
+            N: 5,
+        });
+        // eslint-disable-next-line no-console
+        console.log(res.parent.Sum);
+    });
+}
+if (require.main === module) {
+    main()
+        // eslint-disable-next-line no-console
+        .catch(console.error)
+        .finally(() => process.exit(0));
+}

package/v1/examples/deep/worker.d.ts

@@ -0,0 +1 @@
+export {};

package/v1/examples/deep/worker.js

@@ -0,0 +1,25 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("../client");
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield client_1.hatchet.worker('simple-worker', {
+            workflows: [workflow_1.parent, workflow_1.child1, workflow_1.child2, workflow_1.child3, workflow_1.child4, workflow_1.child5],
+            slots: 5000,
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}

package/v1/examples/deep/workflow.d.ts

@@ -0,0 +1,18 @@
+type SimpleInput = {
+    Message: string;
+    N: number;
+};
+type Output = {
+    transformer: {
+        Sum: number;
+    };
+};
+export declare const child1: import("../../workflow").Workflow<SimpleInput, Output>;
+export declare const child2: import("../../workflow").Workflow<SimpleInput, Output>;
+export declare const child3: import("../../workflow").Workflow<SimpleInput, Output>;
+export declare const child4: import("../../workflow").Workflow<SimpleInput, Output>;
+export declare const child5: import("../../workflow").Workflow<SimpleInput, Output>;
+export declare const parent: import("../../workflow").Workflow<SimpleInput, {
+    parent: Output["transformer"];
+}>;
+export {};