@hatchet-dev/typescript-sdk 0.16.0-alpha.4 → 0.17.0

package/clients/worker/worker.js

@@ -27,7 +27,6 @@ const workflows_1 = require("../../protoc/workflows");
 const logger_1 = require("../../util/logger");
 const handler_1 = require("./handler");
 const step_1 = require("../../step");
-const managed_compute_1 = require("./compute/managed-compute");
 class Worker {
     constructor(client, options) {
         this.workflow_registry = [];
@@ -49,33 +48,18 @@ class Worker {
     registerActions(workflow) {
         var _a;
         const newActions = workflow.steps.reduce((acc, step) => {
-            // Only register actions that are in the runnable_actions list
-            if (!this.client.config.runnable_actions ||
-                this.client.config.runnable_actions.includes(`${workflow.id}:${step.name}`)) {
-                acc[`${workflow.id}:${step.name}`] = {
-                    func: step.run,
-                    compute: step.compute,
-                };
-            }
+            acc[`${workflow.id}:${step.name}`] = step.run;
             return acc;
         }, {});
         const onFailureAction = workflow.onFailure
             ? {
-                [`${workflow.id}-on-failure:${workflow.onFailure.name}`]: {
-                    func: workflow.onFailure.run,
-                    compute: workflow.onFailure.compute,
-                },
-            }
-            : {};
-        const concurrencyAction = ((_a = workflow.concurrency) === null || _a === void 0 ? void 0 : _a.name) && workflow.concurrency.key
-            ? {
-                [`${workflow.id}:${workflow.concurrency.name}`]: {
-                    func: workflow.concurrency.key,
-                    compute: undefined,
-                },
+                [`${workflow.id}-on-failure:${workflow.onFailure.name}`]: workflow.onFailure.run,
             }
             : {};
-        this.action_registry = Object.assign(Object.assign(Object.assign(Object.assign({}, this.action_registry), newActions), onFailureAction), concurrencyAction);
+        this.action_registry = Object.assign(Object.assign(Object.assign({}, this.action_registry), newActions), onFailureAction);
+        this.action_registry =
+            ((_a = workflow.concurrency) === null || _a === void 0 ? void 0 : _a.name) && workflow.concurrency.key
+                ? Object.assign(Object.assign({}, this.action_registry), { [`${workflow.id}:${workflow.concurrency.name}`]: workflow.concurrency.key }) : Object.assign({}, this.action_registry);
     }
     getHandler(workflows) {
         for (const workflow of workflows) {
@@ -152,7 +136,7 @@ class Worker {
                             name: workflow.id,
                             description: workflow.description,
                             steps: workflow.steps.map((step) => {
-                                var _a;
+                                var _a, _b, _c;
                                 return ({
                                     readableId: step.name,
                                     action: `${workflow.id}:${step.name}`,
@@ -163,6 +147,8 @@ class Worker {
                                     retries: step.retries || 0,
                                     rateLimits: (0, step_1.mapRateLimit)(step.rate_limits),
                                     workerLabels: toPbWorkerLabel(step.worker_labels),
+                                    backoffFactor: (_b = step.backoff) === null || _b === void 0 ? void 0 : _b.factor,
+                                    backoffMaxSeconds: (_c = step.backoff) === null || _c === void 0 ? void 0 : _c.maxSeconds,
                                 });
                             }),
                         },
@@ -178,11 +164,8 @@ class Worker {
             this.registerActions(workflow);
         });
     }
-    registerAction(actionId, action, compute) {
-        this.action_registry[actionId] = {
-            func: action,
-            compute,
-        };
+    registerAction(actionId, action) {
+        this.action_registry[actionId] = action;
     }
     handleStartStepRun(action) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -196,7 +179,7 @@ class Worker {
                     return;
                 }
                 const run = () => __awaiter(this, void 0, void 0, function* () {
-                    return step.func(context);
+                    return step(context);
                 });
                 const success = (result) => __awaiter(this, void 0, void 0, function* () {
                     this.logger.info(`Step run ${action.stepRunId} succeeded`);
@@ -208,16 +191,16 @@ class Worker {
                         delete this.futures[action.stepRunId];
                     }
                     catch (actionEventError) {
-                        this.logger.error(`Could not send completed action event: ${actionEventError.message}`);
+                        this.logger.error(`Could not send completed action event: ${actionEventError.message || actionEventError}`);
                         // send a failure event
                         const failureEvent = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_FAILED, actionEventError.message);
                         try {
                             yield this.client.dispatcher.sendStepActionEvent(failureEvent);
                         }
                         catch (failureEventError) {
-                            this.logger.error(`Could not send failed action event: ${failureEventError.message}`);
+                            this.logger.error(`Could not send failed action event: ${failureEventError.message || failureEventError}`);
                         }
-                        this.logger.error(`Could not send action event: ${actionEventError.message}`);
+                        this.logger.error(`Could not send action event: ${actionEventError.message || actionEventError}`);
                     }
                 });
                 const failure = (error) => __awaiter(this, void 0, void 0, function* () {
@@ -256,10 +239,15 @@ class Worker {
                 this.client.dispatcher.sendStepActionEvent(event).catch((e) => {
                     this.logger.error(`Could not send action event: ${e.message}`);
                 });
-                yield future.promise;
+                try {
+                    yield future.promise;
+                }
+                catch (e) {
+                    this.logger.error(`Could not wait for step run to finish: ${e}`);
+                }
             }
             catch (e) {
-                this.logger.error(`Could not send action event: ${e.message}`);
+                this.logger.error(`Could not send action event (outer): ${e}`);
             }
         });
     }
@@ -281,7 +269,7 @@ class Worker {
                     return;
                 }
                 const run = () => __awaiter(this, void 0, void 0, function* () {
-                    return step.func(context);
+                    return step(context);
                 });
                 const success = (result) => {
                     this.logger.info(`Step run ${action.stepRunId} succeeded`);
@@ -375,7 +363,7 @@ class Worker {
                 }
             }
             catch (e) {
-                this.logger.error(`Could not cancel step run: ${e.message}`);
+                this.logger.error(`Could not cancel step run: ${e}`);
             }
         });
     }
