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

package/dist/schemas/index.js

@@ -0,0 +1,1630 @@
+'use strict';
+
+var ulidx = require('ulidx');
+var zod = require('zod');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/schemas/addMissingVersionField.ts
+function addMissingVersionField(val) {
+  if (val !== null && typeof val === "object" && !("version" in val)) {
+    return {
+      ...val,
+      version: "1"
+    };
+  }
+  return val;
+}
+__name(addMissingVersionField, "addMissingVersionField");
+var ErrorWithStackSchema = zod.z.object({
+  message: zod.z.string(),
+  name: zod.z.string().optional(),
+  stack: zod.z.string().optional()
+});
+var SchemaErrorSchema = zod.z.object({
+  path: zod.z.array(zod.z.string()),
+  message: zod.z.string()
+});
+var stringPatternMatchers = [
+  zod.z.object({
+    $endsWith: zod.z.string()
+  }),
+  zod.z.object({
+    $startsWith: zod.z.string()
+  }),
+  zod.z.object({
+    $ignoreCaseEquals: zod.z.string()
+  })
+];
+var EventMatcherSchema = 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 EventFilterSchema = zod.z.lazy(() => zod.z.record(zod.z.union([
+  EventMatcherSchema,
+  EventFilterSchema
+])));
+var EventRuleSchema = zod.z.object({
+  event: zod.z.string().or(zod.z.array(zod.z.string())),
+  source: zod.z.string(),
+  payload: EventFilterSchema.optional(),
+  context: EventFilterSchema.optional()
+});
+var ConnectionAuthSchema = zod.z.object({
+  type: zod.z.enum([
+    "oauth2",
+    "apiKey"
+  ]),
+  accessToken: zod.z.string(),
+  scopes: zod.z.array(zod.z.string()).optional(),
+  additionalFields: zod.z.record(zod.z.string()).optional()
+});
+var IntegrationMetadataSchema = zod.z.object({
+  id: zod.z.string(),
+  name: zod.z.string(),
+  instructions: zod.z.string().optional()
+});
+var IntegrationConfigSchema = zod.z.object({
+  id: zod.z.string(),
+  metadata: IntegrationMetadataSchema,
+  authSource: zod.z.enum([
+    "HOSTED",
+    "LOCAL",
+    "RESOLVER"
+  ])
+});
+var LiteralSchema = zod.z.union([
+  zod.z.string(),
+  zod.z.number(),
+  zod.z.boolean(),
+  zod.z.null()
+]);
+var DeserializedJsonSchema = zod.z.lazy(() => zod.z.union([
+  LiteralSchema,
+  zod.z.array(DeserializedJsonSchema),
+  zod.z.record(DeserializedJsonSchema)
+]));
+var SerializableSchema = zod.z.union([
+  zod.z.string(),
+  zod.z.number(),
+  zod.z.boolean(),
+  zod.z.null(),
+  zod.z.date(),
+  zod.z.undefined(),
+  zod.z.symbol()
+]);
+var SerializableJsonSchema = zod.z.lazy(() => zod.z.union([
+  SerializableSchema,
+  zod.z.array(SerializableJsonSchema),
+  zod.z.record(SerializableJsonSchema)
+]));
+var DisplayPropertySchema = zod.z.object({
+  /** The label for the property */
+  label: zod.z.string(),
+  /** The value of the property */
+  text: zod.z.string(),
+  /** The URL to link to when the property is clicked */
+  url: zod.z.string().optional(),
+  /** The URL to a list of images to display next to the property */
+  imageUrl: zod.z.array(zod.z.string()).optional()
+});
+var DisplayPropertiesSchema = zod.z.array(DisplayPropertySchema);
+var StyleSchema = zod.z.object({
+  /** The style, `normal` or `minimal` */
+  style: zod.z.enum([
+    "normal",
+    "minimal"
+  ]),
+  /** A variant of the style. */
+  variant: zod.z.string().optional()
+});
+var SCHEDULED_EVENT = "dev.trigger.scheduled";
+var ScheduledPayloadSchema = zod.z.object({
+  ts: zod.z.coerce.date(),
+  lastTimestamp: zod.z.coerce.date().optional()
+});
+var IntervalOptionsSchema = zod.z.object({
+  /** The number of seconds for the interval. Min = 20, Max = 2_592_000 (30 days) */
+  seconds: zod.z.number().int().positive().min(20).max(2592e3)
+});
+var CronOptionsSchema = zod.z.object({
+  /** A CRON expression that defines the schedule. A useful tool when writing CRON
+  expressions is [crontab guru](https://crontab.guru). Note that the timezone
+  used is UTC. */
+  cron: zod.z.string()
+});
+var CronMetadataSchema = zod.z.object({
+  type: zod.z.literal("cron"),
+  options: CronOptionsSchema,
+  /** An optional Account ID to associate with runs triggered by this interval */
+  accountId: zod.z.string().optional(),
+  metadata: zod.z.any()
+});
+var IntervalMetadataSchema = zod.z.object({
+  /** An interval reoccurs at the specified number of seconds  */
+  type: zod.z.literal("interval"),
+  /** An object containing options about the interval. */
+  options: IntervalOptionsSchema,
+  /** An optional Account ID to associate with runs triggered by this interval */
+  accountId: zod.z.string().optional(),
+  /** Any additional metadata about the schedule. */
+  metadata: zod.z.any()
+});
+var ScheduleMetadataSchema = zod.z.discriminatedUnion("type", [
+  IntervalMetadataSchema,
+  CronMetadataSchema
+]);
+var RegisterDynamicSchedulePayloadSchema = zod.z.object({
+  id: zod.z.string(),
+  jobs: zod.z.array(zod.z.object({
+    id: zod.z.string(),
+    version: zod.z.string()
+  }))
+});
+var TaskStatusSchema = zod.z.enum([
+  "PENDING",
+  "WAITING",
+  "RUNNING",
+  "COMPLETED",
+  "ERRORED",
+  "CANCELED"
+]);
+var TaskSchema = zod.z.object({
+  id: zod.z.string(),
+  name: zod.z.string(),
+  icon: zod.z.string().optional().nullable(),
+  noop: zod.z.boolean(),
+  startedAt: zod.z.coerce.date().optional().nullable(),
+  completedAt: zod.z.coerce.date().optional().nullable(),
+  delayUntil: zod.z.coerce.date().optional().nullable(),
+  status: TaskStatusSchema,
+  description: zod.z.string().optional().nullable(),
+  properties: zod.z.array(DisplayPropertySchema).optional().nullable(),
+  outputProperties: zod.z.array(DisplayPropertySchema).optional().nullable(),
+  params: DeserializedJsonSchema.optional().nullable(),
+  output: DeserializedJsonSchema.optional().nullable(),
+  context: DeserializedJsonSchema.optional().nullable(),
+  error: zod.z.string().optional().nullable(),
+  parentId: zod.z.string().optional().nullable(),
+  style: StyleSchema.optional().nullable(),
+  operation: zod.z.string().optional().nullable(),
+  callbackUrl: zod.z.string().optional().nullable(),
+  childExecutionMode: zod.z.enum([
+    "SEQUENTIAL",
+    "PARALLEL"
+  ]).optional().nullable()
+});
+var ServerTaskSchema = TaskSchema.extend({
+  idempotencyKey: zod.z.string(),
+  attempts: zod.z.number(),
+  forceYield: zod.z.boolean().optional().nullable()
+});
+var CachedTaskSchema = zod.z.object({
+  id: zod.z.string(),
+  idempotencyKey: zod.z.string(),
+  status: TaskStatusSchema,
+  noop: zod.z.boolean().default(false),
+  output: DeserializedJsonSchema.optional().nullable(),
+  parentId: zod.z.string().optional().nullable()
+});
+var EventExampleSchema = zod.z.object({
+  id: zod.z.string(),
+  icon: zod.z.string().optional(),
+  name: zod.z.string(),
+  payload: zod.z.any()
+});
+var EventSpecificationSchema = zod.z.object({
+  name: zod.z.string().or(zod.z.array(zod.z.string())),
+  title: zod.z.string(),
+  source: zod.z.string(),
+  icon: zod.z.string(),
+  filter: EventFilterSchema.optional(),
+  properties: zod.z.array(DisplayPropertySchema).optional(),
+  schema: zod.z.any().optional(),
+  examples: zod.z.array(EventExampleSchema).optional()
+});
+var DynamicTriggerMetadataSchema = zod.z.object({
+  type: zod.z.literal("dynamic"),
+  id: zod.z.string()
+});
+var TriggerHelpSchema = zod.z.object({
+  noRuns: zod.z.object({
+    text: zod.z.string(),
+    link: zod.z.string().optional()
+  }).optional()
+});
+var StaticTriggerMetadataSchema = zod.z.object({
+  type: zod.z.literal("static"),
+  title: zod.z.union([
+    zod.z.string(),
+    zod.z.array(zod.z.string())
+  ]),
+  properties: zod.z.array(DisplayPropertySchema).optional(),
+  rule: EventRuleSchema,
+  link: zod.z.string().optional(),
+  help: TriggerHelpSchema.optional()
+});
+var InvokeTriggerMetadataSchema = zod.z.object({
+  type: zod.z.literal("invoke")
+});
+var ScheduledTriggerMetadataSchema = zod.z.object({
+  type: zod.z.literal("scheduled"),
+  schedule: ScheduleMetadataSchema
+});
+var TriggerMetadataSchema = zod.z.discriminatedUnion("type", [
+  DynamicTriggerMetadataSchema,
+  StaticTriggerMetadataSchema,
+  ScheduledTriggerMetadataSchema,
+  InvokeTriggerMetadataSchema
+]);
+var StatusUpdateStateSchema = zod.z.union([
+  zod.z.literal("loading"),
+  zod.z.literal("success"),
+  zod.z.literal("failure")
+]);
+var StatusUpdateDataSchema = zod.z.record(SerializableJsonSchema);
+var StatusUpdateSchema = zod.z.object({
+  label: zod.z.string().optional(),
+  state: StatusUpdateStateSchema.optional(),
+  data: StatusUpdateDataSchema.optional()
+});
+var InitalStatusUpdateSchema = StatusUpdateSchema.required({
+  label: true
+});
+var StatusHistorySchema = zod.z.array(StatusUpdateSchema);
+var JobRunStatusRecordSchema = InitalStatusUpdateSchema.extend({
+  key: zod.z.string(),
+  history: StatusHistorySchema
+});
+
+// src/schemas/runs.ts
+var RunStatusSchema = zod.z.union([
+  zod.z.literal("PENDING"),
+  zod.z.literal("QUEUED"),
+  zod.z.literal("WAITING_ON_CONNECTIONS"),
+  zod.z.literal("PREPROCESSING"),
+  zod.z.literal("STARTED"),
+  zod.z.literal("SUCCESS"),
+  zod.z.literal("FAILURE"),
+  zod.z.literal("TIMED_OUT"),
+  zod.z.literal("ABORTED"),
+  zod.z.literal("CANCELED"),
+  zod.z.literal("UNRESOLVED_AUTH"),
+  zod.z.literal("INVALID_PAYLOAD"),
+  zod.z.literal("EXECUTING"),
+  zod.z.literal("WAITING_TO_CONTINUE"),
+  zod.z.literal("WAITING_TO_EXECUTE")
+]);
+var RunTaskSchema = zod.z.object({
+  /** The Task id */
+  id: zod.z.string(),
+  /** The key that you defined when creating the Task, the first param in any task. */
+  displayKey: zod.z.string().nullable(),
+  /** The Task status */
+  status: TaskStatusSchema,
+  /** The name of the Task */
+  name: zod.z.string(),
+  /** The icon of the Task, a string.
+  * For integrations, this will be a lowercase name of the company.
+  * Can be used with the [@trigger.dev/companyicons](https://www.npmjs.com/package/@trigger.dev/companyicons) package to display an svg. */
+  icon: zod.z.string().nullable(),
+  /** When the task started */
+  startedAt: zod.z.coerce.date().nullable(),
+  /** When the task completed */
+  completedAt: zod.z.coerce.date().nullable()
+});
+var RunTaskWithSubtasksSchema = RunTaskSchema.extend({
+  subtasks: zod.z.lazy(() => RunTaskWithSubtasksSchema.array()).optional()
+});
+var GetRunOptionsSchema = zod.z.object({
+  /** Return subtasks, which appear in a `subtasks` array on a task. @default false */
+  subtasks: zod.z.boolean().optional(),
+  /** You can use this to get more tasks, if there are more than are returned in a single batch @default undefined */
+  cursor: zod.z.string().optional(),
+  /** How many tasks you want to return in one go, max 50. @default 20 */
+  take: zod.z.number().optional()
+});
+GetRunOptionsSchema.extend({
+  /** If `true`, it returns the `params` and `output` of all tasks. @default false */
+  taskdetails: zod.z.boolean().optional()
+});
+var RunSchema = zod.z.object({
+  /** The Run id */
+  id: zod.z.string(),
+  /** The Run status */
+  status: RunStatusSchema,
+  /** When the run started */
+  startedAt: zod.z.coerce.date().nullable(),
+  /** When the run was last updated */
+  updatedAt: zod.z.coerce.date().nullable(),
+  /** When the run was completed */
+  completedAt: zod.z.coerce.date().nullable()
+});
+var GetRunSchema = RunSchema.extend({
+  /** The output of the run */
+  output: zod.z.any().optional(),
+  /** The tasks from the run */
+  tasks: zod.z.array(RunTaskWithSubtasksSchema),
+  /** Any status updates that were published from the run */
+  statuses: zod.z.array(JobRunStatusRecordSchema).default([]),
+  /** If there are more tasks, you can use this to get them */
+  nextCursor: zod.z.string().optional()
+});
+zod.z.object({
+  /** You can use this to get more tasks, if there are more than are returned in a single batch @default undefined */
+  cursor: zod.z.string().optional(),
+  /** How many runs you want to return in one go, max 50. @default 20 */
+  take: zod.z.number().optional()
+});
+var GetRunsSchema = zod.z.object({
+  /** The runs from the query */
+  runs: RunSchema.array(),
+  /** If there are more runs, you can use this to get them */
+  nextCursor: zod.z.string().optional()
+});
+var StringMatchSchema = zod.z.union([
+  /** Match against a string */
+  zod.z.array(zod.z.string()),
+  zod.z.array(zod.z.union(stringPatternMatchers))
+]);
+var HTTPMethodUnionSchema = zod.z.union([
+  zod.z.literal("GET"),
+  zod.z.literal("POST"),
+  zod.z.literal("PUT"),
+  zod.z.literal("PATCH"),
+  zod.z.literal("DELETE"),
+  zod.z.literal("HEAD"),
+  zod.z.literal("OPTIONS")
+]);
+var RequestFilterSchema = zod.z.object({
+  /** An array of HTTP methods to match.
+  * For example, `["GET", "POST"]` will match both `GET` and `POST` Requests. */
+  method: zod.z.array(HTTPMethodUnionSchema).optional(),
+  /** An object of header key/values to match. 
+     * This uses the [EventFilter matching syntax](https://trigger.dev/docs/documentation/guides/event-filter).
+  
+      @example
+    ```ts
+    filter: {
+      header: {
+        "content-type": ["application/json"],
+      },
+    },
+    ``` */
+  headers: zod.z.record(StringMatchSchema).optional(),
+  /** An object of query parameters to match. 
+     * This uses the [EventFilter matching syntax](https://trigger.dev/docs/documentation/guides/event-filter).
+  
+    @example
+    ```ts
+    filter: {
+      query: {
+        "hub.mode": [{ $startsWith: "sub" }],
+      },
+    },
+    ``` */
+  query: zod.z.record(StringMatchSchema).optional(),
+  /** An object of key/values to match.
+  * This uses the [EventFilter matching syntax](https://trigger.dev/docs/documentation/guides/event-filter).
+  */
+  body: EventFilterSchema.optional()
+});
+var ResponseFilterSchema = RequestFilterSchema.omit({
+  method: true,
+  query: true
+}).extend({
+  status: zod.z.array(zod.z.number()).optional()
+});
+
+// src/schemas/api.ts
+var UpdateTriggerSourceBodyV1Schema = zod.z.object({
+  registeredEvents: zod.z.array(zod.z.string()),
+  secret: zod.z.string().optional(),
+  data: SerializableJsonSchema.optional()
+});
+var UpdateTriggerSourceBodyV2Schema = zod.z.object({
+  secret: zod.z.string().optional(),
+  data: SerializableJsonSchema.optional(),
+  options: zod.z.object({
+    event: zod.z.array(zod.z.string())
+  }).and(zod.z.record(zod.z.string(), zod.z.array(zod.z.string())).optional())
+});
+var UpdateWebhookBodySchema = zod.z.discriminatedUnion("active", [
+  zod.z.object({
+    active: zod.z.literal(false)
+  }),
+  zod.z.object({
+    active: zod.z.literal(true),
+    config: zod.z.record(zod.z.string().array())
+  })
+]);
+var RegisterHTTPTriggerSourceBodySchema = zod.z.object({
+  type: zod.z.literal("HTTP"),
+  url: zod.z.string().url()
+});
+var RegisterSMTPTriggerSourceBodySchema = zod.z.object({
+  type: zod.z.literal("SMTP")
+});
+var RegisterSQSTriggerSourceBodySchema = zod.z.object({
+  type: zod.z.literal("SQS")
+});
+var RegisterSourceChannelBodySchema = zod.z.discriminatedUnion("type", [
+  RegisterHTTPTriggerSourceBodySchema,
+  RegisterSMTPTriggerSourceBodySchema,
+  RegisterSQSTriggerSourceBodySchema
+]);
+var REGISTER_WEBHOOK = "dev.trigger.webhook.register";
+var DELIVER_WEBHOOK_REQUEST = "dev.trigger.webhook.deliver";
+var RegisterWebhookSourceSchema = zod.z.object({
+  key: zod.z.string(),
+  params: zod.z.any(),
+  config: zod.z.any(),
+  active: zod.z.boolean(),
+  secret: zod.z.string(),
+  url: zod.z.string(),
+  data: DeserializedJsonSchema.optional(),
+  clientId: zod.z.string().optional()
+});
+var RegisterWebhookPayloadSchema = zod.z.object({
+  active: zod.z.boolean(),
+  params: zod.z.any().optional(),
+  config: zod.z.object({
+    current: zod.z.record(zod.z.string().array()),
+    desired: zod.z.record(zod.z.string().array())
+  }),
+  // from HTTP Endpoint
+  url: zod.z.string(),
+  secret: zod.z.string()
+});
+var REGISTER_SOURCE_EVENT_V1 = "dev.trigger.source.register";
+var REGISTER_SOURCE_EVENT_V2 = "dev.trigger.source.register.v2";
+var RegisterTriggerSourceSchema = zod.z.object({
+  key: zod.z.string(),
+  params: zod.z.any(),
+  active: zod.z.boolean(),
+  secret: zod.z.string(),
+  data: DeserializedJsonSchema.optional(),
+  channel: RegisterSourceChannelBodySchema,
+  clientId: zod.z.string().optional()
+});
+zod.z.object({
+  name: zod.z.string(),
+  value: zod.z.string()
+});
+var RegisterSourceEventSchemaV1 = zod.z.object({
+  /** The id of the source */
+  id: zod.z.string(),
+  source: RegisterTriggerSourceSchema,
+  events: zod.z.array(zod.z.string()),
+  missingEvents: zod.z.array(zod.z.string()),
+  orphanedEvents: zod.z.array(zod.z.string()),
+  dynamicTriggerId: zod.z.string().optional()
+});
+var RegisteredOptionsDiffSchema = zod.z.object({
+  desired: zod.z.array(zod.z.string()),
+  missing: zod.z.array(zod.z.string()),
+  orphaned: zod.z.array(zod.z.string())
+});
+var RegisterSourceEventOptionsSchema = zod.z.object({
+  event: RegisteredOptionsDiffSchema
+}).and(zod.z.record(zod.z.string(), RegisteredOptionsDiffSchema));
+var RegisterSourceEventSchemaV2 = zod.z.object({
+  /** The id of the source */
+  id: zod.z.string(),
+  source: RegisterTriggerSourceSchema,
+  options: RegisterSourceEventOptionsSchema,
+  dynamicTriggerId: zod.z.string().optional()
+});
+var TriggerSourceSchema = zod.z.object({
+  id: zod.z.string(),
+  key: zod.z.string()
+});
+var HttpSourceResponseMetadataSchema = DeserializedJsonSchema;
+var HandleTriggerSourceSchema = zod.z.object({
+  key: zod.z.string(),
+  secret: zod.z.string(),
+  data: zod.z.any(),
+  params: zod.z.any(),
+  auth: ConnectionAuthSchema.optional(),
+  metadata: HttpSourceResponseMetadataSchema.optional()
+});
+var HttpSourceRequestHeadersSchema = zod.z.object({
+  "x-ts-key": zod.z.string(),
+  "x-ts-dynamic-id": zod.z.string().optional(),
+  "x-ts-secret": zod.z.string(),
+  "x-ts-data": zod.z.string().transform((s) => JSON.parse(s)),
+  "x-ts-params": zod.z.string().transform((s) => JSON.parse(s)),
+  "x-ts-http-url": zod.z.string(),
+  "x-ts-http-method": zod.z.string(),
+  "x-ts-http-headers": zod.z.string().transform((s) => zod.z.record(zod.z.string()).parse(JSON.parse(s))),
+  "x-ts-auth": zod.z.string().optional().transform((s) => {
+    if (s === void 0)
+      return;
+    const json = JSON.parse(s);
+    return ConnectionAuthSchema.parse(json);
+  }),
+  "x-ts-metadata": zod.z.string().optional().transform((s) => {
+    if (s === void 0)
+      return;
+    const json = JSON.parse(s);
+    return DeserializedJsonSchema.parse(json);
+  })
+});
+var HttpEndpointRequestHeadersSchema = zod.z.object({
+  "x-ts-key": zod.z.string(),
+  "x-ts-http-url": zod.z.string(),
+  "x-ts-http-method": zod.z.string(),
+  "x-ts-http-headers": zod.z.string().transform((s) => zod.z.record(zod.z.string()).parse(JSON.parse(s)))
+});
+var WebhookSourceRequestHeadersSchema = zod.z.object({
+  "x-ts-key": zod.z.string(),
+  "x-ts-dynamic-id": zod.z.string().optional(),
+  "x-ts-secret": zod.z.string(),
+  "x-ts-params": zod.z.string().transform((s) => JSON.parse(s)),
+  "x-ts-http-url": zod.z.string(),
+  "x-ts-http-method": zod.z.string(),
+  "x-ts-http-headers": zod.z.string().transform((s) => zod.z.record(zod.z.string()).parse(JSON.parse(s)))
+});
+var PongSuccessResponseSchema = zod.z.object({
+  ok: zod.z.literal(true),
+  triggerVersion: zod.z.string().optional(),
+  triggerSdkVersion: zod.z.string().optional()
+});
+var PongErrorResponseSchema = zod.z.object({
+  ok: zod.z.literal(false),
+  error: zod.z.string(),
+  triggerVersion: zod.z.string().optional(),
+  triggerSdkVersion: zod.z.string().optional()
+});
+var PongResponseSchema = zod.z.discriminatedUnion("ok", [
+  PongSuccessResponseSchema,
+  PongErrorResponseSchema
+]);
+var ValidateSuccessResponseSchema = zod.z.object({
+  ok: zod.z.literal(true),
+  endpointId: zod.z.string(),
+  triggerVersion: zod.z.string().optional()
+});
+var ValidateErrorResponseSchema = zod.z.object({
+  ok: zod.z.literal(false),
+  error: zod.z.string(),
+  triggerVersion: zod.z.string().optional()
+});
+var ValidateResponseSchema = zod.z.discriminatedUnion("ok", [
+  ValidateSuccessResponseSchema,
+  ValidateErrorResponseSchema
+]);
+var QueueOptionsSchema = zod.z.object({
+  name: zod.z.string(),
+  maxConcurrent: zod.z.number().optional()
+});
+var ConcurrencyLimitOptionsSchema = zod.z.object({
+  id: zod.z.string(),
+  limit: zod.z.number()
+});
+var JobMetadataSchema = zod.z.object({
+  id: zod.z.string(),
+  name: zod.z.string(),
+  version: zod.z.string(),
+  event: EventSpecificationSchema,
+  trigger: TriggerMetadataSchema,
+  integrations: zod.z.record(IntegrationConfigSchema),
+  internal: zod.z.boolean().default(false),
+  enabled: zod.z.boolean(),
+  startPosition: zod.z.enum([
+    "initial",
+    "latest"
+  ]),
+  preprocessRuns: zod.z.boolean(),
+  concurrencyLimit: ConcurrencyLimitOptionsSchema.or(zod.z.number().int().positive()).optional()
+});
+var SourceMetadataV1Schema = zod.z.object({
+  version: zod.z.literal("1"),
+  channel: zod.z.enum([
+    "HTTP",
+    "SQS",
+    "SMTP"
+  ]),
+  integration: IntegrationConfigSchema,
+  key: zod.z.string(),
+  params: zod.z.any(),
+  events: zod.z.array(zod.z.string()),
+  registerSourceJob: zod.z.object({
+    id: zod.z.string(),
+    version: zod.z.string()
+  }).optional()
+});
+var SourceMetadataV2Schema = zod.z.object({
+  version: zod.z.literal("2"),
+  channel: zod.z.enum([
+    "HTTP",
+    "SQS",
+    "SMTP"
+  ]),
+  integration: IntegrationConfigSchema,
+  key: zod.z.string(),
+  params: zod.z.any(),
+  options: zod.z.record(zod.z.array(zod.z.string())),
+  registerSourceJob: zod.z.object({
+    id: zod.z.string(),
+    version: zod.z.string()
+  }).optional()
+});
+var SourceMetadataSchema = zod.z.preprocess(addMissingVersionField, zod.z.discriminatedUnion("version", [
+  SourceMetadataV1Schema,
+  SourceMetadataV2Schema
+]));
+var WebhookMetadataSchema = zod.z.object({
+  key: zod.z.string(),
+  params: zod.z.any(),
+  config: zod.z.record(zod.z.array(zod.z.string())),
+  integration: IntegrationConfigSchema,
+  httpEndpoint: zod.z.object({
+    id: zod.z.string()
+  })
+});
+var WebhookContextMetadataSchema = zod.z.object({
+  params: zod.z.any(),
+  config: zod.z.record(zod.z.string().array()),
+  secret: zod.z.string()
+});
+var DynamicTriggerEndpointMetadataSchema = zod.z.object({
+  id: zod.z.string(),
+  jobs: zod.z.array(JobMetadataSchema.pick({
+    id: true,
+    version: true
+  })),
+  registerSourceJob: zod.z.object({
+    id: zod.z.string(),
+    version: zod.z.string()
+  }).optional()
+});
+var HttpEndpointMetadataSchema = zod.z.object({
+  id: zod.z.string(),
+  version: zod.z.string(),
+  enabled: zod.z.boolean(),
+  title: zod.z.string().optional(),
+  icon: zod.z.string().optional(),
+  properties: zod.z.array(DisplayPropertySchema).optional(),
+  event: EventSpecificationSchema,
+  immediateResponseFilter: RequestFilterSchema.optional(),
+  skipTriggeringRuns: zod.z.boolean().optional(),
+  source: zod.z.string()
+});
+var IndexEndpointResponseSchema = zod.z.object({
+  jobs: zod.z.array(JobMetadataSchema),
+  sources: zod.z.array(SourceMetadataSchema),
+  webhooks: zod.z.array(WebhookMetadataSchema).optional(),
+  dynamicTriggers: zod.z.array(DynamicTriggerEndpointMetadataSchema),
+  dynamicSchedules: zod.z.array(RegisterDynamicSchedulePayloadSchema),
+  httpEndpoints: zod.z.array(HttpEndpointMetadataSchema).optional()
+});
+var EndpointIndexErrorSchema = zod.z.object({
+  message: zod.z.string(),
+  raw: zod.z.any().optional()
+});
+var IndexEndpointStatsSchema = zod.z.object({
+  jobs: zod.z.number(),
+  sources: zod.z.number(),
+  webhooks: zod.z.number().optional(),
+  dynamicTriggers: zod.z.number(),
+  dynamicSchedules: zod.z.number(),
+  disabledJobs: zod.z.number().default(0),
+  httpEndpoints: zod.z.number().default(0)
+});
+function parseEndpointIndexStats(stats) {
+  if (stats === null || stats === void 0) {
+    return;
+  }
+  return IndexEndpointStatsSchema.parse(stats);
+}
+__name(parseEndpointIndexStats, "parseEndpointIndexStats");
+var GetEndpointIndexResponseSchema = zod.z.discriminatedUnion("status", [
+  zod.z.object({
+    status: zod.z.literal("PENDING"),
+    updatedAt: zod.z.coerce.date()
+  }),
+  zod.z.object({
+    status: zod.z.literal("STARTED"),
+    updatedAt: zod.z.coerce.date()
+  }),
+  zod.z.object({
+    status: zod.z.literal("SUCCESS"),
+    stats: IndexEndpointStatsSchema,
+    updatedAt: zod.z.coerce.date()
+  }),
+  zod.z.object({
+    status: zod.z.literal("FAILURE"),
+    error: EndpointIndexErrorSchema,
+    updatedAt: zod.z.coerce.date()
+  })
+]);
+var EndpointHeadersSchema = zod.z.object({
+  "trigger-version": zod.z.string().optional(),
+  "trigger-sdk-version": zod.z.string().optional()
+});
+var ExecuteJobRunMetadataSchema = zod.z.object({
+  successSubscription: zod.z.boolean().optional(),
+  failedSubscription: zod.z.boolean().optional()
+});
+var ExecuteJobHeadersSchema = EndpointHeadersSchema.extend({
+  "x-trigger-run-metadata": zod.z.preprocess((val) => typeof val === "string" && JSON.parse(val), ExecuteJobRunMetadataSchema).optional()
+});
+var RawEventSchema = zod.z.object({
+  /** The `name` property must exactly match any subscriptions you want to
+    trigger. */
+  name: zod.z.string(),
+  /** The `payload` property will be sent to any matching Jobs and will appear
+    as the `payload` param of the `run()` function. You can leave this
+    parameter out if you just want to trigger a Job without any input data. */
+  payload: zod.z.any(),
+  /** The optional `context` property will be sent to any matching Jobs and will
+    be passed through as the `context.event.context` param of the `run()`
+    function. This is optional but can be useful if you want to pass through
+    some additional context to the Job. */
+  context: zod.z.any().optional(),
+  /** The `id` property uniquely identify this particular event. If unset it
+    will be set automatically using `ulid`. */
+  id: zod.z.string().default(() => ulidx.ulid()),
+  /** This is optional, it defaults to the current timestamp. Usually you would
+    only set this if you have a timestamp that you wish to pass through, e.g.
+    you receive a timestamp from a service and you want the same timestamp to
+    be used in your Job. */
+  timestamp: zod.z.coerce.date().optional(),
+  /** This is optional, it defaults to "trigger.dev". It can be useful to set
+    this as you can filter events using this in the `eventTrigger()`. */
+  source: zod.z.string().optional(),
+  /** This is optional, it defaults to "JSON". If your event is actually a request,
+    with a url, headers, method and rawBody you can use "REQUEST" */
+  payloadType: zod.z.union([
+    zod.z.literal("JSON"),
+    zod.z.literal("REQUEST")
+  ]).optional()
+});
+var ApiEventLogSchema = zod.z.object({
+  /** The `id` of the event that was sent.
+  */
+  id: zod.z.string(),
+  /** The `name` of the event that was sent. */
+  name: zod.z.string(),
+  /** The `payload` of the event that was sent */
+  payload: DeserializedJsonSchema,
+  /** The `context` of the event that was sent. Is `undefined` if no context was
+    set when sending the event. */
+  context: DeserializedJsonSchema.optional().nullable(),
+  /** The `timestamp` of the event that was sent */
+  timestamp: zod.z.coerce.date(),
+  /** The timestamp when the event will be delivered to any matching Jobs. Is
+    `undefined` if `deliverAt` or `deliverAfter` wasn't set when sending the
+    event. */
+  deliverAt: zod.z.coerce.date().optional().nullable(),
+  /** The timestamp when the event was delivered. Is `undefined` if `deliverAt`
+    or `deliverAfter` were set when sending the event. */
+  deliveredAt: zod.z.coerce.date().optional().nullable(),
+  /** The timestamp when the event was cancelled. Is `undefined` if the event
+  * wasn't cancelled. */
+  cancelledAt: zod.z.coerce.date().optional().nullable()
+});
+var SendEventOptionsSchema = zod.z.object({
+  /** An optional Date when you want the event to trigger Jobs. The event will
+    be sent to the platform immediately but won't be acted upon until the
+    specified time. */
+  deliverAt: zod.z.coerce.date().optional(),
+  /** An optional number of seconds you want to wait for the event to trigger
+    any relevant Jobs. The event will be sent to the platform immediately but
+    won't be delivered until after the elapsed number of seconds. */
+  deliverAfter: zod.z.number().int().optional(),
+  /** This optional param will be used by Trigger.dev Connect, which
+    is coming soon. */
+  accountId: zod.z.string().optional()
+});
+var SendEventBodySchema = zod.z.object({
+  event: RawEventSchema,
+  options: SendEventOptionsSchema.optional()
+});
+var SendBulkEventsBodySchema = zod.z.object({
+  events: RawEventSchema.array(),
+  options: SendEventOptionsSchema.optional()
+});
+var DeliverEventResponseSchema = zod.z.object({
+  deliveredAt: zod.z.string().datetime()
+});
+var RuntimeEnvironmentTypeSchema = zod.z.enum([
+  "PRODUCTION",
+  "STAGING",
+  "DEVELOPMENT",
+  "PREVIEW"
+]);
+var RunSourceContextSchema = zod.z.object({
+  id: zod.z.string(),
+  metadata: zod.z.any()
+});
+var AutoYieldConfigSchema = zod.z.object({
+  startTaskThreshold: zod.z.number(),
+  beforeExecuteTaskThreshold: zod.z.number(),
+  beforeCompleteTaskThreshold: zod.z.number(),
+  afterCompleteTaskThreshold: zod.z.number()
+});
+var RunJobBodySchema = zod.z.object({
+  event: ApiEventLogSchema,
+  job: zod.z.object({
+    id: zod.z.string(),
+    version: zod.z.string()
+  }),
+  run: zod.z.object({
+    id: zod.z.string(),
+    isTest: zod.z.boolean(),
+    isRetry: zod.z.boolean().default(false),
+    startedAt: zod.z.coerce.date()
+  }),
+  environment: zod.z.object({
+    id: zod.z.string(),
+    slug: zod.z.string(),
+    type: RuntimeEnvironmentTypeSchema
+  }),
+  organization: zod.z.object({
+    id: zod.z.string(),
+    title: zod.z.string(),
+    slug: zod.z.string()
+  }),
+  project: zod.z.object({
+    id: zod.z.string(),
+    name: zod.z.string(),
+    slug: zod.z.string()
+  }).optional(),
+  account: zod.z.object({
+    id: zod.z.string(),
+    metadata: zod.z.any()
+  }).optional(),
+  source: RunSourceContextSchema.optional(),
+  tasks: zod.z.array(CachedTaskSchema).optional(),
+  cachedTaskCursor: zod.z.string().optional(),
+  noopTasksSet: zod.z.string().optional(),
+  connections: zod.z.record(ConnectionAuthSchema).optional(),
+  yieldedExecutions: zod.z.string().array().optional(),
+  runChunkExecutionLimit: zod.z.number().optional(),
+  autoYieldConfig: AutoYieldConfigSchema.optional()
+});
+var RunJobErrorSchema = zod.z.object({
+  status: zod.z.literal("ERROR"),
+  error: ErrorWithStackSchema,
+  task: TaskSchema.optional()
+});
+var RunJobYieldExecutionErrorSchema = zod.z.object({
+  status: zod.z.literal("YIELD_EXECUTION"),
+  key: zod.z.string()
+});
+var AutoYieldMetadataSchema = zod.z.object({
+  location: zod.z.string(),
+  timeRemaining: zod.z.number(),
+  timeElapsed: zod.z.number(),
+  limit: zod.z.number().optional()
+});
+var RunJobAutoYieldExecutionErrorSchema = AutoYieldMetadataSchema.extend({
+  status: zod.z.literal("AUTO_YIELD_EXECUTION")
+});
+var RunJobAutoYieldWithCompletedTaskExecutionErrorSchema = zod.z.object({
+  status: zod.z.literal("AUTO_YIELD_EXECUTION_WITH_COMPLETED_TASK"),
+  id: zod.z.string(),
+  properties: zod.z.array(DisplayPropertySchema).optional(),
+  output: zod.z.string().optional(),
+  data: AutoYieldMetadataSchema
+});
+var RunJobAutoYieldRateLimitErrorSchema = zod.z.object({
+  status: zod.z.literal("AUTO_YIELD_RATE_LIMIT"),
+  reset: zod.z.coerce.number()
+});
+var RunJobInvalidPayloadErrorSchema = zod.z.object({
+  status: zod.z.literal("INVALID_PAYLOAD"),
+  errors: zod.z.array(SchemaErrorSchema)
+});
+var RunJobUnresolvedAuthErrorSchema = zod.z.object({
+  status: zod.z.literal("UNRESOLVED_AUTH_ERROR"),
+  issues: zod.z.record(zod.z.object({
+    id: zod.z.string(),
+    error: zod.z.string()
+  }))
+});
+var RunJobResumeWithTaskSchema = zod.z.object({
+  status: zod.z.literal("RESUME_WITH_TASK"),
+  task: TaskSchema
+});
+var RunJobRetryWithTaskSchema = zod.z.object({
+  status: zod.z.literal("RETRY_WITH_TASK"),
+  task: TaskSchema,
+  error: ErrorWithStackSchema,
+  retryAt: zod.z.coerce.date()
+});
+var RunJobCanceledWithTaskSchema = zod.z.object({
+  status: zod.z.literal("CANCELED"),
+  task: TaskSchema
+});
+var RunJobSuccessSchema = zod.z.object({
+  status: zod.z.literal("SUCCESS"),
+  output: DeserializedJsonSchema.optional()
+});
+var RunJobErrorResponseSchema = zod.z.union([
+  RunJobAutoYieldExecutionErrorSchema,
+  RunJobAutoYieldWithCompletedTaskExecutionErrorSchema,
+  RunJobYieldExecutionErrorSchema,
+  RunJobAutoYieldRateLimitErrorSchema,
+  RunJobErrorSchema,
+  RunJobUnresolvedAuthErrorSchema,
+  RunJobInvalidPayloadErrorSchema,
+  RunJobResumeWithTaskSchema,
+  RunJobRetryWithTaskSchema,
+  RunJobCanceledWithTaskSchema
+]);
+var RunJobResumeWithParallelTaskSchema = zod.z.object({
+  status: zod.z.literal("RESUME_WITH_PARALLEL_TASK"),
+  task: TaskSchema,
+  childErrors: zod.z.array(RunJobErrorResponseSchema)
+});
+var RunJobResponseSchema = zod.z.discriminatedUnion("status", [
+  RunJobAutoYieldExecutionErrorSchema,
+  RunJobAutoYieldWithCompletedTaskExecutionErrorSchema,
+  RunJobYieldExecutionErrorSchema,
+  RunJobAutoYieldRateLimitErrorSchema,
+  RunJobErrorSchema,
+  RunJobUnresolvedAuthErrorSchema,
+  RunJobInvalidPayloadErrorSchema,
+  RunJobResumeWithTaskSchema,
+  RunJobResumeWithParallelTaskSchema,
+  RunJobRetryWithTaskSchema,
+  RunJobCanceledWithTaskSchema,
+  RunJobSuccessSchema
+]);
+var PreprocessRunBodySchema = zod.z.object({
+  event: ApiEventLogSchema,
+  job: zod.z.object({
+    id: zod.z.string(),
+    version: zod.z.string()
+  }),
+  run: zod.z.object({
+    id: zod.z.string(),
+    isTest: zod.z.boolean()
+  }),
+  environment: zod.z.object({
+    id: zod.z.string(),
+    slug: zod.z.string(),
+    type: RuntimeEnvironmentTypeSchema
+  }),
+  organization: zod.z.object({
+    id: zod.z.string(),
+    title: zod.z.string(),
+    slug: zod.z.string()
+  }),
+  account: zod.z.object({
+    id: zod.z.string(),
+    metadata: zod.z.any()
+  }).optional()
+});
+var PreprocessRunResponseSchema = zod.z.object({
+  abort: zod.z.boolean(),
+  properties: zod.z.array(DisplayPropertySchema).optional()
+});
+var CreateRunResponseOkSchema = zod.z.object({
+  ok: zod.z.literal(true),
+  data: zod.z.object({
+    id: zod.z.string()
+  })
+});
+var CreateRunResponseErrorSchema = zod.z.object({
+  ok: zod.z.literal(false),
+  error: zod.z.string()
+});
+var CreateRunResponseBodySchema = zod.z.discriminatedUnion("ok", [
+  CreateRunResponseOkSchema,
+  CreateRunResponseErrorSchema
+]);
+var RedactStringSchema = zod.z.object({
+  __redactedString: zod.z.literal(true),
+  strings: zod.z.array(zod.z.string()),
+  interpolations: zod.z.array(zod.z.string())
+});
+var LogMessageSchema = zod.z.object({
+  level: zod.z.enum([
+    "DEBUG",
+    "INFO",
+    "WARN",
+    "ERROR"
+  ]),
+  message: zod.z.string(),
+  data: SerializableJsonSchema.optional()
+});
+var RedactSchema = zod.z.object({
+  paths: zod.z.array(zod.z.string())
+});
+var RetryOptionsSchema = zod.z.object({
+  /** The maximum number of times to retry the request. */
+  limit: zod.z.number().optional(),
+  /** The exponential factor to use when calculating the next retry time. */
+  factor: zod.z.number().optional(),
+  /** The minimum amount of time to wait before retrying the request. */
+  minTimeoutInMs: zod.z.number().optional(),
+  /** The maximum amount of time to wait before retrying the request. */
+  maxTimeoutInMs: zod.z.number().optional(),
+  /** Whether to randomize the retry time. */
+  randomize: zod.z.boolean().optional()
+});
+var RunTaskOptionsSchema = zod.z.object({
+  /** The name of the Task is required. This is displayed on the Task in the logs. */
+  name: zod.z.string().optional(),
+  /** The Task will wait and only start at the specified Date  */
+  delayUntil: zod.z.coerce.date().optional(),
+  /** Retry options */
+  retry: RetryOptionsSchema.optional(),
+  /** The icon for the Task, it will appear in the logs.
+  *  You can use the name of a company in lowercase, e.g. "github".
+  *  Or any icon name that [Tabler Icons](https://tabler-icons.io/) supports. */
+  icon: zod.z.string().optional(),
+  /** The key for the Task that you want to appear in the logs */
+  displayKey: zod.z.string().optional(),
+  /** A description of the Task */
+  description: zod.z.string().optional(),
+  /** Properties that are displayed in the logs */
+  properties: zod.z.array(DisplayPropertySchema).optional(),
+  /** The input params to the Task, will be displayed in the logs  */
+  params: zod.z.any(),
+  /** The style of the log entry. */
+  style: StyleSchema.optional(),
+  /** Allows you to expose a `task.callbackUrl` to use in your tasks. Enabling this feature will cause the task to return the data sent to the callbackUrl instead of the usual async callback result. */
+  callback: zod.z.object({
+    /** Causes the task to wait for and return the data of the first request sent to `task.callbackUrl`. */
+    enabled: zod.z.boolean(),
+    /** Time to wait for the first request to `task.callbackUrl`. Default: One hour. */
+    timeoutInSeconds: zod.z.number()
+  }).partial().optional(),
+  /** Allows you to link the Integration connection in the logs. This is handled automatically in integrations.  */
+  connectionKey: zod.z.string().optional(),
+  /** An operation you want to perform on the Trigger.dev platform, current only "fetch", "fetch-response", and "fetch-poll" is supported. If you wish to `fetch` use [`io.backgroundFetch()`](https://trigger.dev/docs/sdk/io/backgroundfetch) instead. */
+  operation: zod.z.enum([
+    "fetch",
+    "fetch-response",
+    "fetch-poll"
+  ]).optional(),
+  /** A No Operation means that the code won't be executed. This is used internally to implement features like [io.wait()](https://trigger.dev/docs/sdk/io/wait).  */
+  noop: zod.z.boolean().default(false),
+  redact: RedactSchema.optional(),
+  parallel: zod.z.boolean().optional()
+});
+var RunTaskBodyInputSchema = RunTaskOptionsSchema.extend({
+  idempotencyKey: zod.z.string(),
+  parentId: zod.z.string().optional()
+});
+var RunTaskBodyOutputSchema = RunTaskBodyInputSchema.extend({
+  properties: zod.z.array(DisplayPropertySchema.partial()).optional(),
+  params: DeserializedJsonSchema.optional().nullable(),
+  callback: zod.z.object({
+    enabled: zod.z.boolean(),
+    timeoutInSeconds: zod.z.number().default(3600)
+  }).optional()
+});
+var RunTaskResponseWithCachedTasksBodySchema = zod.z.object({
+  task: ServerTaskSchema,
+  cachedTasks: zod.z.object({
+    tasks: zod.z.array(CachedTaskSchema),
+    cursor: zod.z.string().optional()
+  }).optional()
+});
+var CompleteTaskBodyInputSchema = RunTaskBodyInputSchema.pick({
+  properties: true,
+  description: true,
+  params: true
+}).extend({
+  output: SerializableJsonSchema.optional().transform((v) => v ? DeserializedJsonSchema.parse(JSON.parse(JSON.stringify(v))) : {})
+});
+var CompleteTaskBodyV2InputSchema = RunTaskBodyInputSchema.pick({
+  properties: true,
+  description: true,
+  params: true
+}).extend({
+  output: zod.z.string().optional()
+});
+var FailTaskBodyInputSchema = zod.z.object({
+  error: ErrorWithStackSchema
+});
+var NormalizedRequestSchema = zod.z.object({
+  headers: zod.z.record(zod.z.string()),
+  method: zod.z.string(),
+  query: zod.z.record(zod.z.string()),
+  url: zod.z.string(),
+  body: zod.z.any()
+});
+var NormalizedResponseSchema = zod.z.object({
+  status: zod.z.number(),
+  body: zod.z.any(),
+  headers: zod.z.record(zod.z.string()).optional()
+});
+var HttpSourceResponseSchema = zod.z.object({
+  response: NormalizedResponseSchema,
+  events: zod.z.array(RawEventSchema),
+  metadata: HttpSourceResponseMetadataSchema.optional()
+});
+var WebhookDeliveryResponseSchema = zod.z.object({
+  response: NormalizedResponseSchema,
+  verified: zod.z.boolean(),
+  error: zod.z.string().optional()
+});
+var RegisterTriggerBodySchemaV1 = zod.z.object({
+  rule: EventRuleSchema,
+  source: SourceMetadataV1Schema
+});
+var RegisterTriggerBodySchemaV2 = zod.z.object({
+  rule: EventRuleSchema,
+  source: SourceMetadataV2Schema,
+  accountId: zod.z.string().optional()
+});
+var InitializeTriggerBodySchema = zod.z.object({
+  id: zod.z.string(),
+  params: zod.z.any(),
+  accountId: zod.z.string().optional(),
+  metadata: zod.z.any().optional()
+});
+var RegisterCommonScheduleBodySchema = zod.z.object({
+  /** A unique id for the schedule. This is used to identify and unregister the schedule later. */
+  id: zod.z.string(),
+  /** Any additional metadata about the schedule. */
+  metadata: zod.z.any(),
+  /** An optional Account ID to associate with runs triggered by this schedule */
+  accountId: zod.z.string().optional()
+});
+var RegisterIntervalScheduleBodySchema = RegisterCommonScheduleBodySchema.merge(IntervalMetadataSchema);
+var InitializeCronScheduleBodySchema = RegisterCommonScheduleBodySchema.merge(CronMetadataSchema);
+var RegisterScheduleBodySchema = zod.z.discriminatedUnion("type", [
+  RegisterIntervalScheduleBodySchema,
+  InitializeCronScheduleBodySchema
+]);
+var RegisterScheduleResponseBodySchema = zod.z.object({
+  id: zod.z.string(),
+  schedule: ScheduleMetadataSchema,
+  metadata: zod.z.any(),
+  active: zod.z.boolean()
+});
+var CreateExternalConnectionBodySchema = zod.z.object({
+  accessToken: zod.z.string(),
+  type: zod.z.enum([
+    "oauth2"
+  ]),
+  scopes: zod.z.array(zod.z.string()).optional(),
+  metadata: zod.z.any()
+});
+var GetRunStatusesSchema = zod.z.object({
+  run: zod.z.object({
+    id: zod.z.string(),
+    status: RunStatusSchema,
+    output: zod.z.any().optional()
+  }),
+  statuses: zod.z.array(JobRunStatusRecordSchema)
+});
+var InvokeJobResponseSchema = zod.z.object({
+  id: zod.z.string()
+});
+var InvokeJobRequestBodySchema = zod.z.object({
+  payload: zod.z.any(),
+  context: zod.z.any().optional(),
+  options: zod.z.object({
+    accountId: zod.z.string().optional(),
+    callbackUrl: zod.z.string().optional()
+  }).optional()
+});
+var InvokeOptionsSchema = zod.z.object({
+  accountId: zod.z.string().optional(),
+  idempotencyKey: zod.z.string().optional(),
+  context: zod.z.any().optional(),
+  callbackUrl: zod.z.string().optional()
+});
+var EphemeralEventDispatcherRequestBodySchema = zod.z.object({
+  url: zod.z.string(),
+  name: zod.z.string().or(zod.z.array(zod.z.string())),
+  source: zod.z.string().optional(),
+  filter: EventFilterSchema.optional(),
+  contextFilter: EventFilterSchema.optional(),
+  accountId: zod.z.string().optional(),
+  timeoutInSeconds: zod.z.number().int().positive().min(10).max(60 * 60 * 24 * 365).default(3600)
+});
+var EphemeralEventDispatcherResponseBodySchema = zod.z.object({
+  id: zod.z.string()
+});
+var KeyValueStoreResponseBodySchema = zod.z.discriminatedUnion("action", [
+  zod.z.object({
+    action: zod.z.literal("DELETE"),
+    key: zod.z.string(),
+    deleted: zod.z.boolean()
+  }),
+  zod.z.object({
+    action: zod.z.literal("GET"),
+    key: zod.z.string(),
+    value: zod.z.string().optional()
+  }),
+  zod.z.object({
+    action: zod.z.literal("HAS"),
+    key: zod.z.string(),
+    has: zod.z.boolean()
+  }),
+  zod.z.object({
+    action: zod.z.literal("SET"),
+    key: zod.z.string(),
+    value: zod.z.string().optional()
+  })
+]);
+var MISSING_CONNECTION_NOTIFICATION = "dev.trigger.notifications.missingConnection";
+var MISSING_CONNECTION_RESOLVED_NOTIFICATION = "dev.trigger.notifications.missingConnectionResolved";
+var CommonMissingConnectionNotificationPayloadSchema = zod.z.object({
+  id: zod.z.string(),
+  client: zod.z.object({
+    id: zod.z.string(),
+    title: zod.z.string(),
+    scopes: zod.z.array(zod.z.string()),
+    createdAt: zod.z.coerce.date(),
+    updatedAt: zod.z.coerce.date()
+  }),
+  authorizationUrl: zod.z.string()
+});
+var MissingDeveloperConnectionNotificationPayloadSchema = CommonMissingConnectionNotificationPayloadSchema.extend({
+  type: zod.z.literal("DEVELOPER")
+});
+var MissingExternalConnectionNotificationPayloadSchema = CommonMissingConnectionNotificationPayloadSchema.extend({
+  type: zod.z.literal("EXTERNAL"),
+  account: zod.z.object({
+    id: zod.z.string(),
+    metadata: zod.z.any()
+  })
+});
+var MissingConnectionNotificationPayloadSchema = zod.z.discriminatedUnion("type", [
+  MissingDeveloperConnectionNotificationPayloadSchema,
+  MissingExternalConnectionNotificationPayloadSchema
+]);
+var CommonMissingConnectionNotificationResolvedPayloadSchema = zod.z.object({
+  id: zod.z.string(),
+  client: zod.z.object({
+    id: zod.z.string(),
+    title: zod.z.string(),
+    scopes: zod.z.array(zod.z.string()),
+    createdAt: zod.z.coerce.date(),
+    updatedAt: zod.z.coerce.date(),
+    integrationIdentifier: zod.z.string(),
+    integrationAuthMethod: zod.z.string()
+  }),
+  expiresAt: zod.z.coerce.date()
+});
+var MissingDeveloperConnectionResolvedNotificationPayloadSchema = CommonMissingConnectionNotificationResolvedPayloadSchema.extend({
+  type: zod.z.literal("DEVELOPER")
+});
+var MissingExternalConnectionResolvedNotificationPayloadSchema = CommonMissingConnectionNotificationResolvedPayloadSchema.extend({
+  type: zod.z.literal("EXTERNAL"),
+  account: zod.z.object({
+    id: zod.z.string(),
+    metadata: zod.z.any()
+  })
+});
+var MissingConnectionResolvedNotificationPayloadSchema = zod.z.discriminatedUnion("type", [
+  MissingDeveloperConnectionResolvedNotificationPayloadSchema,
+  MissingExternalConnectionResolvedNotificationPayloadSchema
+]);
+var FetchRetryHeadersStrategySchema = 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: EventFilterSchema.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")
+});
+var FetchRetryBackoffStrategySchema = RetryOptionsSchema.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: EventFilterSchema.optional()
+});
+var FetchRetryStrategySchema = zod.z.discriminatedUnion("strategy", [
+  FetchRetryHeadersStrategySchema,
+  FetchRetryBackoffStrategySchema
+]);
+var FetchRequestInitSchema = zod.z.object({
+  /** The HTTP method to use for the request. */
+  method: zod.z.string().optional(),
+  /** Any headers to send with the request. Note that you can use [redactString](https://trigger.dev/docs/sdk/redactString) to prevent sensitive information from being stored (e.g. in the logs), like API keys and tokens. */
+  headers: zod.z.record(zod.z.union([
+    zod.z.string(),
+    RedactStringSchema
+  ])).optional(),
+  /** The body of the request. */
+  body: zod.z.union([
+    zod.z.string(),
+    zod.z.instanceof(ArrayBuffer)
+  ]).optional()
+});
+var FetchRetryOptionsSchema = zod.z.record(FetchRetryStrategySchema);
+var FetchTimeoutOptionsSchema = zod.z.object({
+  durationInMs: zod.z.number(),
+  retry: RetryOptionsSchema.optional()
+});
+var FetchOperationSchema = zod.z.object({
+  url: zod.z.string(),
+  requestInit: FetchRequestInitSchema.optional(),
+  retry: zod.z.record(FetchRetryStrategySchema).optional(),
+  timeout: FetchTimeoutOptionsSchema.optional()
+});
+var FetchPollOperationSchema = zod.z.object({
+  url: zod.z.string(),
+  interval: zod.z.number().int().positive().min(10).max(600).default(10),
+  timeout: zod.z.number().int().positive().min(30).max(3600).default(600),
+  responseFilter: ResponseFilterSchema,
+  requestInit: FetchRequestInitSchema.optional(),
+  requestTimeout: FetchTimeoutOptionsSchema.optional()
+});
+var GetEventSchema = zod.z.object({
+  /** The event id */
+  id: zod.z.string(),
+  /** The event name */
+  name: zod.z.string(),
+  /** When the event was created */
+  createdAt: zod.z.coerce.date(),
+  /** When the event was last updated */
+  updatedAt: zod.z.coerce.date(),
+  /** The runs that were triggered by the event */
+  runs: zod.z.array(zod.z.object({
+    /** The Run id */
+    id: zod.z.string(),
+    /** The Run status */
+    status: RunStatusSchema,
+    /** When the run started */
+    startedAt: zod.z.coerce.date().optional().nullable(),
+    /** When the run completed */
+    completedAt: zod.z.coerce.date().optional().nullable()
+  }))
+});
+var CancelRunsForEventSchema = zod.z.object({
+  cancelledRunIds: zod.z.array(zod.z.string()),
+  failedToCancelRunIds: zod.z.array(zod.z.string())
+});
+var RequestWithRawBodySchema = zod.z.object({
+  url: zod.z.string(),
+  method: zod.z.string(),
+  headers: zod.z.record(zod.z.string()),
+  rawBody: zod.z.string()
+});
+var CancelRunsForJobSchema = zod.z.object({
+  cancelledRunIds: zod.z.array(zod.z.string()),
+  failedToCancelRunIds: zod.z.array(zod.z.string())
+});
+
+exports.ApiEventLogSchema = ApiEventLogSchema;
+exports.AutoYieldConfigSchema = AutoYieldConfigSchema;
+exports.AutoYieldMetadataSchema = AutoYieldMetadataSchema;
+exports.CachedTaskSchema = CachedTaskSchema;
+exports.CancelRunsForEventSchema = CancelRunsForEventSchema;
+exports.CancelRunsForJobSchema = CancelRunsForJobSchema;
+exports.CommonMissingConnectionNotificationPayloadSchema = CommonMissingConnectionNotificationPayloadSchema;
+exports.CommonMissingConnectionNotificationResolvedPayloadSchema = CommonMissingConnectionNotificationResolvedPayloadSchema;
+exports.CompleteTaskBodyInputSchema = CompleteTaskBodyInputSchema;
+exports.CompleteTaskBodyV2InputSchema = CompleteTaskBodyV2InputSchema;
+exports.ConcurrencyLimitOptionsSchema = ConcurrencyLimitOptionsSchema;
+exports.ConnectionAuthSchema = ConnectionAuthSchema;
+exports.CreateExternalConnectionBodySchema = CreateExternalConnectionBodySchema;
+exports.CreateRunResponseBodySchema = CreateRunResponseBodySchema;
+exports.CronMetadataSchema = CronMetadataSchema;
+exports.CronOptionsSchema = CronOptionsSchema;
+exports.DELIVER_WEBHOOK_REQUEST = DELIVER_WEBHOOK_REQUEST;
+exports.DeliverEventResponseSchema = DeliverEventResponseSchema;
+exports.DeserializedJsonSchema = DeserializedJsonSchema;
+exports.DisplayPropertiesSchema = DisplayPropertiesSchema;
+exports.DisplayPropertySchema = DisplayPropertySchema;
+exports.DynamicTriggerEndpointMetadataSchema = DynamicTriggerEndpointMetadataSchema;
+exports.DynamicTriggerMetadataSchema = DynamicTriggerMetadataSchema;
+exports.EndpointHeadersSchema = EndpointHeadersSchema;
+exports.EndpointIndexErrorSchema = EndpointIndexErrorSchema;
+exports.EphemeralEventDispatcherRequestBodySchema = EphemeralEventDispatcherRequestBodySchema;
+exports.EphemeralEventDispatcherResponseBodySchema = EphemeralEventDispatcherResponseBodySchema;
+exports.ErrorWithStackSchema = ErrorWithStackSchema;
+exports.EventExampleSchema = EventExampleSchema;
+exports.EventFilterSchema = EventFilterSchema;
+exports.EventRuleSchema = EventRuleSchema;
+exports.EventSpecificationSchema = EventSpecificationSchema;
+exports.ExecuteJobHeadersSchema = ExecuteJobHeadersSchema;
+exports.ExecuteJobRunMetadataSchema = ExecuteJobRunMetadataSchema;
+exports.FailTaskBodyInputSchema = FailTaskBodyInputSchema;
+exports.FetchOperationSchema = FetchOperationSchema;
+exports.FetchPollOperationSchema = FetchPollOperationSchema;
+exports.FetchRequestInitSchema = FetchRequestInitSchema;
+exports.FetchRetryBackoffStrategySchema = FetchRetryBackoffStrategySchema;
+exports.FetchRetryHeadersStrategySchema = FetchRetryHeadersStrategySchema;
+exports.FetchRetryOptionsSchema = FetchRetryOptionsSchema;
+exports.FetchRetryStrategySchema = FetchRetryStrategySchema;
+exports.FetchTimeoutOptionsSchema = FetchTimeoutOptionsSchema;
+exports.GetEndpointIndexResponseSchema = GetEndpointIndexResponseSchema;
+exports.GetEventSchema = GetEventSchema;
+exports.GetRunSchema = GetRunSchema;
+exports.GetRunStatusesSchema = GetRunStatusesSchema;
+exports.GetRunsSchema = GetRunsSchema;
+exports.HTTPMethodUnionSchema = HTTPMethodUnionSchema;
+exports.HandleTriggerSourceSchema = HandleTriggerSourceSchema;
+exports.HttpEndpointRequestHeadersSchema = HttpEndpointRequestHeadersSchema;
+exports.HttpSourceRequestHeadersSchema = HttpSourceRequestHeadersSchema;
+exports.HttpSourceResponseSchema = HttpSourceResponseSchema;
+exports.IndexEndpointResponseSchema = IndexEndpointResponseSchema;
+exports.InitializeCronScheduleBodySchema = InitializeCronScheduleBodySchema;
+exports.InitializeTriggerBodySchema = InitializeTriggerBodySchema;
+exports.IntegrationConfigSchema = IntegrationConfigSchema;
+exports.IntegrationMetadataSchema = IntegrationMetadataSchema;
+exports.IntervalMetadataSchema = IntervalMetadataSchema;
+exports.IntervalOptionsSchema = IntervalOptionsSchema;
+exports.InvokeJobRequestBodySchema = InvokeJobRequestBodySchema;
+exports.InvokeJobResponseSchema = InvokeJobResponseSchema;
+exports.InvokeOptionsSchema = InvokeOptionsSchema;
+exports.InvokeTriggerMetadataSchema = InvokeTriggerMetadataSchema;
+exports.JobMetadataSchema = JobMetadataSchema;
+exports.JobRunStatusRecordSchema = JobRunStatusRecordSchema;
+exports.KeyValueStoreResponseBodySchema = KeyValueStoreResponseBodySchema;
+exports.LogMessageSchema = LogMessageSchema;
+exports.MISSING_CONNECTION_NOTIFICATION = MISSING_CONNECTION_NOTIFICATION;
+exports.MISSING_CONNECTION_RESOLVED_NOTIFICATION = MISSING_CONNECTION_RESOLVED_NOTIFICATION;
+exports.MissingConnectionNotificationPayloadSchema = MissingConnectionNotificationPayloadSchema;
+exports.MissingConnectionResolvedNotificationPayloadSchema = MissingConnectionResolvedNotificationPayloadSchema;
+exports.MissingDeveloperConnectionNotificationPayloadSchema = MissingDeveloperConnectionNotificationPayloadSchema;
+exports.MissingDeveloperConnectionResolvedNotificationPayloadSchema = MissingDeveloperConnectionResolvedNotificationPayloadSchema;
+exports.MissingExternalConnectionNotificationPayloadSchema = MissingExternalConnectionNotificationPayloadSchema;
+exports.MissingExternalConnectionResolvedNotificationPayloadSchema = MissingExternalConnectionResolvedNotificationPayloadSchema;
+exports.NormalizedRequestSchema = NormalizedRequestSchema;
+exports.NormalizedResponseSchema = NormalizedResponseSchema;
+exports.PongErrorResponseSchema = PongErrorResponseSchema;
+exports.PongResponseSchema = PongResponseSchema;
+exports.PongSuccessResponseSchema = PongSuccessResponseSchema;
+exports.PreprocessRunBodySchema = PreprocessRunBodySchema;
+exports.PreprocessRunResponseSchema = PreprocessRunResponseSchema;
+exports.QueueOptionsSchema = QueueOptionsSchema;
+exports.REGISTER_SOURCE_EVENT_V1 = REGISTER_SOURCE_EVENT_V1;
+exports.REGISTER_SOURCE_EVENT_V2 = REGISTER_SOURCE_EVENT_V2;
+exports.REGISTER_WEBHOOK = REGISTER_WEBHOOK;
+exports.RawEventSchema = RawEventSchema;
+exports.RedactSchema = RedactSchema;
+exports.RedactStringSchema = RedactStringSchema;
+exports.RegisterDynamicSchedulePayloadSchema = RegisterDynamicSchedulePayloadSchema;
+exports.RegisterHTTPTriggerSourceBodySchema = RegisterHTTPTriggerSourceBodySchema;
+exports.RegisterIntervalScheduleBodySchema = RegisterIntervalScheduleBodySchema;
+exports.RegisterSMTPTriggerSourceBodySchema = RegisterSMTPTriggerSourceBodySchema;
+exports.RegisterSQSTriggerSourceBodySchema = RegisterSQSTriggerSourceBodySchema;
+exports.RegisterScheduleBodySchema = RegisterScheduleBodySchema;
+exports.RegisterScheduleResponseBodySchema = RegisterScheduleResponseBodySchema;
+exports.RegisterSourceChannelBodySchema = RegisterSourceChannelBodySchema;
+exports.RegisterSourceEventSchemaV1 = RegisterSourceEventSchemaV1;
+exports.RegisterSourceEventSchemaV2 = RegisterSourceEventSchemaV2;
+exports.RegisterTriggerBodySchemaV1 = RegisterTriggerBodySchemaV1;
+exports.RegisterTriggerBodySchemaV2 = RegisterTriggerBodySchemaV2;
+exports.RegisterTriggerSourceSchema = RegisterTriggerSourceSchema;
+exports.RegisterWebhookPayloadSchema = RegisterWebhookPayloadSchema;
+exports.RegisterWebhookSourceSchema = RegisterWebhookSourceSchema;
+exports.RequestFilterSchema = RequestFilterSchema;
+exports.RequestWithRawBodySchema = RequestWithRawBodySchema;
+exports.ResponseFilterSchema = ResponseFilterSchema;
+exports.RetryOptionsSchema = RetryOptionsSchema;
+exports.RunJobAutoYieldExecutionErrorSchema = RunJobAutoYieldExecutionErrorSchema;
+exports.RunJobAutoYieldRateLimitErrorSchema = RunJobAutoYieldRateLimitErrorSchema;
+exports.RunJobAutoYieldWithCompletedTaskExecutionErrorSchema = RunJobAutoYieldWithCompletedTaskExecutionErrorSchema;
+exports.RunJobBodySchema = RunJobBodySchema;
+exports.RunJobCanceledWithTaskSchema = RunJobCanceledWithTaskSchema;
+exports.RunJobErrorResponseSchema = RunJobErrorResponseSchema;
+exports.RunJobErrorSchema = RunJobErrorSchema;
+exports.RunJobInvalidPayloadErrorSchema = RunJobInvalidPayloadErrorSchema;
+exports.RunJobResponseSchema = RunJobResponseSchema;
+exports.RunJobResumeWithParallelTaskSchema = RunJobResumeWithParallelTaskSchema;
+exports.RunJobResumeWithTaskSchema = RunJobResumeWithTaskSchema;
+exports.RunJobRetryWithTaskSchema = RunJobRetryWithTaskSchema;
+exports.RunJobSuccessSchema = RunJobSuccessSchema;
+exports.RunJobUnresolvedAuthErrorSchema = RunJobUnresolvedAuthErrorSchema;
+exports.RunJobYieldExecutionErrorSchema = RunJobYieldExecutionErrorSchema;
+exports.RunSourceContextSchema = RunSourceContextSchema;
+exports.RunStatusSchema = RunStatusSchema;
+exports.RunTaskBodyInputSchema = RunTaskBodyInputSchema;
+exports.RunTaskBodyOutputSchema = RunTaskBodyOutputSchema;
+exports.RunTaskOptionsSchema = RunTaskOptionsSchema;
+exports.RunTaskResponseWithCachedTasksBodySchema = RunTaskResponseWithCachedTasksBodySchema;
+exports.RunTaskSchema = RunTaskSchema;
+exports.RuntimeEnvironmentTypeSchema = RuntimeEnvironmentTypeSchema;
+exports.SCHEDULED_EVENT = SCHEDULED_EVENT;
+exports.ScheduleMetadataSchema = ScheduleMetadataSchema;
+exports.ScheduledPayloadSchema = ScheduledPayloadSchema;
+exports.ScheduledTriggerMetadataSchema = ScheduledTriggerMetadataSchema;
+exports.SchemaErrorSchema = SchemaErrorSchema;
+exports.SendBulkEventsBodySchema = SendBulkEventsBodySchema;
+exports.SendEventBodySchema = SendEventBodySchema;
+exports.SendEventOptionsSchema = SendEventOptionsSchema;
+exports.SerializableJsonSchema = SerializableJsonSchema;
+exports.ServerTaskSchema = ServerTaskSchema;
+exports.SourceMetadataV2Schema = SourceMetadataV2Schema;
+exports.StaticTriggerMetadataSchema = StaticTriggerMetadataSchema;
+exports.StatusHistorySchema = StatusHistorySchema;
+exports.StatusUpdateSchema = StatusUpdateSchema;
+exports.StatusUpdateStateSchema = StatusUpdateStateSchema;
+exports.StyleSchema = StyleSchema;
+exports.TaskSchema = TaskSchema;
+exports.TaskStatusSchema = TaskStatusSchema;
+exports.TriggerHelpSchema = TriggerHelpSchema;
+exports.TriggerMetadataSchema = TriggerMetadataSchema;
+exports.TriggerSourceSchema = TriggerSourceSchema;
+exports.UpdateTriggerSourceBodyV1Schema = UpdateTriggerSourceBodyV1Schema;
+exports.UpdateTriggerSourceBodyV2Schema = UpdateTriggerSourceBodyV2Schema;
+exports.UpdateWebhookBodySchema = UpdateWebhookBodySchema;
+exports.ValidateErrorResponseSchema = ValidateErrorResponseSchema;
+exports.ValidateResponseSchema = ValidateResponseSchema;
+exports.ValidateSuccessResponseSchema = ValidateSuccessResponseSchema;
+exports.WebhookContextMetadataSchema = WebhookContextMetadataSchema;
+exports.WebhookDeliveryResponseSchema = WebhookDeliveryResponseSchema;
+exports.WebhookMetadataSchema = WebhookMetadataSchema;
+exports.WebhookSourceRequestHeadersSchema = WebhookSourceRequestHeadersSchema;
+exports.addMissingVersionField = addMissingVersionField;
+exports.parseEndpointIndexStats = parseEndpointIndexStats;
+exports.stringPatternMatchers = stringPatternMatchers;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.js.map