run(event: WorkflowEvent<T>, step: WorkflowStep): Promise<T>
+ - `event` - the event passed to the Workflow, including an optional `payload` containing data (parameters)
+ - `step` - the `WorkflowStep` type that provides the step methods for your Workflow
+
+The `run` method can optionally return data, which is available when querying the instance status via the [Workers API](/workflows/build/workers-api/#instancestatus), [REST API](/api/resources/workflows/subresources/instances/subresources/status/) and the Workflows dashboard. This can be useful if your Workflow is computing a result, returning the key to data stored in object storage, or generating some kind of identifier you need to act on.
+
+```ts
+export class MyWorkflow extends WorkflowEntrypointstep.do(name: string, callback: (ctx: WorkflowStepContext): RpcSerializable): Promise<T>
+- step.do(name: string, callback: (ctx: WorkflowStepContext): RpcSerializable, rollbackOptions?: WorkflowStepRollbackOptions<T>): Promise<T>
+- step.do(name: string, config?: WorkflowStepConfig, callback: (ctx: WorkflowStepContext):
+ RpcSerializable): Promise<T>
+ - `name` - the name of the step, up to 256 characters.
+ - `config` (optional) - an optional `WorkflowStepConfig` for configuring [step specific retry behaviour](/workflows/build/sleeping-and-retrying/).
+ - `callback` - an asynchronous function that receives a [`WorkflowStepContext`](/workflows/build/step-context/) and optionally returns serializable state for the Workflow to persist. In JavaScript Workflows, this includes a fresh, unlocked `ReadableStreamstep.do(name: string, config?: WorkflowStepConfig, callback: (ctx: WorkflowStepContext):
+ RpcSerializable, rollbackOptions?: WorkflowStepRollbackOptions<T>): Promise<T>
+ - `name` - the name of the step, up to 256 characters.
+ - `config` (optional) - an optional `WorkflowStepConfig` for configuring [step specific retry behaviour](/workflows/build/sleeping-and-retrying/).
+ - `callback` - an asynchronous function that receives a [`WorkflowStepContext`](/workflows/build/step-context/) and optionally returns serializable state for the Workflow to persist. In JavaScript Workflows, this includes a fresh, unlocked `ReadableStreamstep.sleep(name: string, duration: WorkflowDuration): Promise<void>
+ - `name` - the name of the step.
+ - `duration` - the duration to sleep until, in either seconds or as a `WorkflowDuration` compatible string.
+ - Refer to the [documentation on sleeping and retrying](/workflows/build/sleeping-and-retrying/) to learn more about how Workflows are retried.
+
+- step.sleepUntil(name: string, timestamp: Date | number): Promise<void>
+ - `name` - the name of the step.
+ - `timestamp` - a JavaScript `Date` object or milliseconds from the Unix epoch to sleep the Workflow instance until.
+
+:::note
+
+`step.sleep` and `step.sleepUntil` methods do not count towards the maximum Workflow steps limit.
+
+More information about the limits imposed on Workflow can be found in the [Workflows limits documentation](/workflows/reference/limits/).
+
+:::
+
+- step.waitForEvent(name: string, options: ): Promise<void>-
+ `name` - the name of the step. - `options` - an object with properties for
+ `type` (up to 100 characters [^1]), which determines which event type this
+ `waitForEvent` call will match on when calling `instance.sendEvent`, and an
+ optional `timeout` property, which defines how long the `waitForEvent` call
+ will block for before throwing a timeout exception. The default timeout is 24
+ hours.
+
+throw new NonRetryableError(message: : create(options?: WorkflowInstanceCreateOptions): Promise<WorkflowInstance>
+ - `options` - optional properties to pass when creating an instance, including a user-provided ID and payload parameters.
+
+An ID is automatically generated, but a user-provided ID can be specified (up to 100 characters [^1]). This can be useful when mapping Workflows to users, merchants or other identifiers in your system. You can also provide a JSON object as the `params` property, allowing you to pass data for the Workflow instance to act on as its [`WorkflowEvent`](/workflows/build/events-and-parameters/).
+
+```ts
+// Create a new Workflow instance with your own ID and pass params to the Workflow instance
+let instance = await env.MY_WORKFLOW.create({
+ id: myIdDefinedFromOtherSystem,
+ params: { hello: "world" },
+});
+return Response.json({
+ id: instance.id,
+ details: await instance.status(),
+});
+```
+
+Returns a `WorkflowInstance`.
+
+Throws an error if the provided ID is already used by an existing instance that has not yet passed its [retention limit](/workflows/reference/limits/). To re-run a workflow with the same ID, you can [`restart`](/workflows/build/trigger-workflows/#restart-a-workflow) the existing instance.
+
+createBatch(batch: WorkflowInstanceCreateOptions[]): Promise<WorkflowInstance[]>
+ - `batch` - list of Options to pass when creating an instance, including a user-provided ID and payload parameters.
+
+Each element of the `batch` list is expected to include both `id` and `params` properties:
+
+```ts
+// Create a new batch of 3 Workflow instances, each with its own ID and pass params to the Workflow instances
+const listOfInstances = [
+ { id: "id-abc123", params: { hello: "world-0" } },
+ { id: "id-def456", params: { hello: "world-1" } },
+ { id: "id-ghi789", params: { hello: "world-2" } },
+];
+let instances = await env.MY_WORKFLOW.createBatch(listOfInstances);
+```
+
+Returns an array of `WorkflowInstance`.
+
+Unlike [`create`](/workflows/build/workers-api/#create), this operation is idempotent and will not fail if an ID is already in use. If an existing instance with the same ID is still within its [retention limit](/workflows/reference/limits/), it will be skipped and excluded from the returned array.
+
+### get
+
+Get a specific Workflow instance by ID.
+
+- get(id: string): Promise<WorkflowInstance>- `id` - the ID
+ of the Workflow instance.
+
+Returns a `WorkflowInstance`. Throws an exception if the instance ID does not exist.
+
+```ts
+// Fetch an existing Workflow instance by ID:
+try {
+ let instance = await env.MY_WORKFLOW.get(id);
+ return Response.json({
+ id: instance.id,
+ details: await instance.status(),
+ });
+} catch (e: any) {
+ // Handle errors
+ // .get will throw an exception if the ID doesn't exist or is invalid.
+ const msg = `failed to get instance ${id}: ${e.message}`;
+ console.error(msg);
+ return Response.json({ error: msg }, { status: 400 });
+}
+```
+
+## WorkflowInstanceCreateOptions
+
+Optional properties to pass when creating an instance.
+
+```ts
+interface WorkflowInstanceCreateOptions {
+ /**
+ * An id for your Workflow instance. Must be unique within the Workflow.
+ */
+ id?: string;
+ /**
+ * The event payload the Workflow instance is triggered with
+ */
+ params?: unknown;
+ /**
+ * The retention policy for the Workflow instance.
+ * Defaults to the maximum retention period available for the owner's account.
+ */
+ retention?: {
+ /**
+ * How long to retain instance state after the Workflow completes successfully.
+ */
+ successRetention?: WorkflowRetentionDuration;
+ /**
+ * How long to retain instance state after the Workflow ends in an errored or terminated state.
+ */
+ errorRetention?: WorkflowRetentionDuration;
+ };
+}
+
+type WorkflowRetentionDuration = WorkflowSleepDuration;
+```
+
+If `retention` is not set, instance state is retained for the maximum retention period available on your account (3 days on the Workers Free plan, 30 days on the Workers Paid plan). Refer to the [retention limit](/workflows/reference/limits/) for more information.
+
+The following example creates an instance that retains state for 1 day after success and 7 days after an error:
+
+```ts
+let instance = await env.MY_WORKFLOW.create({
+ id: myIdDefinedFromOtherSystem,
+ params: { hello: "world" },
+ retention: {
+ successRetention: "1 day",
+ errorRetention: "7 days",
+ },
+});
+```
+
+## WorkflowInstance
+
+Represents a specific instance of a Workflow, and provides methods to manage the instance.
+
+```ts
+declare abstract class WorkflowInstance {
+ public id: string;
+ /**
+ * Pause the instance.
+ */
+ public pause(): Promiseid: string
+
+### status
+
+Return the status of a running Workflow instance.
+
+- status(): Promise<InstanceStatus>
+
+### pause
+
+Pause a running Workflow instance.
+
+- pause(): Promise<void>
+
+### resume
+
+Resume a paused Workflow instance.
+
+- resume(): Promise<void>
+
+### restart
+
+Restart a Workflow instance from the beginning, or from a specific step.
+
+- restart(options?: WorkflowInstanceRestartOptions): Promise<void>
+ - `options` - optional properties that control from where the instance restarts.
+
+```ts
+let instance = await env.MY_WORKFLOW.get("abc-123");
+
+// Restart the instance from the beginning.
+await instance.restart();
+
+// Restart the instance from the step named "aggregate".
+await instance.restart({ from: { name: "aggregate" } });
+
+// Restart the instance from the third call to a step named "process".
+await instance.restart({ from: { name: "process", count: 3 } });
+```
+
+When restarting from a specific step, the cached results of every earlier step are reused, while the target step and any steps that follow it run again. The call throws an error if no step matching `from` is found in the instance's execution history.
+
+#### WorkflowInstanceRestartOptions
+
+```ts
+interface WorkflowInstanceRestartOptions {
+ /**
+ * The step to restart the instance from.
+ * If omitted, the instance restarts from the beginning.
+ */
+ from?: {
+ /**
+ * The name of the step.
+ */
+ name: string;
+ /**
+ * The 1-based index of the step, used when multiple steps share the same name and type. Defaults to 1 (the first occurrence).
+ */
+ count?: number;
+ /**
+ * The step type. Use this to disambiguate when the same name is shared across step types. Defaults to "do".
+ */
+ type?: "do" | "sleep" | "waitForEvent";
+ };
+}
+```
+
+The `from` object identifies the step to restart from. Only `name` is required; `count` and `type` are only needed when the same step name appears more than once in the run.
+
+- `name` - the name of the step.
+- `count` - the 1-based index of the step, used when multiple steps share the same name and type (for example, inside a loop). Defaults to `1` (the first occurrence). Corresponds to `step.count` in the [step context](/workflows/build/step-context/).
+- `type` - the step type (`"do"`, `"sleep"`, or `"waitForEvent"`). Defaults to `"do"`. Use this when the same name is shared across different step types.
+
+### terminate
+
+Terminate a Workflow instance.
+
+- terminate(options?: WorkflowInstanceTerminateOptions): Promise<void>
+ - `options` - optional properties that control how the instance is terminated.
+
+```ts
+let instance = await env.MY_WORKFLOW.get("abc-123");
+
+// Terminate without running rollback handlers.
+await instance.terminate();
+
+// Run registered rollback handlers before terminating.
+await instance.terminate({ rollback: true });
+```
+
+If `rollback` is `true`, Workflows runs the rollback handlers registered by completed or eligible steps before the instance reaches the `terminated` state. Steps without rollback handlers are skipped.
+
+#### WorkflowInstanceTerminateOptions
+
+```ts
+interface WorkflowInstanceTerminateOptions {
+ /**
+ * If true, run registered rollback handlers before terminating the instance.
+ */
+ rollback?: boolean;
+}
+```
+
+### sendEvent
+
+[Send an event](/workflows/build/events-and-parameters/) to a running Workflow instance.
+
+- sendEvent(): Promise<void>- `options` - the event `type`
+ (up to 100 characters [^1]) and `payload` to send to the Workflow instance.
+ The `type` must match the `type` in the corresponding `waitForEvent` call in
+ your Workflow.
+
+Return `void` on success; throws an exception if the Workflow is not running or is an errored state.
+
+getAlarm(): setAlarm(scheduledTimeMs : alarm(alarmInfo : This is the regular content everyone sees.
+ +