@@ -410,8 +398,6 @@ class Worker {
             var _a, e_1, _b, _c;
             // ensure all workflows are registered
             yield Promise.all(this.registeredWorkflowPromises);
-            const managedCompute = new managed_compute_1.ManagedCompute(this.action_registry, this.client, this.maxRuns);
-            yield managedCompute.cloudRegister();
             try {
                 this.listener = yield this.client.dispatcher.getActionListener({
                     workerName: this.name,

package/examples/crons/cron-worker.d.ts

@@ -0,0 +1,2 @@
+import { Workflow } from '../../workflow';
+export declare const simpleCronWorkflow: Workflow;

package/examples/crons/cron-worker.js

@@ -0,0 +1,48 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simpleCronWorkflow = void 0;
+const sdk_1 = __importDefault(require("../../sdk"));
+const hatchet = sdk_1.default.init();
+// ❓ Workflow Definition Cron Trigger
+// Adding a cron trigger to a workflow is as simple as adding a `cron expression` to the `on` prop of the workflow definition
+exports.simpleCronWorkflow = {
+    id: 'simple-cron-workflow',
+    on: {
+        // 👀 define the cron expression to run every minute
+        cron: '* * * * *',
+    },
+    // ... normal workflow definition
+    description: 'return the current time every minute',
+    steps: [
+        {
+            name: 'what-time-is-it',
+            run: (ctx) => {
+                return { time: new Date().toISOString() };
+            },
+        },
+    ],
+    // ,
+};
+// ‼️
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield hatchet.worker('example-worker');
+        yield worker.registerWorkflow(exports.simpleCronWorkflow);
+        worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}

package/examples/crons/programatic-crons.js

@@ -0,0 +1,55 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sdk_1 = __importDefault(require("../../sdk"));
+const cron_worker_1 = require("./cron-worker");
+const hatchet = sdk_1.default.init();
+// This example assumes you have a worker already running
+// and registered the cron workflow to it
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // ? Create
+        // You can create dynamic cron triggers programmatically via the API
+        const createdCron = yield hatchet.cron.create(cron_worker_1.simpleCronWorkflow, // workflow object or string workflow id
+        {
+            name: 'customer-a-daily-report', // friendly name for the cron trigger
+            expression: '0 12 * * *', // every day at noon
+            input: {
+                name: 'John Doe',
+            },
+            additionalMetadata: {
+                customerId: '123',
+            },
+        });
+        const { id } = createdCron.metadata; // id which you can later use to reference the cron trigger
+        // !!
+        // ? Get
+        // You can get a specific cron trigger by passing in the cron trigger id
+        const cron = yield hatchet.cron.get(id);
+        // !!
+        // ? Delete
+        // You can delete a cron trigger by passing the cron object
+        // or a cron Id to the delete method
+        yield hatchet.cron.delete(cron);
+        // !!
+        // ? List
+        // You can list all cron triggers by passing in a query object
+        const cronList = yield hatchet.cron.list({
+            offset: 0,
+            limit: 10,
+        });
+        // !!
+    });
+}
+main();

