@trigger.dev/core 3.0.0-beta.5 → 3.0.0-beta.50

package/dist/v3/schemas/index.js

@@ -0,0 +1,2039 @@
+'use strict';
+
+var zod = require('zod');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var CreateAuthorizationCodeResponseSchema = zod.z.object({
+  url: zod.z.string().url(),
+  authorizationCode: zod.z.string()
+});
+var GetPersonalAccessTokenRequestSchema = zod.z.object({
+  authorizationCode: zod.z.string()
+});
+var GetPersonalAccessTokenResponseSchema = zod.z.object({
+  token: zod.z.object({
+    token: zod.z.string(),
+    obfuscatedToken: zod.z.string()
+  }).nullable()
+});
+var MachineCpu = zod.z.union([
+  zod.z.literal(0.25),
+  zod.z.literal(0.5),
+  zod.z.literal(1),
+  zod.z.literal(2),
+  zod.z.literal(4)
+]);
+var MachineMemory = zod.z.union([
+  zod.z.literal(0.25),
+  zod.z.literal(0.5),
+  zod.z.literal(1),
+  zod.z.literal(2),
+  zod.z.literal(4),
+  zod.z.literal(8)
+]);
+var MachinePresetName = zod.z.enum([
+  "micro",
+  "small-1x",
+  "small-2x",
+  "medium-1x",
+  "medium-2x",
+  "large-1x",
+  "large-2x"
+]);
+var MachineConfig = zod.z.object({
+  cpu: MachineCpu.optional(),
+  memory: MachineMemory.optional(),
+  preset: MachinePresetName.optional()
+});
+var MachinePreset = zod.z.object({
+  name: MachinePresetName,
+  cpu: zod.z.number(),
+  memory: zod.z.number(),
+  centsPerMs: zod.z.number()
+});
+var TaskRunBuiltInError = zod.z.object({
+  type: zod.z.literal("BUILT_IN_ERROR"),
+  name: zod.z.string(),
+  message: zod.z.string(),
+  stackTrace: zod.z.string()
+});
+var TaskRunCustomErrorObject = zod.z.object({
+  type: zod.z.literal("CUSTOM_ERROR"),
+  raw: zod.z.string()
+});
+var TaskRunStringError = zod.z.object({
+  type: zod.z.literal("STRING_ERROR"),
+  raw: zod.z.string()
+});
+var TaskRunErrorCodes = {
+  COULD_NOT_FIND_EXECUTOR: "COULD_NOT_FIND_EXECUTOR",
+  COULD_NOT_FIND_TASK: "COULD_NOT_FIND_TASK",
+  CONFIGURED_INCORRECTLY: "CONFIGURED_INCORRECTLY",
+  TASK_ALREADY_RUNNING: "TASK_ALREADY_RUNNING",
+  TASK_EXECUTION_FAILED: "TASK_EXECUTION_FAILED",
+  TASK_EXECUTION_ABORTED: "TASK_EXECUTION_ABORTED",
+  TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE: "TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE",
+  TASK_PROCESS_SIGKILL_TIMEOUT: "TASK_PROCESS_SIGKILL_TIMEOUT",
+  TASK_RUN_CANCELLED: "TASK_RUN_CANCELLED",
+  TASK_OUTPUT_ERROR: "TASK_OUTPUT_ERROR",
+  HANDLE_ERROR_ERROR: "HANDLE_ERROR_ERROR",
+  GRACEFUL_EXIT_TIMEOUT: "GRACEFUL_EXIT_TIMEOUT"
+};
+var TaskRunInternalError = zod.z.object({
+  type: zod.z.literal("INTERNAL_ERROR"),
+  code: zod.z.enum([
+    "COULD_NOT_FIND_EXECUTOR",
+    "COULD_NOT_FIND_TASK",
+    "CONFIGURED_INCORRECTLY",
+    "TASK_ALREADY_RUNNING",
+    "TASK_EXECUTION_FAILED",
+    "TASK_EXECUTION_ABORTED",
+    "TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE",
+    "TASK_PROCESS_SIGKILL_TIMEOUT",
+    "TASK_RUN_CANCELLED",
+    "TASK_OUTPUT_ERROR",
+    "HANDLE_ERROR_ERROR",
+    "GRACEFUL_EXIT_TIMEOUT",
+    "TASK_RUN_HEARTBEAT_TIMEOUT"
+  ]),
+  message: zod.z.string().optional(),
+  stackTrace: zod.z.string().optional()
+});
+var TaskRunError = zod.z.discriminatedUnion("type", [
+  TaskRunBuiltInError,
+  TaskRunCustomErrorObject,
+  TaskRunStringError,
+  TaskRunInternalError
+]);
+var TaskRun = zod.z.object({
+  id: zod.z.string(),
+  payload: zod.z.string(),
+  payloadType: zod.z.string(),
+  context: zod.z.any(),
+  tags: zod.z.array(zod.z.string()),
+  isTest: zod.z.boolean().default(false),
+  createdAt: zod.z.coerce.date(),
+  startedAt: zod.z.coerce.date().default(() => /* @__PURE__ */ new Date()),
+  idempotencyKey: zod.z.string().optional(),
+  maxAttempts: zod.z.number().optional(),
+  durationMs: zod.z.number().default(0),
+  costInCents: zod.z.number().default(0),
+  baseCostInCents: zod.z.number().default(0)
+});
+var TaskRunExecutionTask = zod.z.object({
+  id: zod.z.string(),
+  filePath: zod.z.string(),
+  exportName: zod.z.string()
+});
+var TaskRunExecutionAttempt = zod.z.object({
+  id: zod.z.string(),
+  number: zod.z.number(),
+  startedAt: zod.z.coerce.date(),
+  backgroundWorkerId: zod.z.string(),
+  backgroundWorkerTaskId: zod.z.string(),
+  status: zod.z.string()
+});
+var TaskRunExecutionEnvironment = zod.z.object({
+  id: zod.z.string(),
+  slug: zod.z.string(),
+  type: zod.z.enum([
+    "PRODUCTION",
+    "STAGING",
+    "DEVELOPMENT",
+    "PREVIEW"
+  ])
+});
+var TaskRunExecutionOrganization = zod.z.object({
+  id: zod.z.string(),
+  slug: zod.z.string(),
+  name: zod.z.string()
+});
+var TaskRunExecutionProject = zod.z.object({
+  id: zod.z.string(),
+  ref: zod.z.string(),
+  slug: zod.z.string(),
+  name: zod.z.string()
+});
+var TaskRunExecutionQueue = zod.z.object({
+  id: zod.z.string(),
+  name: zod.z.string()
+});
+var TaskRunExecutionBatch = zod.z.object({
+  id: zod.z.string()
+});
+var TaskRunExecution = zod.z.object({
+  task: TaskRunExecutionTask,
+  attempt: TaskRunExecutionAttempt,
+  run: TaskRun,
+  queue: TaskRunExecutionQueue,
+  environment: TaskRunExecutionEnvironment,
+  organization: TaskRunExecutionOrganization,
+  project: TaskRunExecutionProject,
+  batch: TaskRunExecutionBatch.optional(),
+  machine: MachinePreset.optional()
+});
+var TaskRunContext = zod.z.object({
+  task: TaskRunExecutionTask,
+  attempt: TaskRunExecutionAttempt.omit({
+    backgroundWorkerId: true,
+    backgroundWorkerTaskId: true
+  }),
+  run: TaskRun.omit({
+    payload: true,
+    payloadType: true
+  }),
+  queue: TaskRunExecutionQueue,
+  environment: TaskRunExecutionEnvironment,
+  organization: TaskRunExecutionOrganization,
+  project: TaskRunExecutionProject,
+  batch: TaskRunExecutionBatch.optional(),
+  machine: MachinePreset.optional()
+});
+var TaskRunExecutionRetry = zod.z.object({
+  timestamp: zod.z.number(),
+  delay: zod.z.number(),
+  error: zod.z.unknown().optional()
+});
+var TaskRunExecutionUsage = zod.z.object({
+  durationMs: zod.z.number()
+});
+var TaskRunFailedExecutionResult = zod.z.object({
+  ok: zod.z.literal(false),
+  id: zod.z.string(),
+  error: TaskRunError,
+  retry: TaskRunExecutionRetry.optional(),
+  skippedRetrying: zod.z.boolean().optional(),
+  usage: TaskRunExecutionUsage.optional()
+});
+var TaskRunSuccessfulExecutionResult = zod.z.object({
+  ok: zod.z.literal(true),
+  id: zod.z.string(),
+  output: zod.z.string().optional(),
+  outputType: zod.z.string(),
+  usage: TaskRunExecutionUsage.optional()
+});
+var TaskRunExecutionResult = zod.z.discriminatedUnion("ok", [
+  TaskRunSuccessfulExecutionResult,
+  TaskRunFailedExecutionResult
+]);
+var BatchTaskRunExecutionResult = zod.z.object({
+  id: zod.z.string(),
+  items: TaskRunExecutionResult.array()
+});
+
+// src/v3/schemas/schemas.ts
+var EnvironmentType = zod.z.enum([
+  "PRODUCTION",
+  "STAGING",
+  "DEVELOPMENT",
+  "PREVIEW"
+]);
+var TaskRunExecutionPayload = zod.z.object({
+  execution: TaskRunExecution,
+  traceContext: zod.z.record(zod.z.unknown()),
+  environment: zod.z.record(zod.z.string()).optional()
+});
+var ProdTaskRunExecution = TaskRunExecution.extend({
+  worker: zod.z.object({
+    id: zod.z.string(),
+    contentHash: zod.z.string(),
+    version: zod.z.string()
+  }),
+  machine: MachinePreset.default({
+    name: "small-1x",
+    cpu: 1,
+    memory: 1,
+    centsPerMs: 0
+  })
+});
+var ProdTaskRunExecutionPayload = zod.z.object({
+  execution: ProdTaskRunExecution,
+  traceContext: zod.z.record(zod.z.unknown()),
+  environment: zod.z.record(zod.z.string()).optional()
+});
+var FixedWindowRateLimit = zod.z.object({
+  type: zod.z.literal("fixed-window"),
+  limit: zod.z.number(),
+  window: zod.z.union([
+    zod.z.object({
+      seconds: zod.z.number()
+    }),
+    zod.z.object({
+      minutes: zod.z.number()
+    }),
+    zod.z.object({
+      hours: zod.z.number()
+    })
+  ])
+});
+var SlidingWindowRateLimit = zod.z.object({
+  type: zod.z.literal("sliding-window"),
+  limit: zod.z.number(),
+  window: zod.z.union([
+    zod.z.object({
+      seconds: zod.z.number()
+    }),
+    zod.z.object({
+      minutes: zod.z.number()
+    }),
+    zod.z.object({
+      hours: zod.z.number()
+    })
+  ])
+});
+var RateLimitOptions = zod.z.discriminatedUnion("type", [
+  FixedWindowRateLimit,
+  SlidingWindowRateLimit
+]);
+var RetryOptions = zod.z.object({
+  /** The number of attempts before giving up */
+  maxAttempts: zod.z.number().int().optional(),
+  /** The exponential factor to use when calculating the next retry time.
+  *
+  * Each subsequent retry will be calculated as `previousTimeout * factor`
+  */
+  factor: zod.z.number().optional(),
+  /** The minimum time to wait before retrying */
+  minTimeoutInMs: zod.z.number().int().optional(),
+  /** The maximum time to wait before retrying */
+  maxTimeoutInMs: zod.z.number().int().optional(),
+  /** Randomize the timeout between retries.
+  *
+  * This can be useful to prevent the thundering herd problem where all retries happen at the same time.
+  */
+  randomize: zod.z.boolean().optional()
+});
+var QueueOptions = zod.z.object({
+  /** You can define a shared queue and then pass the name in to your task.
+     * 
+     * @example
+     * 
+     * ```ts
+     * const myQueue = queue({
+        name: "my-queue",
+        concurrencyLimit: 1,
+      });
+  
+      export const task1 = task({
+        id: "task-1",
+        queue: {
+          name: "my-queue",
+        },
+        run: async (payload: { message: string }) => {
+          // ...
+        },
+      });
+  
+      export const task2 = task({
+        id: "task-2",
+        queue: {
+          name: "my-queue",
+        },
+        run: async (payload: { message: string }) => {
+          // ...
+        },
+      });
+     * ```
+     */
+  name: zod.z.string().optional(),
+  /** An optional property that specifies the maximum number of concurrent run executions.
+  *
+  * If this property is omitted, the task can potentially use up the full concurrency of an environment. */
+  concurrencyLimit: zod.z.number().int().min(0).max(1e3).optional(),
+  /** @deprecated This feature is coming soon */
+  rateLimit: RateLimitOptions.optional()
+});
+var ScheduleMetadata = zod.z.object({
+  cron: zod.z.string(),
+  timezone: zod.z.string()
+});
+var TaskMetadata = zod.z.object({
+  id: zod.z.string(),
+  packageVersion: zod.z.string(),
+  queue: QueueOptions.optional(),
+  retry: RetryOptions.optional(),
+  machine: MachineConfig.optional(),
+  triggerSource: zod.z.string().optional(),
+  schedule: ScheduleMetadata.optional()
+});
+var TaskFileMetadata = zod.z.object({
+  filePath: zod.z.string(),
+  exportName: zod.z.string()
+});
+var TaskMetadataWithFilePath = zod.z.object({
+  id: zod.z.string(),
+  packageVersion: zod.z.string(),
+  queue: QueueOptions.optional(),
+  retry: RetryOptions.optional(),
+  machine: MachineConfig.optional(),
+  triggerSource: zod.z.string().optional(),
+  schedule: ScheduleMetadata.optional(),
+  filePath: zod.z.string(),
+  exportName: zod.z.string()
+});
+var PostStartCauses = zod.z.enum([
+  "index",
+  "create",
+  "restore"
+]);
+var PreStopCauses = zod.z.enum([
+  "terminate"
+]);
+var RegexSchema = zod.z.custom((val) => {
+  try {
+    return typeof val.test === "function";
+  } catch {
+    return false;
+  }
+});
+var Config = zod.z.object({
+  project: zod.z.string(),
+  triggerDirectories: zod.z.string().array().optional(),
+  triggerUrl: zod.z.string().optional(),
+  projectDir: zod.z.string().optional(),
+  tsconfigPath: zod.z.string().optional(),
+  retries: zod.z.object({
+    enabledInDev: zod.z.boolean().default(true),
+    default: RetryOptions.optional()
+  }).optional(),
+  additionalPackages: zod.z.string().array().optional(),
+  additionalFiles: zod.z.string().array().optional(),
+  dependenciesToBundle: zod.z.array(zod.z.union([
+    zod.z.string(),
+    RegexSchema
+  ])).optional(),
+  logLevel: zod.z.string().optional(),
+  enableConsoleLogging: zod.z.boolean().optional(),
+  postInstall: zod.z.string().optional(),
+  extraCACerts: zod.z.string().optional()
+});
+var WaitReason = zod.z.enum([
+  "WAIT_FOR_DURATION",
+  "WAIT_FOR_TASK",
+  "WAIT_FOR_BATCH"
+]);
+var TaskRunExecutionLazyAttemptPayload = zod.z.object({
+  runId: zod.z.string(),
+  attemptCount: zod.z.number().optional(),
+  messageId: zod.z.string(),
+  isTest: zod.z.boolean(),
+  traceContext: zod.z.record(zod.z.unknown()),
+  environment: zod.z.record(zod.z.string()).optional()
+});
+
+// src/v3/schemas/resources.ts
+var TaskResource = zod.z.object({
+  id: zod.z.string(),
+  filePath: zod.z.string(),
+  exportName: zod.z.string(),
+  queue: QueueOptions.optional(),
+  retry: RetryOptions.optional(),
+  machine: MachineConfig.optional(),
+  triggerSource: zod.z.string().optional(),
+  schedule: ScheduleMetadata.optional()
+});
+var BackgroundWorkerMetadata = zod.z.object({
+  packageVersion: zod.z.string(),
+  contentHash: zod.z.string(),
+  cliPackageVersion: zod.z.string().optional(),
+  tasks: zod.z.array(TaskResource)
+});
+var ImageDetailsMetadata = zod.z.object({
+  contentHash: zod.z.string(),
+  imageTag: zod.z.string()
+});
+var SerializedError = zod.z.object({
+  message: zod.z.string(),
+  name: zod.z.string().optional(),
+  stackTrace: zod.z.string().optional()
+});
+
+// src/v3/schemas/api.ts
+var WhoAmIResponseSchema = zod.z.object({
+  userId: zod.z.string(),
+  email: zod.z.string().email(),
+  dashboardUrl: zod.z.string()
+});
+var GetProjectResponseBody = zod.z.object({
+  id: zod.z.string(),
+  externalRef: zod.z.string(),
+  name: zod.z.string(),
+  slug: zod.z.string(),
+  createdAt: zod.z.coerce.date(),
+  organization: zod.z.object({
+    id: zod.z.string(),
+    title: zod.z.string(),
+    slug: zod.z.string(),
+    createdAt: zod.z.coerce.date()
+  })
+});
+var GetProjectsResponseBody = zod.z.array(GetProjectResponseBody);
+var GetProjectEnvResponse = zod.z.object({
+  apiKey: zod.z.string(),
+  name: zod.z.string(),
+  apiUrl: zod.z.string()
+});
+var CreateBackgroundWorkerRequestBody = zod.z.object({
+  localOnly: zod.z.boolean(),
+  metadata: BackgroundWorkerMetadata,
+  supportsLazyAttempts: zod.z.boolean().optional()
+});
+var CreateBackgroundWorkerResponse = zod.z.object({
+  id: zod.z.string(),
+  version: zod.z.string(),
+  contentHash: zod.z.string()
+});
+var TriggerTaskRequestBody = zod.z.object({
+  payload: zod.z.any(),
+  context: zod.z.any(),
+  options: zod.z.object({
+    dependentAttempt: zod.z.string().optional(),
+    dependentBatch: zod.z.string().optional(),
+    lockToVersion: zod.z.string().optional(),
+    queue: QueueOptions.optional(),
+    concurrencyKey: zod.z.string().optional(),
+    idempotencyKey: zod.z.string().optional(),
+    test: zod.z.boolean().optional(),
+    payloadType: zod.z.string().optional(),
+    delay: zod.z.string().or(zod.z.coerce.date()).optional(),
+    ttl: zod.z.string().or(zod.z.number().nonnegative().int()).optional(),
+    maxAttempts: zod.z.number().int().optional()
+  }).optional()
+});
+var TriggerTaskResponse = zod.z.object({
+  id: zod.z.string()
+});
+var BatchTriggerTaskRequestBody = zod.z.object({
+  items: TriggerTaskRequestBody.array(),
+  dependentAttempt: zod.z.string().optional()
+});
+var BatchTriggerTaskResponse = zod.z.object({
+  batchId: zod.z.string(),
+  runs: zod.z.string().array()
+});
+var GetBatchResponseBody = zod.z.object({
+  id: zod.z.string(),
+  items: zod.z.array(zod.z.object({
+    id: zod.z.string(),
+    taskRunId: zod.z.string(),
+    status: zod.z.enum([
+      "PENDING",
+      "CANCELED",
+      "COMPLETED",
+      "FAILED"
+    ])
+  }))
+});
+var RescheduleRunRequestBody = zod.z.object({
+  delay: zod.z.string().or(zod.z.coerce.date())
+});
+var GetEnvironmentVariablesResponseBody = zod.z.object({
+  variables: zod.z.record(zod.z.string())
+});
+var StartDeploymentIndexingRequestBody = zod.z.object({
+  imageReference: zod.z.string(),
+  selfHosted: zod.z.boolean().optional()
+});
+var StartDeploymentIndexingResponseBody = zod.z.object({
+  id: zod.z.string(),
+  contentHash: zod.z.string()
+});
+var ExternalBuildData = zod.z.object({
+  buildId: zod.z.string(),
+  buildToken: zod.z.string(),
+  projectId: zod.z.string()
+});
+var InitializeDeploymentResponseBody = zod.z.object({
+  id: zod.z.string(),
+  contentHash: zod.z.string(),
+  shortCode: zod.z.string(),
+  version: zod.z.string(),
+  imageTag: zod.z.string(),
+  externalBuildData: ExternalBuildData.optional().nullable(),
+  registryHost: zod.z.string().optional()
+});
+var InitializeDeploymentRequestBody = zod.z.object({
+  contentHash: zod.z.string(),
+  userId: zod.z.string().optional()
+});
+var DeploymentErrorData = zod.z.object({
+  name: zod.z.string(),
+  message: zod.z.string(),
+  stack: zod.z.string().optional(),
+  stderr: zod.z.string().optional()
+});
+var GetDeploymentResponseBody = zod.z.object({
+  id: zod.z.string(),
+  status: zod.z.enum([
+    "PENDING",
+    "BUILDING",
+    "DEPLOYING",
+    "DEPLOYED",
+    "FAILED",
+    "CANCELED",
+    "TIMED_OUT"
+  ]),
+  contentHash: zod.z.string(),
+  shortCode: zod.z.string(),
+  version: zod.z.string(),
+  imageReference: zod.z.string().optional(),
+  errorData: DeploymentErrorData.optional().nullable(),
+  worker: zod.z.object({
+    id: zod.z.string(),
+    version: zod.z.string(),
+    tasks: zod.z.array(zod.z.object({
+      id: zod.z.string(),
+      slug: zod.z.string(),
+      filePath: zod.z.string(),
+      exportName: zod.z.string()
+    }))
+  }).optional()
+});
+var CreateUploadPayloadUrlResponseBody = zod.z.object({
+  presignedUrl: zod.z.string()
+});
+var ReplayRunResponse = zod.z.object({
+  id: zod.z.string()
+});
+var CanceledRunResponse = zod.z.object({
+  id: zod.z.string()
+});
+var ScheduleType = zod.z.union([
+  zod.z.literal("DECLARATIVE"),
+  zod.z.literal("IMPERATIVE")
+]);
+var ScheduledTaskPayload = zod.z.object({
+  /** The schedule id associated with this run (you can have many schedules for the same task).
+  You can use this to remove the schedule, update it, etc */
+  scheduleId: zod.z.string(),
+  /** The type of schedule – `"DECLARATIVE"` or `"IMPERATIVE"`.
+  *
+  * **DECLARATIVE** – defined inline on your `schedules.task` using the `cron` property. They can only be created, updated or deleted by modifying the `cron` property on your task.
+  *
+  * **IMPERATIVE** – created using the `schedules.create` functions or in the dashboard.
+  */
+  type: ScheduleType,
+  /** When the task was scheduled to run.
+  * Note this will be slightly different from `new Date()` because it takes a few ms to run the task.
+  * 
+  * This date is UTC. To output it as a string with a timezone you would do this: 
+  * ```ts
+  * const formatted = payload.timestamp.toLocaleString("en-US", {
+       timeZone: payload.timezone,
+   });
+   ```  */
+  timestamp: zod.z.date(),
+  /** When the task was last run (it has been).
+  This can be undefined if it's never been run. This date is UTC. */
+  lastTimestamp: zod.z.date().optional(),
+  /** You can optionally provide an external id when creating the schedule.
+  Usually you would use a userId or some other unique identifier.
+  This defaults to undefined if you didn't provide one. */
+  externalId: zod.z.string().optional(),
+  /** The IANA timezone the schedule is set to. The default is UTC.
+  * You can see the full list of supported timezones here: https://cloud.trigger.dev/timezones
+  */
+  timezone: zod.z.string(),
+  /** The next 5 dates this task is scheduled to run */
+  upcoming: zod.z.array(zod.z.date())
+});
+var CreateScheduleOptions = zod.z.object({
+  /** The id of the task you want to attach to. */
+  task: zod.z.string(),
+  /**  The schedule in CRON format.
+     * 
+     * ```txt
+  *    *    *    *    *    *
+  ┬    ┬    ┬    ┬    ┬
+  │    │    │    │    |
+  │    │    │    │    └ day of week (0 - 7, 1L - 7L) (0 or 7 is Sun)
+  │    │    │    └───── month (1 - 12)
+  │    │    └────────── day of month (1 - 31, L)
+  │    └─────────────── hour (0 - 23)
+  └──────────────────── minute (0 - 59)
+     * ```
+  
+  "L" means the last. In the "day of week" field, 1L means the last Monday of the month. In the day of month field, L means the last day of the month.
+  
+     */
+  cron: zod.z.string(),
+  /** You can only create one schedule with this key. If you use it twice, the second call will update the schedule.
+  *
+  * This is required to prevent you from creating duplicate schedules. */
+  deduplicationKey: zod.z.string(),
+  /** Optionally, you can specify your own IDs (like a user ID) and then use it inside the run function of your task.
+  *
+  * This allows you to have per-user CRON tasks.
+  */
+  externalId: zod.z.string().optional(),
+  /** Optionally, you can specify a timezone in the IANA format. If unset it will use UTC.
+  * If specified then the CRON will be evaluated in that timezone and will respect daylight savings.
+  *
+  * If you set the CRON to `0 0 * * *` and the timezone to `America/New_York` then the task will run at midnight in New York time, no matter whether it's daylight savings or not.
+  *
+  * You can see the full list of supported timezones here: https://cloud.trigger.dev/timezones
+  *
+  * @example "America/New_York", "Europe/London", "Asia/Tokyo", "Africa/Cairo"
+  *
+  */
+  timezone: zod.z.string().optional()
+});
+var UpdateScheduleOptions = CreateScheduleOptions.omit({
+  deduplicationKey: true
+});
+var ScheduleGenerator = zod.z.object({
+  type: zod.z.literal("CRON"),
+  expression: zod.z.string(),
+  description: zod.z.string()
+});
+var ScheduleObject = zod.z.object({
+  id: zod.z.string(),
+  type: ScheduleType,
+  task: zod.z.string(),
+  active: zod.z.boolean(),
+  deduplicationKey: zod.z.string().nullish(),
+  externalId: zod.z.string().nullish(),
+  generator: ScheduleGenerator,
+  timezone: zod.z.string(),
+  nextRun: zod.z.coerce.date().nullish(),
+  environments: zod.z.array(zod.z.object({
+    id: zod.z.string(),
+    type: zod.z.string(),
+    userName: zod.z.string().nullish()
+  }))
+});
+var DeletedScheduleObject = zod.z.object({
+  id: zod.z.string()
+});
+var ListSchedulesResult = zod.z.object({
+  data: zod.z.array(ScheduleObject),
+  pagination: zod.z.object({
+    currentPage: zod.z.number(),
+    totalPages: zod.z.number(),
+    count: zod.z.number()
+  })
+});
+var ListScheduleOptions = zod.z.object({
+  page: zod.z.number().optional(),
+  perPage: zod.z.number().optional()
+});
+var TimezonesResult = zod.z.object({
+  timezones: zod.z.array(zod.z.string())
+});
+var RunStatus = zod.z.enum([
+  /// Task hasn't been deployed yet but is waiting to be executed
+  "WAITING_FOR_DEPLOY",
+  /// Task is waiting to be executed by a worker
+  "QUEUED",
+  /// Task is currently being executed by a worker
+  "EXECUTING",
+  /// Task has failed and is waiting to be retried
+  "REATTEMPTING",
+  /// Task has been paused by the system, and will be resumed by the system
+  "FROZEN",
+  /// Task has been completed successfully
+  "COMPLETED",
+  /// Task has been canceled by the user
+  "CANCELED",
+  /// Task has been completed with errors
+  "FAILED",
+  /// Task has crashed and won't be retried, most likely the worker ran out of resources, e.g. memory or storage
+  "CRASHED",
+  /// Task was interrupted during execution, mostly this happens in development environments
+  "INTERRUPTED",
+  /// Task has failed to complete, due to an error in the system
+  "SYSTEM_FAILURE",
+  /// Task has been scheduled to run at a specific time
+  "DELAYED",
+  /// Task has expired and won't be executed
+  "EXPIRED"
+]);
+var AttemptStatus = zod.z.enum([
+  "PENDING",
+  "EXECUTING",
+  "PAUSED",
+  "COMPLETED",
+  "FAILED",
+  "CANCELED"
+]);
+var RunEnvironmentDetails = zod.z.object({
+  id: zod.z.string(),
+  name: zod.z.string(),
+  user: zod.z.string().optional()
+});
+var RunScheduleDetails = zod.z.object({
+  id: zod.z.string(),
+  externalId: zod.z.string().optional(),
+  deduplicationKey: zod.z.string().optional(),
+  generator: ScheduleGenerator
+});
+var CommonRunFields = {
+  id: zod.z.string(),
+  status: RunStatus,
+  taskIdentifier: zod.z.string(),
+  idempotencyKey: zod.z.string().optional(),
+  version: zod.z.string().optional(),
+  isQueued: zod.z.boolean(),
+  isExecuting: zod.z.boolean(),
+  isCompleted: zod.z.boolean(),
+  isSuccess: zod.z.boolean(),
+  isFailed: zod.z.boolean(),
+  isCancelled: zod.z.boolean(),
+  isTest: zod.z.boolean(),
+  createdAt: zod.z.coerce.date(),
+  updatedAt: zod.z.coerce.date(),
+  startedAt: zod.z.coerce.date().optional(),
+  finishedAt: zod.z.coerce.date().optional(),
+  delayedUntil: zod.z.coerce.date().optional(),
+  ttl: zod.z.string().optional(),
+  expiredAt: zod.z.coerce.date().optional()
+};
+var RetrieveRunResponse = zod.z.object({
+  ...CommonRunFields,
+  payload: zod.z.any().optional(),
+  payloadPresignedUrl: zod.z.string().optional(),
+  output: zod.z.any().optional(),
+  outputPresignedUrl: zod.z.string().optional(),
+  schedule: RunScheduleDetails.optional(),
+  attempts: zod.z.array(zod.z.object({
+    id: zod.z.string(),
+    status: AttemptStatus,
+    createdAt: zod.z.coerce.date(),
+    updatedAt: zod.z.coerce.date(),
+    startedAt: zod.z.coerce.date().optional(),
+    completedAt: zod.z.coerce.date().optional(),
+    error: SerializedError.optional()
+  }).optional())
+});
+var ListRunResponseItem = zod.z.object({
+  ...CommonRunFields,
+  env: RunEnvironmentDetails
+});
+var ListRunResponse = zod.z.object({
+  data: zod.z.array(ListRunResponseItem),
+  pagination: zod.z.object({
+    next: zod.z.string().optional(),
+    previous: zod.z.string().optional()
+  })
+});
+var CreateEnvironmentVariableRequestBody = zod.z.object({
+  name: zod.z.string(),
+  value: zod.z.string()
+});
+var UpdateEnvironmentVariableRequestBody = zod.z.object({
+  value: zod.z.string()
+});
+var ImportEnvironmentVariablesRequestBody = zod.z.object({
+  variables: zod.z.record(zod.z.string()),
+  override: zod.z.boolean().optional()
+});
+var EnvironmentVariableResponseBody = zod.z.object({
+  success: zod.z.boolean()
+});
+var EnvironmentVariableValue = zod.z.object({
+  value: zod.z.string()
+});
+var EnvironmentVariable = zod.z.object({
+  name: zod.z.string(),
+  value: zod.z.string()
+});
+var EnvironmentVariables = zod.z.array(EnvironmentVariable);
+var BackgroundWorkerServerMessages = zod.z.discriminatedUnion("type", [
+  zod.z.object({
+    type: zod.z.literal("EXECUTE_RUNS"),
+    payloads: zod.z.array(TaskRunExecutionPayload)
+  }),
+  zod.z.object({
+    type: zod.z.literal("CANCEL_ATTEMPT"),
+    taskAttemptId: zod.z.string(),
+    taskRunId: zod.z.string()
+  }),
+  zod.z.object({
+    type: zod.z.literal("SCHEDULE_ATTEMPT"),
+    image: zod.z.string(),
+    version: zod.z.string(),
+    machine: MachinePreset,
+    // identifiers
+    id: zod.z.string().optional(),
+    envId: zod.z.string(),
+    envType: EnvironmentType,
+    orgId: zod.z.string(),
+    projectId: zod.z.string(),
+    runId: zod.z.string()
+  }),
+  zod.z.object({
+    type: zod.z.literal("EXECUTE_RUN_LAZY_ATTEMPT"),
+    payload: TaskRunExecutionLazyAttemptPayload
+  })
+]);
+var serverWebsocketMessages = {
+  SERVER_READY: zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    id: zod.z.string()
+  }),
+  BACKGROUND_WORKER_MESSAGE: zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    backgroundWorkerId: zod.z.string(),
+    data: BackgroundWorkerServerMessages
+  })
+};
+var BackgroundWorkerClientMessages = zod.z.discriminatedUnion("type", [
+  zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    type: zod.z.literal("TASK_RUN_COMPLETED"),
+    completion: TaskRunExecutionResult,
+    execution: TaskRunExecution
+  }),
+  zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    type: zod.z.literal("TASK_RUN_FAILED_TO_RUN"),
+    completion: TaskRunFailedExecutionResult
+  }),
+  zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    type: zod.z.literal("TASK_HEARTBEAT"),
+    id: zod.z.string()
+  }),
+  zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    type: zod.z.literal("TASK_RUN_HEARTBEAT"),
+    id: zod.z.string()
+  })
+]);
+var BackgroundWorkerProperties = zod.z.object({
+  id: zod.z.string(),
+  version: zod.z.string(),
+  contentHash: zod.z.string()
+});
+var clientWebsocketMessages = {
+  READY_FOR_TASKS: zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    backgroundWorkerId: zod.z.string(),
+    inProgressRuns: zod.z.string().array().optional()
+  }),
+  BACKGROUND_WORKER_DEPRECATED: zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    backgroundWorkerId: zod.z.string()
+  }),
+  BACKGROUND_WORKER_MESSAGE: zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    backgroundWorkerId: zod.z.string(),
+    data: BackgroundWorkerClientMessages
+  })
+};
+var workerToChildMessages = {
+  EXECUTE_TASK_RUN: zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    execution: TaskRunExecution,
+    traceContext: zod.z.record(zod.z.unknown()),
+    metadata: BackgroundWorkerProperties
+  }),
+  TASK_RUN_COMPLETED_NOTIFICATION: zod.z.discriminatedUnion("version", [
+    zod.z.object({
+      version: zod.z.literal("v1"),
+      completion: TaskRunExecutionResult,
+      execution: TaskRunExecution
+    }),
+    zod.z.object({
+      version: zod.z.literal("v2"),
+      completion: TaskRunExecutionResult
+    })
+  ]),
+  CLEANUP: zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    flush: zod.z.boolean().default(false),
+    kill: zod.z.boolean().default(true)
+  })
+};
+var UncaughtExceptionMessage = zod.z.object({
+  version: zod.z.literal("v1").default("v1"),
+  error: zod.z.object({
+    name: zod.z.string(),
+    message: zod.z.string(),
+    stack: zod.z.string().optional()
+  }),
+  origin: zod.z.enum([
+    "uncaughtException",
+    "unhandledRejection"
+  ])
+});
+var TaskMetadataFailedToParseData = zod.z.object({
+  version: zod.z.literal("v1").default("v1"),
+  tasks: zod.z.unknown(),
+  zodIssues: zod.z.custom((v) => {
+    return Array.isArray(v) && v.every((issue) => typeof issue === "object" && "message" in issue);
+  })
+});
+var childToWorkerMessages = {
+  TASK_RUN_COMPLETED: zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    execution: TaskRunExecution,
+    result: TaskRunExecutionResult
+  }),
+  TASKS_READY: zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    tasks: TaskMetadataWithFilePath.array()
+  }),
+  TASKS_FAILED_TO_PARSE: TaskMetadataFailedToParseData,
+  TASK_HEARTBEAT: zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    id: zod.z.string()
+  }),
+  TASK_RUN_HEARTBEAT: zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    id: zod.z.string()
+  }),
+  READY_TO_DISPOSE: zod.z.undefined(),
+  WAIT_FOR_DURATION: zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    ms: zod.z.number()
+  }),
+  WAIT_FOR_TASK: zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    id: zod.z.string()
+  }),
+  WAIT_FOR_BATCH: zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    id: zod.z.string(),
+    runs: zod.z.string().array()
+  }),
+  UNCAUGHT_EXCEPTION: UncaughtExceptionMessage
+};
+var ProdChildToWorkerMessages = {
+  TASK_RUN_COMPLETED: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      execution: TaskRunExecution,
+      result: TaskRunExecutionResult
+    })
+  },
+  TASKS_READY: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      tasks: TaskMetadataWithFilePath.array()
+    })
+  },
+  TASKS_FAILED_TO_PARSE: {
+    message: TaskMetadataFailedToParseData
+  },
+  TASK_HEARTBEAT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      id: zod.z.string()
+    })
+  },
+  READY_TO_DISPOSE: {
+    message: zod.z.undefined()
+  },
+  WAIT_FOR_DURATION: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      ms: zod.z.number(),
+      now: zod.z.number(),
+      waitThresholdInMs: zod.z.number()
+    })
+  },
+  WAIT_FOR_TASK: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      friendlyId: zod.z.string()
+    })
+  },
+  WAIT_FOR_BATCH: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      batchFriendlyId: zod.z.string(),
+      runFriendlyIds: zod.z.string().array()
+    })
+  },
+  UNCAUGHT_EXCEPTION: {
+    message: UncaughtExceptionMessage
+  }
+};
+var ProdWorkerToChildMessages = {
+  EXECUTE_TASK_RUN: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      execution: TaskRunExecution,
+      traceContext: zod.z.record(zod.z.unknown()),
+      metadata: BackgroundWorkerProperties
+    })
+  },
+  TASK_RUN_COMPLETED_NOTIFICATION: {
+    message: zod.z.discriminatedUnion("version", [
+      zod.z.object({
+        version: zod.z.literal("v1"),
+        completion: TaskRunExecutionResult,
+        execution: TaskRunExecution
+      }),
+      zod.z.object({
+        version: zod.z.literal("v2"),
+        completion: TaskRunExecutionResult
+      })
+    ])
+  },
+  CLEANUP: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      flush: zod.z.boolean().default(false),
+      kill: zod.z.boolean().default(true)
+    }),
+    callback: zod.z.void()
+  },
+  WAIT_COMPLETED_NOTIFICATION: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1")
+    })
+  }
+};
+var ProviderToPlatformMessages = {
+  LOG: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      data: zod.z.string()
+    })
+  },
+  LOG_WITH_ACK: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      data: zod.z.string()
+    }),
+    callback: zod.z.object({
+      status: zod.z.literal("ok")
+    })
+  },
+  WORKER_CRASHED: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string(),
+      reason: zod.z.string().optional(),
+      exitCode: zod.z.number().optional(),
+      message: zod.z.string().optional(),
+      logs: zod.z.string().optional(),
+      overrideCompletion: zod.z.boolean().optional()
+    })
+  },
+  INDEXING_FAILED: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      deploymentId: zod.z.string(),
+      error: zod.z.object({
+        name: zod.z.string(),
+        message: zod.z.string(),
+        stack: zod.z.string().optional(),
+        stderr: zod.z.string().optional()
+      }),
+      overrideCompletion: zod.z.boolean().optional()
+    })
+  }
+};
+var PlatformToProviderMessages = {
+  INDEX: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      imageTag: zod.z.string(),
+      shortCode: zod.z.string(),
+      apiKey: zod.z.string(),
+      apiUrl: zod.z.string(),
+      // identifiers
+      envId: zod.z.string(),
+      envType: EnvironmentType,
+      orgId: zod.z.string(),
+      projectId: zod.z.string(),
+      deploymentId: zod.z.string()
+    }),
+    callback: zod.z.discriminatedUnion("success", [
+      zod.z.object({
+        success: zod.z.literal(false),
+        error: zod.z.object({
+          name: zod.z.string(),
+          message: zod.z.string(),
+          stack: zod.z.string().optional(),
+          stderr: zod.z.string().optional()
+        })
+      }),
+      zod.z.object({
+        success: zod.z.literal(true)
+      })
+    ])
+  },
+  RESTORE: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      type: zod.z.enum([
+        "DOCKER",
+        "KUBERNETES"
+      ]),
+      location: zod.z.string(),
+      reason: zod.z.string().optional(),
+      imageRef: zod.z.string(),
+      machine: MachinePreset,
+      // identifiers
+      checkpointId: zod.z.string(),
+      envId: zod.z.string(),
+      envType: EnvironmentType,
+      orgId: zod.z.string(),
+      projectId: zod.z.string(),
+      runId: zod.z.string()
+    })
+  }
+};
+var CreateWorkerMessage = zod.z.object({
+  projectRef: zod.z.string(),
+  envId: zod.z.string(),
+  deploymentId: zod.z.string(),
+  metadata: zod.z.object({
+    cliPackageVersion: zod.z.string().optional(),
+    contentHash: zod.z.string(),
+    packageVersion: zod.z.string(),
+    tasks: TaskResource.array()
+  })
+});
+var CoordinatorToPlatformMessages = {
+  LOG: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      metadata: zod.z.any(),
+      text: zod.z.string()
+    })
+  },
+  CREATE_WORKER: {
+    message: zod.z.discriminatedUnion("version", [
+      CreateWorkerMessage.extend({
+        version: zod.z.literal("v1")
+      }),
+      CreateWorkerMessage.extend({
+        version: zod.z.literal("v2"),
+        supportsLazyAttempts: zod.z.boolean()
+      })
+    ]),
+    callback: zod.z.discriminatedUnion("success", [
+      zod.z.object({
+        success: zod.z.literal(false)
+      }),
+      zod.z.object({
+        success: zod.z.literal(true)
+      })
+    ])
+  },
+  CREATE_TASK_RUN_ATTEMPT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string(),
+      envId: zod.z.string()
+    }),
+    callback: zod.z.discriminatedUnion("success", [
+      zod.z.object({
+        success: zod.z.literal(false),
+        reason: zod.z.string().optional()
+      }),
+      zod.z.object({
+        success: zod.z.literal(true),
+        executionPayload: ProdTaskRunExecutionPayload
+      })
+    ])
+  },
+  // Deprecated: Only workers without lazy attempt support will use this
+  READY_FOR_EXECUTION: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string(),
+      totalCompletions: zod.z.number()
+    }),
+    callback: zod.z.discriminatedUnion("success", [
+      zod.z.object({
+        success: zod.z.literal(false)
+      }),
+      zod.z.object({
+        success: zod.z.literal(true),
+        payload: ProdTaskRunExecutionPayload
+      })
+    ])
+  },
+  READY_FOR_LAZY_ATTEMPT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string(),
+      envId: zod.z.string(),
+      totalCompletions: zod.z.number()
+    }),
+    callback: zod.z.discriminatedUnion("success", [
+      zod.z.object({
+        success: zod.z.literal(false),
+        reason: zod.z.string().optional()
+      }),
+      zod.z.object({
+        success: zod.z.literal(true),
+        lazyPayload: TaskRunExecutionLazyAttemptPayload
+      })
+    ])
+  },
+  READY_FOR_RESUME: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      attemptFriendlyId: zod.z.string(),
+      type: WaitReason
+    })
+  },
+  TASK_RUN_COMPLETED: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      execution: ProdTaskRunExecution,
+      completion: TaskRunExecutionResult,
+      checkpoint: zod.z.object({
+        docker: zod.z.boolean(),
+        location: zod.z.string()
+      }).optional()
+    })
+  },
+  TASK_RUN_FAILED_TO_RUN: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      completion: TaskRunFailedExecutionResult
+    })
+  },
+  TASK_HEARTBEAT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      attemptFriendlyId: zod.z.string()
+    })
+  },
+  TASK_RUN_HEARTBEAT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string()
+    })
+  },
+  CHECKPOINT_CREATED: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      attemptFriendlyId: zod.z.string(),
+      docker: zod.z.boolean(),
+      location: zod.z.string(),
+      reason: zod.z.discriminatedUnion("type", [
+        zod.z.object({
+          type: zod.z.literal("WAIT_FOR_DURATION"),
+          ms: zod.z.number(),
+          now: zod.z.number()
+        }),
+        zod.z.object({
+          type: zod.z.literal("WAIT_FOR_BATCH"),
+          batchFriendlyId: zod.z.string(),
+          runFriendlyIds: zod.z.string().array()
+        }),
+        zod.z.object({
+          type: zod.z.literal("WAIT_FOR_TASK"),
+          friendlyId: zod.z.string()
+        }),
+        zod.z.object({
+          type: zod.z.literal("RETRYING_AFTER_FAILURE"),
+          attemptNumber: zod.z.number()
+        })
+      ])
+    }),
+    callback: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      keepRunAlive: zod.z.boolean()
+    })
+  },
+  INDEXING_FAILED: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      deploymentId: zod.z.string(),
+      error: zod.z.object({
+        name: zod.z.string(),
+        message: zod.z.string(),
+        stack: zod.z.string().optional(),
+        stderr: zod.z.string().optional()
+      })
+    })
+  },
+  RUN_CRASHED: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string(),
+      error: zod.z.object({
+        name: zod.z.string(),
+        message: zod.z.string(),
+        stack: zod.z.string().optional()
+      })
+    })
+  }
+};
+var PlatformToCoordinatorMessages = {
+  RESUME_AFTER_DEPENDENCY: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string(),
+      attemptId: zod.z.string(),
+      attemptFriendlyId: zod.z.string(),
+      completions: TaskRunExecutionResult.array(),
+      executions: TaskRunExecution.array()
+    })
+  },
+  RESUME_AFTER_DURATION: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      attemptId: zod.z.string(),
+      attemptFriendlyId: zod.z.string()
+    })
+  },
+  REQUEST_ATTEMPT_CANCELLATION: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      attemptId: zod.z.string(),
+      attemptFriendlyId: zod.z.string()
+    })
+  },
+  REQUEST_RUN_CANCELLATION: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string(),
+      delayInMs: zod.z.number().optional()
+    })
+  },
+  READY_FOR_RETRY: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string()
+    })
+  },
+  DYNAMIC_CONFIG: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      checkpointThresholdInMs: zod.z.number()
+    })
+  }
+};
+var ClientToSharedQueueMessages = {
+  READY_FOR_TASKS: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      backgroundWorkerId: zod.z.string()
+    })
+  },
+  BACKGROUND_WORKER_DEPRECATED: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      backgroundWorkerId: zod.z.string()
+    })
+  },
+  BACKGROUND_WORKER_MESSAGE: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      backgroundWorkerId: zod.z.string(),
+      data: BackgroundWorkerClientMessages
+    })
+  }
+};
+var SharedQueueToClientMessages = {
+  SERVER_READY: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      id: zod.z.string()
+    })
+  },
+  BACKGROUND_WORKER_MESSAGE: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      backgroundWorkerId: zod.z.string(),
+      data: BackgroundWorkerServerMessages
+    })
+  }
+};
+var IndexTasksMessage = zod.z.object({
+  version: zod.z.literal("v1"),
+  deploymentId: zod.z.string(),
+  tasks: TaskResource.array(),
+  packageVersion: zod.z.string()
+});
+var ProdWorkerToCoordinatorMessages = {
+  TEST: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1")
+    }),
+    callback: zod.z.void()
+  },
+  INDEX_TASKS: {
+    message: zod.z.discriminatedUnion("version", [
+      IndexTasksMessage.extend({
+        version: zod.z.literal("v1")
+      }),
+      IndexTasksMessage.extend({
+        version: zod.z.literal("v2"),
+        supportsLazyAttempts: zod.z.boolean()
+      })
+    ]),
+    callback: zod.z.discriminatedUnion("success", [
+      zod.z.object({
+        success: zod.z.literal(false)
+      }),
+      zod.z.object({
+        success: zod.z.literal(true)
+      })
+    ])
+  },
+  // Deprecated: Only workers without lazy attempt support will use this
+  READY_FOR_EXECUTION: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string(),
+      totalCompletions: zod.z.number()
+    })
+  },
+  READY_FOR_LAZY_ATTEMPT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string(),
+      totalCompletions: zod.z.number()
+    })
+  },
+  READY_FOR_RESUME: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      attemptFriendlyId: zod.z.string(),
+      type: WaitReason
+    })
+  },
+  READY_FOR_CHECKPOINT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1")
+    })
+  },
+  CANCEL_CHECKPOINT: {
+    message: zod.z.discriminatedUnion("version", [
+      zod.z.object({
+        version: zod.z.literal("v1")
+      }),
+      zod.z.object({
+        version: zod.z.literal("v2"),
+        reason: WaitReason.optional()
+      })
+    ]).default({
+      version: "v1"
+    }),
+    callback: zod.z.object({
+      version: zod.z.literal("v2").default("v2"),
+      checkpointCanceled: zod.z.boolean(),
+      reason: WaitReason.optional()
+    })
+  },
+  TASK_HEARTBEAT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      attemptFriendlyId: zod.z.string()
+    })
+  },
+  TASK_RUN_HEARTBEAT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string()
+    })
+  },
+  TASK_RUN_COMPLETED: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      execution: ProdTaskRunExecution,
+      completion: TaskRunExecutionResult
+    }),
+    callback: zod.z.object({
+      willCheckpointAndRestore: zod.z.boolean(),
+      shouldExit: zod.z.boolean()
+    })
+  },
+  TASK_RUN_FAILED_TO_RUN: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      completion: TaskRunFailedExecutionResult
+    })
+  },
+  WAIT_FOR_DURATION: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      ms: zod.z.number(),
+      now: zod.z.number(),
+      attemptFriendlyId: zod.z.string()
+    }),
+    callback: zod.z.object({
+      willCheckpointAndRestore: zod.z.boolean()
+    })
+  },
+  WAIT_FOR_TASK: {
+    message: zod.z.object({
+      version: zod.z.enum([
+        "v1",
+        "v2"
+      ]).default("v1"),
+      friendlyId: zod.z.string(),
+      // This is the attempt that is waiting
+      attemptFriendlyId: zod.z.string()
+    }),
+    callback: zod.z.object({
+      willCheckpointAndRestore: zod.z.boolean()
+    })
+  },
+  WAIT_FOR_BATCH: {
+    message: zod.z.object({
+      version: zod.z.enum([
+        "v1",
+        "v2"
+      ]).default("v1"),
+      batchFriendlyId: zod.z.string(),
+      runFriendlyIds: zod.z.string().array(),
+      // This is the attempt that is waiting
+      attemptFriendlyId: zod.z.string()
+    }),
+    callback: zod.z.object({
+      willCheckpointAndRestore: zod.z.boolean()
+    })
+  },
+  INDEXING_FAILED: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      deploymentId: zod.z.string(),
+      error: zod.z.object({
+        name: zod.z.string(),
+        message: zod.z.string(),
+        stack: zod.z.string().optional(),
+        stderr: zod.z.string().optional()
+      })
+    })
+  },
+  CREATE_TASK_RUN_ATTEMPT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string()
+    }),
+    callback: zod.z.discriminatedUnion("success", [
+      zod.z.object({
+        success: zod.z.literal(false),
+        reason: zod.z.string().optional()
+      }),
+      zod.z.object({
+        success: zod.z.literal(true),
+        executionPayload: ProdTaskRunExecutionPayload
+      })
+    ])
+  },
+  UNRECOVERABLE_ERROR: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      error: zod.z.object({
+        name: zod.z.string(),
+        message: zod.z.string(),
+        stack: zod.z.string().optional()
+      })
+    })
+  },
+  SET_STATE: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      attemptFriendlyId: zod.z.string().optional()
+    })
+  }
+};
+var CoordinatorToProdWorkerMessages = {
+  RESUME_AFTER_DEPENDENCY: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      attemptId: zod.z.string(),
+      completions: TaskRunExecutionResult.array(),
+      executions: TaskRunExecution.array()
+    })
+  },
+  RESUME_AFTER_DURATION: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      attemptId: zod.z.string()
+    })
+  },
+  // Deprecated: Only workers without lazy attempt support will use this
+  EXECUTE_TASK_RUN: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      executionPayload: ProdTaskRunExecutionPayload
+    })
+  },
+  EXECUTE_TASK_RUN_LAZY_ATTEMPT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      lazyPayload: TaskRunExecutionLazyAttemptPayload
+    })
+  },
+  REQUEST_ATTEMPT_CANCELLATION: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      attemptId: zod.z.string()
+    })
+  },
+  REQUEST_EXIT: {
+    message: zod.z.discriminatedUnion("version", [
+      zod.z.object({
+        version: zod.z.literal("v1")
+      }),
+      zod.z.object({
+        version: zod.z.literal("v2"),
+        delayInMs: zod.z.number().optional()
+      })
+    ])
+  },
+  READY_FOR_RETRY: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string()
+    })
+  }
+};
+var ProdWorkerSocketData = zod.z.object({
+  contentHash: zod.z.string(),
+  projectRef: zod.z.string(),
+  envId: zod.z.string(),
+  runId: zod.z.string(),
+  attemptFriendlyId: zod.z.string().optional(),
+  podName: zod.z.string(),
+  deploymentId: zod.z.string(),
+  deploymentVersion: zod.z.string()
+});
+var CoordinatorSocketData = zod.z.object({
+  supportsDynamicConfig: zod.z.string().optional()
+});
+var PRIMARY_VARIANT = "primary";
+var Variant = zod.z.enum([
+  PRIMARY_VARIANT
+]);
+var AccessoryItem = zod.z.object({
+  text: zod.z.string(),
+  variant: zod.z.string().optional(),
+  url: zod.z.string().optional()
+});
+var Accessory = zod.z.object({
+  items: zod.z.array(AccessoryItem),
+  style: zod.z.enum([
+    "codepath"
+  ]).optional()
+});
+var TaskEventStyle = zod.z.object({
+  icon: zod.z.string().optional(),
+  variant: Variant.optional(),
+  accessory: Accessory.optional()
+}).default({
+  icon: void 0,
+  variant: void 0
+});
+var stringPatternMatchers = [
+  zod.z.object({
+    $endsWith: zod.z.string()
+  }),
+  zod.z.object({
+    $startsWith: zod.z.string()
+  }),
+  zod.z.object({
+    $ignoreCaseEquals: zod.z.string()
+  })
+];
+var EventMatcher = zod.z.union([
+  /** Match against a string */
+  zod.z.array(zod.z.string()),
+  /** Match against a number */
+  zod.z.array(zod.z.number()),
+  /** Match against a boolean */
+  zod.z.array(zod.z.boolean()),
+  zod.z.array(zod.z.union([
+    ...stringPatternMatchers,
+    zod.z.object({
+      $exists: zod.z.boolean()
+    }),
+    zod.z.object({
+      $isNull: zod.z.boolean()
+    }),
+    zod.z.object({
+      $anythingBut: zod.z.union([
+        zod.z.string(),
+        zod.z.number(),
+        zod.z.boolean()
+      ])
+    }),
+    zod.z.object({
+      $anythingBut: zod.z.union([
+        zod.z.array(zod.z.string()),
+        zod.z.array(zod.z.number()),
+        zod.z.array(zod.z.boolean())
+      ])
+    }),
+    zod.z.object({
+      $gt: zod.z.number()
+    }),
+    zod.z.object({
+      $lt: zod.z.number()
+    }),
+    zod.z.object({
+      $gte: zod.z.number()
+    }),
+    zod.z.object({
+      $lte: zod.z.number()
+    }),
+    zod.z.object({
+      $between: zod.z.tuple([
+        zod.z.number(),
+        zod.z.number()
+      ])
+    }),
+    zod.z.object({
+      $includes: zod.z.union([
+        zod.z.string(),
+        zod.z.number(),
+        zod.z.boolean()
+      ])
+    }),
+    zod.z.object({
+      $not: zod.z.union([
+        zod.z.string(),
+        zod.z.number(),
+        zod.z.boolean()
+      ])
+    })
+  ]))
+]);
+var EventFilter = zod.z.lazy(() => zod.z.record(zod.z.union([
+  EventMatcher,
+  EventFilter
+])));
+
+// src/v3/schemas/fetch.ts
+var FetchRetryHeadersStrategy = zod.z.object({
+  /** The `headers` strategy retries the request using info from the response headers. */
+  strategy: zod.z.literal("headers"),
+  /** The header to use to determine the maximum number of times to retry the request. */
+  limitHeader: zod.z.string(),
+  /** The header to use to determine the number of remaining retries. */
+  remainingHeader: zod.z.string(),
+  /** The header to use to determine the time when the number of remaining retries will be reset. */
+  resetHeader: zod.z.string(),
+  /** The event filter to use to determine if the request should be retried. */
+  bodyFilter: EventFilter.optional(),
+  /** The format of the `resetHeader` value. */
+  resetFormat: zod.z.enum([
+    "unix_timestamp",
+    "unix_timestamp_in_ms",
+    "iso_8601",
+    "iso_8601_duration_openai_variant"
+  ]).default("unix_timestamp").optional()
+});
+var FetchRetryBackoffStrategy = RetryOptions.extend({
+  /** The `backoff` strategy retries the request with an exponential backoff. */
+  strategy: zod.z.literal("backoff"),
+  /** The event filter to use to determine if the request should be retried. */
+  bodyFilter: EventFilter.optional()
+});
+var FetchRetryStrategy = zod.z.discriminatedUnion("strategy", [
+  FetchRetryHeadersStrategy,
+  FetchRetryBackoffStrategy
+]);
+var FetchRetryByStatusOptions = zod.z.record(zod.z.string(), FetchRetryStrategy);
+var FetchTimeoutOptions = zod.z.object({
+  /** The maximum time to wait for the request to complete. */
+  durationInMs: zod.z.number().optional(),
+  retry: RetryOptions.optional()
+});
+var FetchRetryOptions = zod.z.object({
+  /** The retrying strategy for specific status codes. */
+  byStatus: FetchRetryByStatusOptions.optional(),
+  /** The timeout options for the request. */
+  timeout: RetryOptions.optional(),
+  /**
+  * The retrying strategy for connection errors.
+  */
+  connectionError: RetryOptions.optional()
+});
+var ExceptionEventProperties = zod.z.object({
+  type: zod.z.string().optional(),
+  message: zod.z.string().optional(),
+  stacktrace: zod.z.string().optional()
+});
+var ExceptionSpanEvent = zod.z.object({
+  name: zod.z.literal("exception"),
+  time: zod.z.coerce.date(),
+  properties: zod.z.object({
+    exception: ExceptionEventProperties
+  })
+});
+var CancellationSpanEvent = zod.z.object({
+  name: zod.z.literal("cancellation"),
+  time: zod.z.coerce.date(),
+  properties: zod.z.object({
+    reason: zod.z.string()
+  })
+});
+var OtherSpanEvent = zod.z.object({
+  name: zod.z.string(),
+  time: zod.z.coerce.date(),
+  properties: zod.z.record(zod.z.unknown())
+});
+var SpanEvent = zod.z.union([
+  ExceptionSpanEvent,
+  CancellationSpanEvent,
+  OtherSpanEvent
+]);
+var SpanEvents = zod.z.array(SpanEvent);
+function isExceptionSpanEvent(event) {
+  return event.name === "exception";
+}
+__name(isExceptionSpanEvent, "isExceptionSpanEvent");
+function isCancellationSpanEvent(event) {
+  return event.name === "cancellation";
+}
+__name(isCancellationSpanEvent, "isCancellationSpanEvent");
+var SpanMessagingEvent = zod.z.object({
+  system: zod.z.string().optional(),
+  client_id: zod.z.string().optional(),
+  operation: zod.z.enum([
+    "publish",
+    "create",
+    "receive",
+    "deliver"
+  ]),
+  message: zod.z.any(),
+  destination: zod.z.string().optional()
+});
+
+exports.AttemptStatus = AttemptStatus;
+exports.BackgroundWorkerClientMessages = BackgroundWorkerClientMessages;
+exports.BackgroundWorkerMetadata = BackgroundWorkerMetadata;
+exports.BackgroundWorkerProperties = BackgroundWorkerProperties;
+exports.BackgroundWorkerServerMessages = BackgroundWorkerServerMessages;
+exports.BatchTaskRunExecutionResult = BatchTaskRunExecutionResult;
+exports.BatchTriggerTaskRequestBody = BatchTriggerTaskRequestBody;
+exports.BatchTriggerTaskResponse = BatchTriggerTaskResponse;
+exports.CanceledRunResponse = CanceledRunResponse;
+exports.CancellationSpanEvent = CancellationSpanEvent;
+exports.ClientToSharedQueueMessages = ClientToSharedQueueMessages;
+exports.Config = Config;
+exports.CoordinatorSocketData = CoordinatorSocketData;
+exports.CoordinatorToPlatformMessages = CoordinatorToPlatformMessages;
+exports.CoordinatorToProdWorkerMessages = CoordinatorToProdWorkerMessages;
+exports.CreateAuthorizationCodeResponseSchema = CreateAuthorizationCodeResponseSchema;
+exports.CreateBackgroundWorkerRequestBody = CreateBackgroundWorkerRequestBody;
+exports.CreateBackgroundWorkerResponse = CreateBackgroundWorkerResponse;
+exports.CreateEnvironmentVariableRequestBody = CreateEnvironmentVariableRequestBody;
+exports.CreateScheduleOptions = CreateScheduleOptions;
+exports.CreateUploadPayloadUrlResponseBody = CreateUploadPayloadUrlResponseBody;
+exports.DeletedScheduleObject = DeletedScheduleObject;
+exports.DeploymentErrorData = DeploymentErrorData;
+exports.EnvironmentType = EnvironmentType;
+exports.EnvironmentVariable = EnvironmentVariable;
+exports.EnvironmentVariableResponseBody = EnvironmentVariableResponseBody;
+exports.EnvironmentVariableValue = EnvironmentVariableValue;
+exports.EnvironmentVariables = EnvironmentVariables;
+exports.EventFilter = EventFilter;
+exports.ExceptionEventProperties = ExceptionEventProperties;
+exports.ExceptionSpanEvent = ExceptionSpanEvent;
+exports.ExternalBuildData = ExternalBuildData;
+exports.FetchRetryBackoffStrategy = FetchRetryBackoffStrategy;
+exports.FetchRetryByStatusOptions = FetchRetryByStatusOptions;
+exports.FetchRetryHeadersStrategy = FetchRetryHeadersStrategy;
+exports.FetchRetryOptions = FetchRetryOptions;
+exports.FetchRetryStrategy = FetchRetryStrategy;
+exports.FetchTimeoutOptions = FetchTimeoutOptions;
+exports.FixedWindowRateLimit = FixedWindowRateLimit;
+exports.GetBatchResponseBody = GetBatchResponseBody;
+exports.GetDeploymentResponseBody = GetDeploymentResponseBody;
+exports.GetEnvironmentVariablesResponseBody = GetEnvironmentVariablesResponseBody;
+exports.GetPersonalAccessTokenRequestSchema = GetPersonalAccessTokenRequestSchema;
+exports.GetPersonalAccessTokenResponseSchema = GetPersonalAccessTokenResponseSchema;
+exports.GetProjectEnvResponse = GetProjectEnvResponse;
+exports.GetProjectResponseBody = GetProjectResponseBody;
+exports.GetProjectsResponseBody = GetProjectsResponseBody;
+exports.ImageDetailsMetadata = ImageDetailsMetadata;
+exports.ImportEnvironmentVariablesRequestBody = ImportEnvironmentVariablesRequestBody;
+exports.InitializeDeploymentRequestBody = InitializeDeploymentRequestBody;
+exports.InitializeDeploymentResponseBody = InitializeDeploymentResponseBody;
+exports.ListRunResponse = ListRunResponse;
+exports.ListRunResponseItem = ListRunResponseItem;
+exports.ListScheduleOptions = ListScheduleOptions;
+exports.ListSchedulesResult = ListSchedulesResult;
+exports.MachineConfig = MachineConfig;
+exports.MachineCpu = MachineCpu;
+exports.MachineMemory = MachineMemory;
+exports.MachinePreset = MachinePreset;
+exports.MachinePresetName = MachinePresetName;
+exports.OtherSpanEvent = OtherSpanEvent;
+exports.PRIMARY_VARIANT = PRIMARY_VARIANT;
+exports.PlatformToCoordinatorMessages = PlatformToCoordinatorMessages;
+exports.PlatformToProviderMessages = PlatformToProviderMessages;
+exports.PostStartCauses = PostStartCauses;
+exports.PreStopCauses = PreStopCauses;
+exports.ProdChildToWorkerMessages = ProdChildToWorkerMessages;
+exports.ProdTaskRunExecution = ProdTaskRunExecution;
+exports.ProdTaskRunExecutionPayload = ProdTaskRunExecutionPayload;
+exports.ProdWorkerSocketData = ProdWorkerSocketData;
+exports.ProdWorkerToChildMessages = ProdWorkerToChildMessages;
+exports.ProdWorkerToCoordinatorMessages = ProdWorkerToCoordinatorMessages;
+exports.ProviderToPlatformMessages = ProviderToPlatformMessages;
+exports.QueueOptions = QueueOptions;
+exports.RateLimitOptions = RateLimitOptions;
+exports.ReplayRunResponse = ReplayRunResponse;
+exports.RescheduleRunRequestBody = RescheduleRunRequestBody;
+exports.RetrieveRunResponse = RetrieveRunResponse;
+exports.RetryOptions = RetryOptions;
+exports.RunEnvironmentDetails = RunEnvironmentDetails;
+exports.RunScheduleDetails = RunScheduleDetails;
+exports.RunStatus = RunStatus;
+exports.ScheduleGenerator = ScheduleGenerator;
+exports.ScheduleMetadata = ScheduleMetadata;
+exports.ScheduleObject = ScheduleObject;
+exports.ScheduleType = ScheduleType;
+exports.ScheduledTaskPayload = ScheduledTaskPayload;
+exports.SharedQueueToClientMessages = SharedQueueToClientMessages;
+exports.SlidingWindowRateLimit = SlidingWindowRateLimit;
+exports.SpanEvent = SpanEvent;
+exports.SpanEvents = SpanEvents;
+exports.SpanMessagingEvent = SpanMessagingEvent;
+exports.StartDeploymentIndexingRequestBody = StartDeploymentIndexingRequestBody;
+exports.StartDeploymentIndexingResponseBody = StartDeploymentIndexingResponseBody;
+exports.TaskEventStyle = TaskEventStyle;
+exports.TaskFileMetadata = TaskFileMetadata;
+exports.TaskMetadata = TaskMetadata;
+exports.TaskMetadataFailedToParseData = TaskMetadataFailedToParseData;
+exports.TaskMetadataWithFilePath = TaskMetadataWithFilePath;
+exports.TaskResource = TaskResource;
+exports.TaskRun = TaskRun;
+exports.TaskRunBuiltInError = TaskRunBuiltInError;
+exports.TaskRunContext = TaskRunContext;
+exports.TaskRunCustomErrorObject = TaskRunCustomErrorObject;
+exports.TaskRunError = TaskRunError;
+exports.TaskRunErrorCodes = TaskRunErrorCodes;
+exports.TaskRunExecution = TaskRunExecution;
+exports.TaskRunExecutionAttempt = TaskRunExecutionAttempt;
+exports.TaskRunExecutionBatch = TaskRunExecutionBatch;
+exports.TaskRunExecutionEnvironment = TaskRunExecutionEnvironment;
+exports.TaskRunExecutionLazyAttemptPayload = TaskRunExecutionLazyAttemptPayload;
+exports.TaskRunExecutionOrganization = TaskRunExecutionOrganization;
+exports.TaskRunExecutionPayload = TaskRunExecutionPayload;
+exports.TaskRunExecutionProject = TaskRunExecutionProject;
+exports.TaskRunExecutionQueue = TaskRunExecutionQueue;
+exports.TaskRunExecutionResult = TaskRunExecutionResult;
+exports.TaskRunExecutionRetry = TaskRunExecutionRetry;
+exports.TaskRunExecutionTask = TaskRunExecutionTask;
+exports.TaskRunExecutionUsage = TaskRunExecutionUsage;
+exports.TaskRunFailedExecutionResult = TaskRunFailedExecutionResult;
+exports.TaskRunInternalError = TaskRunInternalError;
+exports.TaskRunStringError = TaskRunStringError;
+exports.TaskRunSuccessfulExecutionResult = TaskRunSuccessfulExecutionResult;
+exports.TimezonesResult = TimezonesResult;
+exports.TriggerTaskRequestBody = TriggerTaskRequestBody;
+exports.TriggerTaskResponse = TriggerTaskResponse;
+exports.UncaughtExceptionMessage = UncaughtExceptionMessage;
+exports.UpdateEnvironmentVariableRequestBody = UpdateEnvironmentVariableRequestBody;
+exports.UpdateScheduleOptions = UpdateScheduleOptions;
+exports.WaitReason = WaitReason;
+exports.WhoAmIResponseSchema = WhoAmIResponseSchema;
+exports.childToWorkerMessages = childToWorkerMessages;
+exports.clientWebsocketMessages = clientWebsocketMessages;
+exports.isCancellationSpanEvent = isCancellationSpanEvent;
+exports.isExceptionSpanEvent = isExceptionSpanEvent;
+exports.serverWebsocketMessages = serverWebsocketMessages;
+exports.stringPatternMatchers = stringPatternMatchers;
+exports.workerToChildMessages = workerToChildMessages;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.js.map