package/examples/on-failure.js

@@ -13,36 +13,41 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const sdk_1 = __importDefault(require("../sdk"));
-const hatchet = sdk_1.default.init({
-    log_level: 'OFF',
-});
-const sleep = (ms) => new Promise((resolve) => {
-    setTimeout(resolve, ms);
-});
+const hatchet = sdk_1.default.init();
+// ❓ OnFailure Step
+// This workflow will fail because the step will throw an error
+// we define an onFailure step to handle this case
 const workflow = {
+    // ... normal workflow definition
     id: 'on-failure-example',
     description: 'test',
     on: {
         event: 'user:create',
     },
+    // ,
     steps: [
         {
-            name: 'dag-step1',
+            name: 'step1',
             run: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-                console.log('Starting Step 1!');
-                yield sleep(1000);
+                // 👀 this step will always throw an error
                 throw new Error('Step 1 failed');
             }),
         },
     ],
+    // 👀 After the workflow fails, this special step will run
     onFailure: {
         name: 'on-failure-step',
         run: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-            console.log('Starting On Failure Step!');
+            // 👀 we can do things like perform cleanup logic
+            // or notify a user here
             return { onFailure: 'step' };
         }),
     },
 };
+// ‼️
+// ❓ OnFailure With Details
+// Coming soon to TypeScript! https://github.com/hatchet-dev/hatchet-typescript/issues/447
+// ‼️
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
         const worker = yield hatchet.worker('example-worker', 1);

package/examples/retries-with-backoff.d.ts

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

package/examples/{managed-worker.js → retries-with-backoff.js}

@@ -12,52 +12,43 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const data_contracts_1 = require("../clients/rest/generated/cloud/data-contracts");
 const sdk_1 = __importDefault(require("../sdk"));
 const hatchet = sdk_1.default.init();
-const oneCpuWorkerConfig = {
-    cpuKind: 'shared',
-    memoryMb: 1024,
-    numReplicas: 1,
-    cpus: 1,
-    regions: [data_contracts_1.ManagedWorkerRegion.Ewr],
-};
-const twoCpuWorkerConfig = {
-    cpuKind: 'shared',
-    memoryMb: 1024,
-    numReplicas: 1,
-    cpus: 2,
-    regions: [data_contracts_1.ManagedWorkerRegion.Ewr],
-};
+let numRetries = 0;
+// ❓ Backoff
 const workflow = {
-    id: 'simple-workflow',
-    description: 'test',
-    on: {
-        event: 'user:create',
-    },
+    // ... normal workflow definition
+    id: 'retries-with-backoff',
+    description: 'Backoff',
+    // ,
     steps: [
         {
-            name: 'step1',
-            compute: oneCpuWorkerConfig,
+            name: 'backoff-step',
+            // ... step definition
             run: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-                console.log('executed step1!');
-                return { step1: 'step1 results!' };
+                if (numRetries < 5) {
+                    numRetries += 1;
+                    throw new Error('failed');
+                }
+                return { backoff: 'completed' };
             }),
-        },
-        {
-            name: 'step2',
-            parents: ['step1'],
-            compute: twoCpuWorkerConfig,
-            run: (ctx) => {
-                console.log('executed step2 after step1 returned ', ctx.stepOutput('step1'));
-                return { step2: 'step2 results!' };
+            // ,
+            retries: 10,
+            // 👀 Backoff configuration
+            backoff: {
+                // 👀 Maximum number of seconds to wait between retries
+                maxSeconds: 60,
+                // 👀 Factor to increase the wait time between retries.
+                // This sequence will be 2s, 4s, 8s, 16s, 32s, 60s... due to the maxSeconds limit
+                factor: 2,
             },
         },
     ],
 };
+// ‼️
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
-        const worker = yield hatchet.worker('managed-worker');
+        const worker = yield hatchet.worker('backoff-worker');
         yield worker.registerWorkflow(workflow);
         worker.start();
     });

package/examples/scheduled-runs/programatic-schedules.d.ts

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

package/examples/scheduled-runs/programatic-schedules.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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sdk_1 = __importDefault(require("../../sdk"));
+const simple_worker_1 = require("../simple-worker");
+const hatchet = sdk_1.default.init();
+// This example assumes you have a worker already running
+// and registered simpleWorkflow to it
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // ? Create
+        // You can create dynamic scheduled runs programmatically via the API
+        const createdScheduledRun = yield hatchet.schedule.create(simple_worker_1.simpleWorkflow, // workflow object or string workflow id
+        {
+            triggerAt: new Date(Date.now() + 1000 * 60 * 60 * 24), // 24 hours from now
+            input: {
+                name: 'John Doe',
+            },
+            additionalMetadata: {
+                customerId: '123',
+            },
+        });
+        const { id } = createdScheduledRun.metadata; // id which you can later use to reference the scheduled run
+        // !!
+        // ? Get
+        // You can get a specific scheduled run by passing in the scheduled run id
+        const scheduledRun = yield hatchet.schedule.get(id);
+        // !!
+        // ? Delete
+        // You can delete a scheduled run by passing the scheduled run object
+        // or a scheduled run Id to the delete method
+        yield hatchet.schedule.delete(scheduledRun);
+        // !!
+        // ? List
+        // You can list all scheduled runs by passing in a query object
+        const scheduledRunList = yield hatchet.schedule.list({
+            offset: 0,
+            limit: 10,
+        });
+        // !!
+    });
+}
+main();

package/examples/simple-worker.d.ts

@@ -1 +1,2 @@
-export {};
+import { Workflow } from '../workflow';
+export declare const simpleWorkflow: Workflow;

package/examples/simple-worker.js

@@ -12,12 +12,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.simpleWorkflow = void 0;
 const sdk_1 = __importDefault(require("../sdk"));
 const hatchet = sdk_1.default.init();
 const sleep = (ms) => new Promise((resolve) => {
     setTimeout(resolve, ms);
 });
-const workflow = {
+exports.simpleWorkflow = {
     id: 'simple-workflow',
     description: 'test',
     on: {
@@ -48,8 +49,10 @@ const workflow = {
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
         const worker = yield hatchet.worker('example-worker');
-        yield worker.registerWorkflow(workflow);
+        yield worker.registerWorkflow(exports.simpleWorkflow);
         worker.start();
     });
 }
-main();
+if (require.main === module) {
+    main();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "0.16.0-alpha.4",
+  "version": "0.17.0",
   "description": "Background task orchestration & visibility for developers",
   "types": "dist/index.d.ts",
   "files": [
@@ -17,13 +17,13 @@
   "scripts": {
     "build": "echo 'build hatchet sdk with `npn run tsc:build` to ensure it is not build during the publish step' && exit 0",
     "prepare": "npm run build",
-    "tsc:build": "tsc && resolve-tspaths",
+    "dump-version": "node -e \"console.log('export const HATCHET_VERSION = \\'' + require('./package.json').version + '\\';');\" > src/version.ts",
+    "tsc:build": "npm run dump-version && tsc && resolve-tspaths",
     "test:unit": "jest --testMatch='**/*.test.ts'",
     "test:e2e": "jest --testMatch='**/*.e2e.ts'",
     "test:unit:watch": "jest --testMatch='**/*.test.ts' --watch",
     "generate": "pnpm run '/generate-.*/'",
-    "generate-api": "npx --yes swagger-cli bundle ./hatchet/api-contracts/openapi/openapi.yaml --outfile openapi.yaml --type yaml && npx swagger-typescript-api -p openapi.yaml -o src/clients/rest/generated -n hatchet.ts --modular --axios",
-    "generate-cloud-api": "npx --yes swagger-cli bundle ./hatchet-cloud/api-contracts/openapi/openapi.yaml --outfile openapi.yaml --type yaml && npx swagger-typescript-api -p openapi.yaml -o src/clients/rest/generated/cloud -n hatchet.ts --modular --axios",
+    "generate-api": "npx --yes swagger-cli bundle ../oss/api-contracts/openapi/openapi.yaml --outfile openapi.yaml --type yaml && npx swagger-typescript-api -p openapi.yaml -o src/clients/rest/generated -n hatchet.ts --modular --axios",
     "generate-protoc": "./generate-protoc.sh",
     "lint:check": "npm run eslint:check && npm run prettier:check",
     "lint:fix": "npm run eslint:fix && npm run prettier:fix",
@@ -39,7 +39,6 @@
     "example:rate": "npm run exec -- ./src/examples/rate-limit/events.ts",
     "worker:fanout": "npm run exec -- ./src/examples/fanout-worker.ts",
     "worker:simple": "npm run exec -- ./src/examples/simple-worker.ts",
-    "worker:managed": "npm run exec -- ./src/examples/managed-worker.ts",
     "worker:affinity": "npm run exec -- ./src/examples/affinity-workers.ts",
     "worker:sticky": "npm run exec -- ./src/examples/sticky-worker.ts",
     "worker:on-failure": "npm run exec -- ./src/examples/on-failure.ts",
@@ -55,12 +54,13 @@
     "event:concurrency:rr": "npm run exec -- ./src/examples/concurrency/group-round-robin/concurrency-event.ts",
     "worker:playground": "npm run exec -- ./src/examples/playground.ts",
     "worker:retries": "npm run exec -- ./src/examples/retries-worker.ts",
+    "worker:retries-with-backoff": "npm run exec -- ./src/examples/retries-with-backoff.ts",
     "worker:multi-workflow": "npm run exec -- ./src/examples/multi-workflow.ts",
     "worker:logger": "npm run exec -- ./src/examples/logger.ts",
     "api": "npm run exec -- ./src/examples/api.ts",
     "prepublish": "cp package.json dist/package.json;",
-    "publish:ci": "rm -rf ./dist && npm run tsc:build && npm run prepublish && cd dist && npm publish --access public --no-git-checks",
-    "publish:ci:alpha": "rm -rf ./dist && npm run tsc:build && npm run prepublish && cd dist && npm publish --access public --no-git-checks --tag alpha",
+    "publish:ci": "rm -rf ./dist && npm run dump-version && npm run tsc:build && npm run prepublish && cd dist && npm publish --access public --no-git-checks",
+    "publish:ci:alpha": "rm -rf ./dist && npm run dump-version && npm run tsc:build && npm run prepublish && cd dist && npm publish --access public --no-git-checks --tag alpha",
     "generate-docs": "typedoc"
   },
   "keywords": [],
@@ -93,7 +93,7 @@
     "ts-jest": "^29.1.1",
     "ts-node": "^10.9.2",
     "ts-proto": "^2.0.2",
-    "typedoc": "^0.26.2",
+    "typedoc": "^0.27.1",
     "typedoc-plugin-markdown": "^4.0.2",
     "typescript": "^5.3.3"
   },

package/protoc/dispatcher/dispatcher.js

@@ -1,7 +1,7 @@
 "use strict";
 // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
 // versions:
-//   protoc-gen-ts_proto  v2.2.4
+//   protoc-gen-ts_proto  v2.5.0
 //   protoc               v3.19.1
 // source: dispatcher/dispatcher.proto
 Object.defineProperty(exports, "__esModule", { value: true });

package/protoc/events/events.js

@@ -1,7 +1,7 @@
 "use strict";
 // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
 // versions:
-//   protoc-gen-ts_proto  v2.2.4
+//   protoc-gen-ts_proto  v2.5.0
 //   protoc               v3.19.1
 // source: events/events.proto
 Object.defineProperty(exports, "__esModule", { value: true });

package/protoc/google/protobuf/timestamp.js

@@ -1,7 +1,7 @@
 "use strict";
 // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
 // versions:
-//   protoc-gen-ts_proto  v2.2.4
+//   protoc-gen-ts_proto  v2.5.0
 //   protoc               v3.19.1
 // source: google/protobuf/timestamp.proto
 Object.defineProperty(exports, "__esModule", { value: true });

package/protoc/google/protobuf/wrappers.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BytesValue = exports.StringValue = exports.BoolValue = exports.UInt32Value = exports.Int32Value = exports.UInt64Value = exports.Int64Value = exports.FloatValue = exports.DoubleValue = exports.protobufPackage = void 0;
 /* eslint-disable */

package/protoc/workflows/workflows.d.ts

@@ -145,6 +145,10 @@ export interface CreateWorkflowStepOpts {
     workerLabels: {
         [key: string]: DesiredWorkerLabels;
     };
+    /** (optional) the retry backoff factor for the step */
+    backoffFactor?: number | undefined;
+    /** (optional) the maximum backoff time for the step */
+    backoffMaxSeconds?: number | undefined;
 }
 export interface CreateWorkflowStepOpts_WorkerLabelsEntry {
     key: string;
@@ -186,6 +190,13 @@ export interface ScheduleWorkflowRequest {
      * child key will be a no-op, even if the schedule has changed.
      */
     childKey?: string | undefined;
+    /** (optional) the additional metadata for the workflow */
+    additionalMetadata?: string | undefined;
+}
+/** ScheduledWorkflow represents a scheduled workflow. */
+export interface ScheduledWorkflow {
+    id: string;
+    triggerAt: Date | undefined;
 }
 /** WorkflowVersion represents the WorkflowVersion model. */
 export interface WorkflowVersion {
@@ -195,6 +206,7 @@ export interface WorkflowVersion {
     version: string;
     order: number;
     workflowId: string;
+    scheduledWorkflows: ScheduledWorkflow[];
 }
 /** WorkflowTriggerEventRef represents the WorkflowTriggerEventRef model. */
 export interface WorkflowTriggerEventRef {
@@ -265,6 +277,7 @@ export declare const CreateWorkflowStepOpts_WorkerLabelsEntry: MessageFns<Create
 export declare const CreateStepRateLimit: MessageFns<CreateStepRateLimit>;
 export declare const ListWorkflowsRequest: MessageFns<ListWorkflowsRequest>;
 export declare const ScheduleWorkflowRequest: MessageFns<ScheduleWorkflowRequest>;
+export declare const ScheduledWorkflow: MessageFns<ScheduledWorkflow>;
 export declare const WorkflowVersion: MessageFns<WorkflowVersion>;
 export declare const WorkflowTriggerEventRef: MessageFns<WorkflowTriggerEventRef>;
 export declare const WorkflowTriggerCronRef: MessageFns<WorkflowTriggerCronRef>;