@trigger.dev/core 2.2.11 → 2.3.1

package/dist/index.js

@@ -1,399 +1,10 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet = (obj, member, value, setter) => {
-  __accessCheck(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
-};
-var __privateMethod = (obj, member, method) => {
-  __accessCheck(obj, member, "access private method");
-  return method;
-};
+'use strict';
 
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  API_VERSIONS: () => API_VERSIONS,
-  ApiEventLogSchema: () => ApiEventLogSchema,
-  AutoYieldConfigSchema: () => AutoYieldConfigSchema,
-  AutoYieldMetadataSchema: () => AutoYieldMetadataSchema,
-  CachedTaskSchema: () => CachedTaskSchema,
-  CancelRunsForEventSchema: () => CancelRunsForEventSchema,
-  CommonMissingConnectionNotificationPayloadSchema: () => CommonMissingConnectionNotificationPayloadSchema,
-  CommonMissingConnectionNotificationResolvedPayloadSchema: () => CommonMissingConnectionNotificationResolvedPayloadSchema,
-  CompleteTaskBodyInputSchema: () => CompleteTaskBodyInputSchema,
-  CompleteTaskBodyV2InputSchema: () => CompleteTaskBodyV2InputSchema,
-  ConcurrencyLimitOptionsSchema: () => ConcurrencyLimitOptionsSchema,
-  ConnectionAuthSchema: () => ConnectionAuthSchema,
-  CreateExternalConnectionBodySchema: () => CreateExternalConnectionBodySchema,
-  CreateRunResponseBodySchema: () => CreateRunResponseBodySchema,
-  CronMetadataSchema: () => CronMetadataSchema,
-  CronOptionsSchema: () => CronOptionsSchema,
-  DELIVER_WEBHOOK_REQUEST: () => DELIVER_WEBHOOK_REQUEST,
-  DeliverEventResponseSchema: () => DeliverEventResponseSchema,
-  DeserializedJsonSchema: () => DeserializedJsonSchema,
-  DisplayPropertiesSchema: () => DisplayPropertiesSchema,
-  DisplayPropertySchema: () => DisplayPropertySchema,
-  DynamicTriggerEndpointMetadataSchema: () => DynamicTriggerEndpointMetadataSchema,
-  DynamicTriggerMetadataSchema: () => DynamicTriggerMetadataSchema,
-  EndpointHeadersSchema: () => EndpointHeadersSchema,
-  EndpointIndexErrorSchema: () => EndpointIndexErrorSchema,
-  EphemeralEventDispatcherRequestBodySchema: () => EphemeralEventDispatcherRequestBodySchema,
-  EphemeralEventDispatcherResponseBodySchema: () => EphemeralEventDispatcherResponseBodySchema,
-  ErrorWithStackSchema: () => ErrorWithStackSchema,
-  EventExampleSchema: () => EventExampleSchema,
-  EventFilterSchema: () => EventFilterSchema,
-  EventRuleSchema: () => EventRuleSchema,
-  EventSpecificationSchema: () => EventSpecificationSchema,
-  ExecuteJobHeadersSchema: () => ExecuteJobHeadersSchema,
-  ExecuteJobRunMetadataSchema: () => ExecuteJobRunMetadataSchema,
-  FailTaskBodyInputSchema: () => FailTaskBodyInputSchema,
-  FetchOperationSchema: () => FetchOperationSchema,
-  FetchPollOperationSchema: () => FetchPollOperationSchema,
-  FetchRequestInitSchema: () => FetchRequestInitSchema,
-  FetchRetryBackoffStrategySchema: () => FetchRetryBackoffStrategySchema,
-  FetchRetryHeadersStrategySchema: () => FetchRetryHeadersStrategySchema,
-  FetchRetryOptionsSchema: () => FetchRetryOptionsSchema,
-  FetchRetryStrategySchema: () => FetchRetryStrategySchema,
-  FetchTimeoutOptionsSchema: () => FetchTimeoutOptionsSchema,
-  GetEndpointIndexResponseSchema: () => GetEndpointIndexResponseSchema,
-  GetEventSchema: () => GetEventSchema,
-  GetRunSchema: () => GetRunSchema,
-  GetRunStatusesSchema: () => GetRunStatusesSchema,
-  GetRunsSchema: () => GetRunsSchema,
-  HTTPMethodUnionSchema: () => HTTPMethodUnionSchema,
-  HandleTriggerSourceSchema: () => HandleTriggerSourceSchema,
-  HttpEndpointRequestHeadersSchema: () => HttpEndpointRequestHeadersSchema,
-  HttpSourceRequestHeadersSchema: () => HttpSourceRequestHeadersSchema,
-  HttpSourceResponseSchema: () => HttpSourceResponseSchema,
-  IndexEndpointResponseSchema: () => IndexEndpointResponseSchema,
-  InitializeCronScheduleBodySchema: () => InitializeCronScheduleBodySchema,
-  InitializeTriggerBodySchema: () => InitializeTriggerBodySchema,
-  IntegrationConfigSchema: () => IntegrationConfigSchema,
-  IntegrationMetadataSchema: () => IntegrationMetadataSchema,
-  IntervalMetadataSchema: () => IntervalMetadataSchema,
-  IntervalOptionsSchema: () => IntervalOptionsSchema,
-  InvokeJobRequestBodySchema: () => InvokeJobRequestBodySchema,
-  InvokeJobResponseSchema: () => InvokeJobResponseSchema,
-  InvokeOptionsSchema: () => InvokeOptionsSchema,
-  InvokeTriggerMetadataSchema: () => InvokeTriggerMetadataSchema,
-  JobMetadataSchema: () => JobMetadataSchema,
-  JobRunStatusRecordSchema: () => JobRunStatusRecordSchema,
-  KeyValueStoreResponseBodySchema: () => KeyValueStoreResponseBodySchema,
-  LogMessageSchema: () => LogMessageSchema,
-  Logger: () => Logger,
-  MISSING_CONNECTION_NOTIFICATION: () => MISSING_CONNECTION_NOTIFICATION,
-  MISSING_CONNECTION_RESOLVED_NOTIFICATION: () => MISSING_CONNECTION_RESOLVED_NOTIFICATION,
-  MissingConnectionNotificationPayloadSchema: () => MissingConnectionNotificationPayloadSchema,
-  MissingConnectionResolvedNotificationPayloadSchema: () => MissingConnectionResolvedNotificationPayloadSchema,
-  MissingDeveloperConnectionNotificationPayloadSchema: () => MissingDeveloperConnectionNotificationPayloadSchema,
-  MissingDeveloperConnectionResolvedNotificationPayloadSchema: () => MissingDeveloperConnectionResolvedNotificationPayloadSchema,
-  MissingExternalConnectionNotificationPayloadSchema: () => MissingExternalConnectionNotificationPayloadSchema,
-  MissingExternalConnectionResolvedNotificationPayloadSchema: () => MissingExternalConnectionResolvedNotificationPayloadSchema,
-  NormalizedRequestSchema: () => NormalizedRequestSchema,
-  NormalizedResponseSchema: () => NormalizedResponseSchema,
-  PLATFORM_FEATURES: () => PLATFORM_FEATURES,
-  PongErrorResponseSchema: () => PongErrorResponseSchema,
-  PongResponseSchema: () => PongResponseSchema,
-  PongSuccessResponseSchema: () => PongSuccessResponseSchema,
-  PreprocessRunBodySchema: () => PreprocessRunBodySchema,
-  PreprocessRunResponseSchema: () => PreprocessRunResponseSchema,
-  QueueOptionsSchema: () => QueueOptionsSchema,
-  REGISTER_SOURCE_EVENT_V1: () => REGISTER_SOURCE_EVENT_V1,
-  REGISTER_SOURCE_EVENT_V2: () => REGISTER_SOURCE_EVENT_V2,
-  REGISTER_WEBHOOK: () => REGISTER_WEBHOOK,
-  RawEventSchema: () => RawEventSchema,
-  RedactSchema: () => RedactSchema,
-  RedactStringSchema: () => RedactStringSchema,
-  RegisterDynamicSchedulePayloadSchema: () => RegisterDynamicSchedulePayloadSchema,
-  RegisterHTTPTriggerSourceBodySchema: () => RegisterHTTPTriggerSourceBodySchema,
-  RegisterIntervalScheduleBodySchema: () => RegisterIntervalScheduleBodySchema,
-  RegisterSMTPTriggerSourceBodySchema: () => RegisterSMTPTriggerSourceBodySchema,
-  RegisterSQSTriggerSourceBodySchema: () => RegisterSQSTriggerSourceBodySchema,
-  RegisterScheduleBodySchema: () => RegisterScheduleBodySchema,
-  RegisterScheduleResponseBodySchema: () => RegisterScheduleResponseBodySchema,
-  RegisterSourceChannelBodySchema: () => RegisterSourceChannelBodySchema,
-  RegisterSourceEventSchemaV1: () => RegisterSourceEventSchemaV1,
-  RegisterSourceEventSchemaV2: () => RegisterSourceEventSchemaV2,
-  RegisterTriggerBodySchemaV1: () => RegisterTriggerBodySchemaV1,
-  RegisterTriggerBodySchemaV2: () => RegisterTriggerBodySchemaV2,
-  RegisterTriggerSourceSchema: () => RegisterTriggerSourceSchema,
-  RegisterWebhookPayloadSchema: () => RegisterWebhookPayloadSchema,
-  RegisterWebhookSourceSchema: () => RegisterWebhookSourceSchema,
-  RequestFilterSchema: () => RequestFilterSchema,
-  RequestWithRawBodySchema: () => RequestWithRawBodySchema,
-  ResponseFilterSchema: () => ResponseFilterSchema,
-  RetryOptionsSchema: () => RetryOptionsSchema,
-  RunJobAutoYieldExecutionErrorSchema: () => RunJobAutoYieldExecutionErrorSchema,
-  RunJobAutoYieldWithCompletedTaskExecutionErrorSchema: () => RunJobAutoYieldWithCompletedTaskExecutionErrorSchema,
-  RunJobBodySchema: () => RunJobBodySchema,
-  RunJobCanceledWithTaskSchema: () => RunJobCanceledWithTaskSchema,
-  RunJobErrorResponseSchema: () => RunJobErrorResponseSchema,
-  RunJobErrorSchema: () => RunJobErrorSchema,
-  RunJobInvalidPayloadErrorSchema: () => RunJobInvalidPayloadErrorSchema,
-  RunJobResponseSchema: () => RunJobResponseSchema,
-  RunJobResumeWithParallelTaskSchema: () => RunJobResumeWithParallelTaskSchema,
-  RunJobResumeWithTaskSchema: () => RunJobResumeWithTaskSchema,
-  RunJobRetryWithTaskSchema: () => RunJobRetryWithTaskSchema,
-  RunJobSuccessSchema: () => RunJobSuccessSchema,
-  RunJobUnresolvedAuthErrorSchema: () => RunJobUnresolvedAuthErrorSchema,
-  RunJobYieldExecutionErrorSchema: () => RunJobYieldExecutionErrorSchema,
-  RunSourceContextSchema: () => RunSourceContextSchema,
-  RunStatusSchema: () => RunStatusSchema,
-  RunTaskBodyInputSchema: () => RunTaskBodyInputSchema,
-  RunTaskBodyOutputSchema: () => RunTaskBodyOutputSchema,
-  RunTaskOptionsSchema: () => RunTaskOptionsSchema,
-  RunTaskResponseWithCachedTasksBodySchema: () => RunTaskResponseWithCachedTasksBodySchema,
-  RunTaskSchema: () => RunTaskSchema,
-  RuntimeEnvironmentTypeSchema: () => RuntimeEnvironmentTypeSchema,
-  SCHEDULED_EVENT: () => SCHEDULED_EVENT,
-  ScheduleMetadataSchema: () => ScheduleMetadataSchema,
-  ScheduledPayloadSchema: () => ScheduledPayloadSchema,
-  ScheduledTriggerMetadataSchema: () => ScheduledTriggerMetadataSchema,
-  SchemaErrorSchema: () => SchemaErrorSchema,
-  SendBulkEventsBodySchema: () => SendBulkEventsBodySchema,
-  SendEventBodySchema: () => SendEventBodySchema,
-  SendEventOptionsSchema: () => SendEventOptionsSchema,
-  SerializableJsonSchema: () => SerializableJsonSchema,
-  ServerTaskSchema: () => ServerTaskSchema,
-  SourceMetadataV2Schema: () => SourceMetadataV2Schema,
-  StaticTriggerMetadataSchema: () => StaticTriggerMetadataSchema,
-  StatusHistorySchema: () => StatusHistorySchema,
-  StatusUpdateSchema: () => StatusUpdateSchema,
-  StatusUpdateStateSchema: () => StatusUpdateStateSchema,
-  StyleSchema: () => StyleSchema,
-  TaskSchema: () => TaskSchema,
-  TaskStatusSchema: () => TaskStatusSchema,
-  TriggerHelpSchema: () => TriggerHelpSchema,
-  TriggerMetadataSchema: () => TriggerMetadataSchema,
-  TriggerSourceSchema: () => TriggerSourceSchema,
-  UpdateTriggerSourceBodyV1Schema: () => UpdateTriggerSourceBodyV1Schema,
-  UpdateTriggerSourceBodyV2Schema: () => UpdateTriggerSourceBodyV2Schema,
-  UpdateWebhookBodySchema: () => UpdateWebhookBodySchema,
-  ValidateErrorResponseSchema: () => ValidateErrorResponseSchema,
-  ValidateResponseSchema: () => ValidateResponseSchema,
-  ValidateSuccessResponseSchema: () => ValidateSuccessResponseSchema,
-  WebhookContextMetadataSchema: () => WebhookContextMetadataSchema,
-  WebhookDeliveryResponseSchema: () => WebhookDeliveryResponseSchema,
-  WebhookMetadataSchema: () => WebhookMetadataSchema,
-  WebhookSourceRequestHeadersSchema: () => WebhookSourceRequestHeadersSchema,
-  addMissingVersionField: () => addMissingVersionField,
-  assertExhaustive: () => assertExhaustive,
-  calculateResetAt: () => calculateResetAt,
-  calculateRetryAt: () => calculateRetryAt,
-  currentDate: () => currentDate,
-  currentTimestampMilliseconds: () => currentTimestampMilliseconds,
-  currentTimestampSeconds: () => currentTimestampSeconds,
-  deepMergeFilters: () => deepMergeFilters,
-  eventFilterMatches: () => eventFilterMatches,
-  parseEndpointIndexStats: () => parseEndpointIndexStats,
-  replacements: () => replacements,
-  requestFilterMatches: () => requestFilterMatches,
-  responseFilterMatches: () => responseFilterMatches,
-  stringPatternMatchers: () => stringPatternMatchers,
-  supportsFeature: () => supportsFeature,
-  urlWithSearchParams: () => urlWithSearchParams
-});
-module.exports = __toCommonJS(src_exports);
+var ulidx = require('ulidx');
+var zod = require('zod');
 
-// src/logger.ts
-var logLevels = [
-  "log",
-  "error",
-  "warn",
-  "info",
-  "debug"
-];
-var _name, _level, _filteredKeys, _jsonReplacer, _additionalFields, _structuredLog, structuredLog_fn;
-var _Logger = class _Logger {
-  constructor(name, level = "info", filteredKeys = [], jsonReplacer, additionalFields) {
-    __privateAdd(this, _structuredLog);
-    __privateAdd(this, _name, void 0);
-    __privateAdd(this, _level, void 0);
-    __privateAdd(this, _filteredKeys, []);
-    __privateAdd(this, _jsonReplacer, void 0);
-    __privateAdd(this, _additionalFields, void 0);
-    __privateSet(this, _name, name);
-    __privateSet(this, _level, logLevels.indexOf(process.env.TRIGGER_LOG_LEVEL ?? level));
-    __privateSet(this, _filteredKeys, filteredKeys);
-    __privateSet(this, _jsonReplacer, createReplacer(jsonReplacer));
-    __privateSet(this, _additionalFields, additionalFields ?? (() => ({})));
-  }
-  // Return a new Logger instance with the same name and a new log level
-  // but filter out the keys from the log messages (at any level)
-  filter(...keys) {
-    return new _Logger(__privateGet(this, _name), logLevels[__privateGet(this, _level)], keys, __privateGet(this, _jsonReplacer));
-  }
-  static satisfiesLogLevel(logLevel, setLevel) {
-    return logLevels.indexOf(logLevel) <= logLevels.indexOf(setLevel);
-  }
-  log(message, ...args) {
-    if (__privateGet(this, _level) < 0)
-      return;
-    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.log, message, "log", ...args);
-  }
-  error(message, ...args) {
-    if (__privateGet(this, _level) < 1)
-      return;
-    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.error, message, "error", ...args);
-  }
-  warn(message, ...args) {
-    if (__privateGet(this, _level) < 2)
-      return;
-    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.warn, message, "warn", ...args);
-  }
-  info(message, ...args) {
-    if (__privateGet(this, _level) < 3)
-      return;
-    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.info, message, "info", ...args);
-  }
-  debug(message, ...args) {
-    if (__privateGet(this, _level) < 4)
-      return;
-    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.debug, message, "debug", ...args);
-  }
-};
-_name = new WeakMap();
-_level = new WeakMap();
-_filteredKeys = new WeakMap();
-_jsonReplacer = new WeakMap();
-_additionalFields = new WeakMap();
-_structuredLog = new WeakSet();
-structuredLog_fn = /* @__PURE__ */ __name(function(loggerFunction, message, level, ...args) {
-  const structuredLog = {
-    ...structureArgs(safeJsonClone(args), __privateGet(this, _filteredKeys)),
-    ...__privateGet(this, _additionalFields).call(this),
-    timestamp: /* @__PURE__ */ new Date(),
-    name: __privateGet(this, _name),
-    message,
-    level
-  };
-  loggerFunction(JSON.stringify(structuredLog, __privateGet(this, _jsonReplacer)));
-}, "#structuredLog");
-__name(_Logger, "Logger");
-var Logger = _Logger;
-function createReplacer(replacer) {
-  return (key, value) => {
-    if (typeof value === "bigint") {
-      return value.toString();
-    }
-    if (replacer) {
-      return replacer(key, value);
-    }
-    return value;
-  };
-}
-__name(createReplacer, "createReplacer");
-function bigIntReplacer(_key, value) {
-  if (typeof value === "bigint") {
-    return value.toString();
-  }
-  return value;
-}
-__name(bigIntReplacer, "bigIntReplacer");
-function safeJsonClone(obj) {
-  try {
-    return JSON.parse(JSON.stringify(obj, bigIntReplacer));
-  } catch (e) {
-    return;
-  }
-}
-__name(safeJsonClone, "safeJsonClone");
-function structureArgs(args, filteredKeys = []) {
-  if (!args) {
-    return;
-  }
-  if (args.length === 0) {
-    return;
-  }
-  if (args.length === 1 && typeof args[0] === "object") {
-    return filterKeys(JSON.parse(JSON.stringify(args[0], bigIntReplacer)), filteredKeys);
-  }
-  return args;
-}
-__name(structureArgs, "structureArgs");
-function filterKeys(obj, keys) {
-  if (typeof obj !== "object" || obj === null) {
-    return obj;
-  }
-  if (Array.isArray(obj)) {
-    return obj.map((item) => filterKeys(item, keys));
-  }
-  const filteredObj = {};
-  for (const [key, value] of Object.entries(obj)) {
-    if (keys.includes(key)) {
-      if (value) {
-        filteredObj[key] = `[filtered ${prettyPrintBytes(value)}]`;
-      } else {
-        filteredObj[key] = value;
-      }
-      continue;
-    }
-    filteredObj[key] = filterKeys(value, keys);
-  }
-  return filteredObj;
-}
-__name(filterKeys, "filterKeys");
-function prettyPrintBytes(value) {
-  if (process.env.NODE_ENV === "production") {
-    return "skipped size";
-  }
-  const sizeInBytes = getSizeInBytes(value);
-  if (sizeInBytes < 1024) {
-    return `${sizeInBytes} bytes`;
-  }
-  if (sizeInBytes < 1024 * 1024) {
-    return `${(sizeInBytes / 1024).toFixed(2)} KB`;
-  }
-  if (sizeInBytes < 1024 * 1024 * 1024) {
-    return `${(sizeInBytes / (1024 * 1024)).toFixed(2)} MB`;
-  }
-  return `${(sizeInBytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
-}
-__name(prettyPrintBytes, "prettyPrintBytes");
-function getSizeInBytes(value) {
-  const jsonString = JSON.stringify(value);
-  if (typeof window === "undefined") {
-    return Buffer.byteLength(jsonString, "utf8");
-  } else {
-    return new TextEncoder().encode(jsonString).length;
-  }
-}
-__name(getSizeInBytes, "getSizeInBytes");
-
-// src/schemas/api.ts
-var import_ulidx = require("ulidx");
-var import_zod12 = require("zod");
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/schemas/addMissingVersionField.ts
 function addMissingVersionField(val) {
@@ -406,225 +17,204 @@ function addMissingVersionField(val) {
   return val;
 }
 __name(addMissingVersionField, "addMissingVersionField");
-
-// src/schemas/errors.ts
-var import_zod = require("zod");
-var ErrorWithStackSchema = import_zod.z.object({
-  message: import_zod.z.string(),
-  name: import_zod.z.string().optional(),
-  stack: import_zod.z.string().optional()
+var ErrorWithStackSchema = zod.z.object({
+  message: zod.z.string(),
+  name: zod.z.string().optional(),
+  stack: zod.z.string().optional()
 });
-var SchemaErrorSchema = import_zod.z.object({
-  path: import_zod.z.array(import_zod.z.string()),
-  message: import_zod.z.string()
+var SchemaErrorSchema = zod.z.object({
+  path: zod.z.array(zod.z.string()),
+  message: zod.z.string()
 });
-
-// src/schemas/eventFilter.ts
-var import_zod2 = require("zod");
 var stringPatternMatchers = [
-  import_zod2.z.object({
-    $endsWith: import_zod2.z.string()
+  zod.z.object({
+    $endsWith: zod.z.string()
   }),
-  import_zod2.z.object({
-    $startsWith: import_zod2.z.string()
+  zod.z.object({
+    $startsWith: zod.z.string()
   }),
-  import_zod2.z.object({
-    $ignoreCaseEquals: import_zod2.z.string()
+  zod.z.object({
+    $ignoreCaseEquals: zod.z.string()
   })
 ];
-var EventMatcherSchema = import_zod2.z.union([
+var EventMatcherSchema = zod.z.union([
   /** Match against a string */
-  import_zod2.z.array(import_zod2.z.string()),
+  zod.z.array(zod.z.string()),
   /** Match against a number */
-  import_zod2.z.array(import_zod2.z.number()),
+  zod.z.array(zod.z.number()),
   /** Match against a boolean */
-  import_zod2.z.array(import_zod2.z.boolean()),
-  import_zod2.z.array(import_zod2.z.union([
+  zod.z.array(zod.z.boolean()),
+  zod.z.array(zod.z.union([
     ...stringPatternMatchers,
-    import_zod2.z.object({
-      $exists: import_zod2.z.boolean()
+    zod.z.object({
+      $exists: zod.z.boolean()
     }),
-    import_zod2.z.object({
-      $isNull: import_zod2.z.boolean()
+    zod.z.object({
+      $isNull: zod.z.boolean()
     }),
-    import_zod2.z.object({
-      $anythingBut: import_zod2.z.union([
-        import_zod2.z.string(),
-        import_zod2.z.number(),
-        import_zod2.z.boolean()
+    zod.z.object({
+      $anythingBut: zod.z.union([
+        zod.z.string(),
+        zod.z.number(),
+        zod.z.boolean()
       ])
     }),
-    import_zod2.z.object({
-      $anythingBut: import_zod2.z.union([
-        import_zod2.z.array(import_zod2.z.string()),
-        import_zod2.z.array(import_zod2.z.number()),
-        import_zod2.z.array(import_zod2.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())
       ])
     }),
-    import_zod2.z.object({
-      $gt: import_zod2.z.number()
+    zod.z.object({
+      $gt: zod.z.number()
     }),
-    import_zod2.z.object({
-      $lt: import_zod2.z.number()
+    zod.z.object({
+      $lt: zod.z.number()
     }),
-    import_zod2.z.object({
-      $gte: import_zod2.z.number()
+    zod.z.object({
+      $gte: zod.z.number()
     }),
-    import_zod2.z.object({
-      $lte: import_zod2.z.number()
+    zod.z.object({
+      $lte: zod.z.number()
     }),
-    import_zod2.z.object({
-      $between: import_zod2.z.tuple([
-        import_zod2.z.number(),
-        import_zod2.z.number()
+    zod.z.object({
+      $between: zod.z.tuple([
+        zod.z.number(),
+        zod.z.number()
       ])
     }),
-    import_zod2.z.object({
-      $includes: import_zod2.z.union([
-        import_zod2.z.string(),
-        import_zod2.z.number(),
-        import_zod2.z.boolean()
+    zod.z.object({
+      $includes: zod.z.union([
+        zod.z.string(),
+        zod.z.number(),
+        zod.z.boolean()
       ])
     })
   ]))
 ]);
-var EventFilterSchema = import_zod2.z.lazy(() => import_zod2.z.record(import_zod2.z.union([
+var EventFilterSchema = zod.z.lazy(() => zod.z.record(zod.z.union([
   EventMatcherSchema,
   EventFilterSchema
 ])));
-var EventRuleSchema = import_zod2.z.object({
-  event: import_zod2.z.string().or(import_zod2.z.array(import_zod2.z.string())),
-  source: import_zod2.z.string(),
+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()
 });
-
-// src/schemas/integrations.ts
-var import_zod3 = require("zod");
-var ConnectionAuthSchema = import_zod3.z.object({
-  type: import_zod3.z.enum([
+var ConnectionAuthSchema = zod.z.object({
+  type: zod.z.enum([
     "oauth2",
     "apiKey"
   ]),
-  accessToken: import_zod3.z.string(),
-  scopes: import_zod3.z.array(import_zod3.z.string()).optional(),
-  additionalFields: import_zod3.z.record(import_zod3.z.string()).optional()
+  accessToken: zod.z.string(),
+  scopes: zod.z.array(zod.z.string()).optional(),
+  additionalFields: zod.z.record(zod.z.string()).optional()
 });
-var IntegrationMetadataSchema = import_zod3.z.object({
-  id: import_zod3.z.string(),
-  name: import_zod3.z.string(),
-  instructions: import_zod3.z.string().optional()
+var IntegrationMetadataSchema = zod.z.object({
+  id: zod.z.string(),
+  name: zod.z.string(),
+  instructions: zod.z.string().optional()
 });
-var IntegrationConfigSchema = import_zod3.z.object({
-  id: import_zod3.z.string(),
+var IntegrationConfigSchema = zod.z.object({
+  id: zod.z.string(),
   metadata: IntegrationMetadataSchema,
-  authSource: import_zod3.z.enum([
+  authSource: zod.z.enum([
     "HOSTED",
     "LOCAL",
     "RESOLVER"
   ])
 });
-
-// src/schemas/json.ts
-var import_zod4 = require("zod");
-var LiteralSchema = import_zod4.z.union([
-  import_zod4.z.string(),
-  import_zod4.z.number(),
-  import_zod4.z.boolean(),
-  import_zod4.z.null()
+var LiteralSchema = zod.z.union([
+  zod.z.string(),
+  zod.z.number(),
+  zod.z.boolean(),
+  zod.z.null()
 ]);
-var DeserializedJsonSchema = import_zod4.z.lazy(() => import_zod4.z.union([
+var DeserializedJsonSchema = zod.z.lazy(() => zod.z.union([
   LiteralSchema,
-  import_zod4.z.array(DeserializedJsonSchema),
-  import_zod4.z.record(DeserializedJsonSchema)
+  zod.z.array(DeserializedJsonSchema),
+  zod.z.record(DeserializedJsonSchema)
 ]));
-var SerializableSchema = import_zod4.z.union([
-  import_zod4.z.string(),
-  import_zod4.z.number(),
-  import_zod4.z.boolean(),
-  import_zod4.z.null(),
-  import_zod4.z.date(),
-  import_zod4.z.undefined(),
-  import_zod4.z.symbol()
+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 = import_zod4.z.lazy(() => import_zod4.z.union([
+var SerializableJsonSchema = zod.z.lazy(() => zod.z.union([
   SerializableSchema,
-  import_zod4.z.array(SerializableJsonSchema),
-  import_zod4.z.record(SerializableJsonSchema)
+  zod.z.array(SerializableJsonSchema),
+  zod.z.record(SerializableJsonSchema)
 ]));
-
-// src/schemas/properties.ts
-var import_zod5 = require("zod");
-var DisplayPropertySchema = import_zod5.z.object({
+var DisplayPropertySchema = zod.z.object({
   /** The label for the property */
-  label: import_zod5.z.string(),
+  label: zod.z.string(),
   /** The value of the property */
-  text: import_zod5.z.string(),
+  text: zod.z.string(),
   /** The URL to link to when the property is clicked */
-  url: import_zod5.z.string().optional(),
+  url: zod.z.string().optional(),
   /** The URL to a list of images to display next to the property */
-  imageUrl: import_zod5.z.array(import_zod5.z.string()).optional()
+  imageUrl: zod.z.array(zod.z.string()).optional()
 });
-var DisplayPropertiesSchema = import_zod5.z.array(DisplayPropertySchema);
-var StyleSchema = import_zod5.z.object({
+var DisplayPropertiesSchema = zod.z.array(DisplayPropertySchema);
+var StyleSchema = zod.z.object({
   /** The style, `normal` or `minimal` */
-  style: import_zod5.z.enum([
+  style: zod.z.enum([
     "normal",
     "minimal"
   ]),
   /** A variant of the style. */
-  variant: import_zod5.z.string().optional()
+  variant: zod.z.string().optional()
 });
-
-// src/schemas/schedules.ts
-var import_zod6 = require("zod");
 var SCHEDULED_EVENT = "dev.trigger.scheduled";
-var ScheduledPayloadSchema = import_zod6.z.object({
-  ts: import_zod6.z.coerce.date(),
-  lastTimestamp: import_zod6.z.coerce.date().optional()
+var ScheduledPayloadSchema = zod.z.object({
+  ts: zod.z.coerce.date(),
+  lastTimestamp: zod.z.coerce.date().optional()
 });
-var IntervalOptionsSchema = import_zod6.z.object({
+var IntervalOptionsSchema = zod.z.object({
   /** The number of seconds for the interval. Min = 60, Max = 2_592_000 (30 days) */
-  seconds: import_zod6.z.number().int().positive().min(60).max(2592e3)
+  seconds: zod.z.number().int().positive().min(60).max(2592e3)
 });
-var CronOptionsSchema = import_zod6.z.object({
+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: import_zod6.z.string()
+  cron: zod.z.string()
 });
-var CronMetadataSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("cron"),
+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: import_zod6.z.string().optional(),
-  metadata: import_zod6.z.any()
+  accountId: zod.z.string().optional(),
+  metadata: zod.z.any()
 });
-var IntervalMetadataSchema = import_zod6.z.object({
+var IntervalMetadataSchema = zod.z.object({
   /** An interval reoccurs at the specified number of seconds  */
-  type: import_zod6.z.literal("interval"),
+  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: import_zod6.z.string().optional(),
+  accountId: zod.z.string().optional(),
   /** Any additional metadata about the schedule. */
-  metadata: import_zod6.z.any()
+  metadata: zod.z.any()
 });
-var ScheduleMetadataSchema = import_zod6.z.discriminatedUnion("type", [
+var ScheduleMetadataSchema = zod.z.discriminatedUnion("type", [
   IntervalMetadataSchema,
   CronMetadataSchema
 ]);
-var RegisterDynamicSchedulePayloadSchema = import_zod6.z.object({
-  id: import_zod6.z.string(),
-  jobs: import_zod6.z.array(import_zod6.z.object({
-    id: import_zod6.z.string(),
-    version: import_zod6.z.string()
+var RegisterDynamicSchedulePayloadSchema = zod.z.object({
+  id: zod.z.string(),
+  jobs: zod.z.array(zod.z.object({
+    id: zod.z.string(),
+    version: zod.z.string()
   }))
 });
-
-// src/schemas/tasks.ts
-var import_zod7 = require("zod");
-var TaskStatusSchema = import_zod7.z.enum([
+var TaskStatusSchema = zod.z.enum([
   "PENDING",
   "WAITING",
   "RUNNING",
@@ -632,229 +222,217 @@ var TaskStatusSchema = import_zod7.z.enum([
   "ERRORED",
   "CANCELED"
 ]);
-var TaskSchema = import_zod7.z.object({
-  id: import_zod7.z.string(),
-  name: import_zod7.z.string(),
-  icon: import_zod7.z.string().optional().nullable(),
-  noop: import_zod7.z.boolean(),
-  startedAt: import_zod7.z.coerce.date().optional().nullable(),
-  completedAt: import_zod7.z.coerce.date().optional().nullable(),
-  delayUntil: import_zod7.z.coerce.date().optional().nullable(),
+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: import_zod7.z.string().optional().nullable(),
-  properties: import_zod7.z.array(DisplayPropertySchema).optional().nullable(),
-  outputProperties: import_zod7.z.array(DisplayPropertySchema).optional().nullable(),
+  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: import_zod7.z.string().optional().nullable(),
-  parentId: import_zod7.z.string().optional().nullable(),
+  error: zod.z.string().optional().nullable(),
+  parentId: zod.z.string().optional().nullable(),
   style: StyleSchema.optional().nullable(),
-  operation: import_zod7.z.string().optional().nullable(),
-  callbackUrl: import_zod7.z.string().optional().nullable(),
-  childExecutionMode: import_zod7.z.enum([
+  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: import_zod7.z.string(),
-  attempts: import_zod7.z.number(),
-  forceYield: import_zod7.z.boolean().optional().nullable()
+  idempotencyKey: zod.z.string(),
+  attempts: zod.z.number(),
+  forceYield: zod.z.boolean().optional().nullable()
 });
-var CachedTaskSchema = import_zod7.z.object({
-  id: import_zod7.z.string(),
-  idempotencyKey: import_zod7.z.string(),
+var CachedTaskSchema = zod.z.object({
+  id: zod.z.string(),
+  idempotencyKey: zod.z.string(),
   status: TaskStatusSchema,
-  noop: import_zod7.z.boolean().default(false),
+  noop: zod.z.boolean().default(false),
   output: DeserializedJsonSchema.optional().nullable(),
-  parentId: import_zod7.z.string().optional().nullable()
-});
-
-// src/schemas/triggers.ts
-var import_zod8 = require("zod");
-var EventExampleSchema = import_zod8.z.object({
-  id: import_zod8.z.string(),
-  icon: import_zod8.z.string().optional(),
-  name: import_zod8.z.string(),
-  payload: import_zod8.z.any()
-});
-var EventSpecificationSchema = import_zod8.z.object({
-  name: import_zod8.z.string().or(import_zod8.z.array(import_zod8.z.string())),
-  title: import_zod8.z.string(),
-  source: import_zod8.z.string(),
-  icon: import_zod8.z.string(),
+  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: import_zod8.z.array(DisplayPropertySchema).optional(),
-  schema: import_zod8.z.any().optional(),
-  examples: import_zod8.z.array(EventExampleSchema).optional()
-});
-var DynamicTriggerMetadataSchema = import_zod8.z.object({
-  type: import_zod8.z.literal("dynamic"),
-  id: import_zod8.z.string()
-});
-var TriggerHelpSchema = import_zod8.z.object({
-  noRuns: import_zod8.z.object({
-    text: import_zod8.z.string(),
-    link: import_zod8.z.string().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 = import_zod8.z.object({
-  type: import_zod8.z.literal("static"),
-  title: import_zod8.z.union([
-    import_zod8.z.string(),
-    import_zod8.z.array(import_zod8.z.string())
+var StaticTriggerMetadataSchema = zod.z.object({
+  type: zod.z.literal("static"),
+  title: zod.z.union([
+    zod.z.string(),
+    zod.z.array(zod.z.string())
   ]),
-  properties: import_zod8.z.array(DisplayPropertySchema).optional(),
+  properties: zod.z.array(DisplayPropertySchema).optional(),
   rule: EventRuleSchema,
-  link: import_zod8.z.string().optional(),
+  link: zod.z.string().optional(),
   help: TriggerHelpSchema.optional()
 });
-var InvokeTriggerMetadataSchema = import_zod8.z.object({
-  type: import_zod8.z.literal("invoke")
+var InvokeTriggerMetadataSchema = zod.z.object({
+  type: zod.z.literal("invoke")
 });
-var ScheduledTriggerMetadataSchema = import_zod8.z.object({
-  type: import_zod8.z.literal("scheduled"),
+var ScheduledTriggerMetadataSchema = zod.z.object({
+  type: zod.z.literal("scheduled"),
   schedule: ScheduleMetadataSchema
 });
-var TriggerMetadataSchema = import_zod8.z.discriminatedUnion("type", [
+var TriggerMetadataSchema = zod.z.discriminatedUnion("type", [
   DynamicTriggerMetadataSchema,
   StaticTriggerMetadataSchema,
   ScheduledTriggerMetadataSchema,
   InvokeTriggerMetadataSchema
 ]);
-
-// src/schemas/runs.ts
-var import_zod10 = require("zod");
-
-// src/schemas/statuses.ts
-var import_zod9 = require("zod");
-var StatusUpdateStateSchema = import_zod9.z.union([
-  import_zod9.z.literal("loading"),
-  import_zod9.z.literal("success"),
-  import_zod9.z.literal("failure")
+var StatusUpdateStateSchema = zod.z.union([
+  zod.z.literal("loading"),
+  zod.z.literal("success"),
+  zod.z.literal("failure")
 ]);
-var StatusUpdateDataSchema = import_zod9.z.record(SerializableJsonSchema);
-var StatusUpdateSchema = import_zod9.z.object({
-  label: import_zod9.z.string().optional(),
+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 = import_zod9.z.array(StatusUpdateSchema);
+var StatusHistorySchema = zod.z.array(StatusUpdateSchema);
 var JobRunStatusRecordSchema = InitalStatusUpdateSchema.extend({
-  key: import_zod9.z.string(),
+  key: zod.z.string(),
   history: StatusHistorySchema
 });
 
 // src/schemas/runs.ts
-var RunStatusSchema = import_zod10.z.union([
-  import_zod10.z.literal("PENDING"),
-  import_zod10.z.literal("QUEUED"),
-  import_zod10.z.literal("WAITING_ON_CONNECTIONS"),
-  import_zod10.z.literal("PREPROCESSING"),
-  import_zod10.z.literal("STARTED"),
-  import_zod10.z.literal("SUCCESS"),
-  import_zod10.z.literal("FAILURE"),
-  import_zod10.z.literal("TIMED_OUT"),
-  import_zod10.z.literal("ABORTED"),
-  import_zod10.z.literal("CANCELED"),
-  import_zod10.z.literal("UNRESOLVED_AUTH"),
-  import_zod10.z.literal("INVALID_PAYLOAD"),
-  import_zod10.z.literal("EXECUTING"),
-  import_zod10.z.literal("WAITING_TO_CONTINUE"),
-  import_zod10.z.literal("WAITING_TO_EXECUTE")
+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 = import_zod10.z.object({
+var RunTaskSchema = zod.z.object({
   /** The Task id */
-  id: import_zod10.z.string(),
+  id: zod.z.string(),
   /** The key that you defined when creating the Task, the first param in any task. */
-  displayKey: import_zod10.z.string().nullable(),
+  displayKey: zod.z.string().nullable(),
   /** The Task status */
   status: TaskStatusSchema,
   /** The name of the Task */
-  name: import_zod10.z.string(),
+  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: import_zod10.z.string().nullable(),
+  icon: zod.z.string().nullable(),
   /** When the task started */
-  startedAt: import_zod10.z.coerce.date().nullable(),
+  startedAt: zod.z.coerce.date().nullable(),
   /** When the task completed */
-  completedAt: import_zod10.z.coerce.date().nullable()
+  completedAt: zod.z.coerce.date().nullable()
 });
 var RunTaskWithSubtasksSchema = RunTaskSchema.extend({
-  subtasks: import_zod10.z.lazy(() => RunTaskWithSubtasksSchema.array()).optional()
+  subtasks: zod.z.lazy(() => RunTaskWithSubtasksSchema.array()).optional()
 });
-var GetRunOptionsSchema = import_zod10.z.object({
+var GetRunOptionsSchema = zod.z.object({
   /** Return subtasks, which appear in a `subtasks` array on a task. @default false */
-  subtasks: import_zod10.z.boolean().optional(),
+  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: import_zod10.z.string().optional(),
+  cursor: zod.z.string().optional(),
   /** How many tasks you want to return in one go, max 50. @default 20 */
-  take: import_zod10.z.number().optional()
+  take: zod.z.number().optional()
 });
-var GetRunOptionsWithTaskDetailsSchema = GetRunOptionsSchema.extend({
+GetRunOptionsSchema.extend({
   /** If `true`, it returns the `params` and `output` of all tasks. @default false */
-  taskdetails: import_zod10.z.boolean().optional()
+  taskdetails: zod.z.boolean().optional()
 });
-var RunSchema = import_zod10.z.object({
+var RunSchema = zod.z.object({
   /** The Run id */
-  id: import_zod10.z.string(),
+  id: zod.z.string(),
   /** The Run status */
   status: RunStatusSchema,
   /** When the run started */
-  startedAt: import_zod10.z.coerce.date().nullable(),
+  startedAt: zod.z.coerce.date().nullable(),
   /** When the run was last updated */
-  updatedAt: import_zod10.z.coerce.date().nullable(),
+  updatedAt: zod.z.coerce.date().nullable(),
   /** When the run was completed */
-  completedAt: import_zod10.z.coerce.date().nullable()
+  completedAt: zod.z.coerce.date().nullable()
 });
 var GetRunSchema = RunSchema.extend({
   /** The output of the run */
-  output: import_zod10.z.any().optional(),
+  output: zod.z.any().optional(),
   /** The tasks from the run */
-  tasks: import_zod10.z.array(RunTaskWithSubtasksSchema),
+  tasks: zod.z.array(RunTaskWithSubtasksSchema),
   /** Any status updates that were published from the run */
-  statuses: import_zod10.z.array(JobRunStatusRecordSchema).default([]),
+  statuses: zod.z.array(JobRunStatusRecordSchema).default([]),
   /** If there are more tasks, you can use this to get them */
-  nextCursor: import_zod10.z.string().optional()
+  nextCursor: zod.z.string().optional()
 });
-var GetRunsOptionsSchema = import_zod10.z.object({
+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: import_zod10.z.string().optional(),
+  cursor: zod.z.string().optional(),
   /** How many runs you want to return in one go, max 50. @default 20 */
-  take: import_zod10.z.number().optional()
+  take: zod.z.number().optional()
 });
-var GetRunsSchema = import_zod10.z.object({
+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: import_zod10.z.string().optional()
+  nextCursor: zod.z.string().optional()
 });
-
-// src/schemas/requestFilter.ts
-var import_zod11 = require("zod");
-var StringMatchSchema = import_zod11.z.union([
+var StringMatchSchema = zod.z.union([
   /** Match against a string */
-  import_zod11.z.array(import_zod11.z.string()),
-  import_zod11.z.array(import_zod11.z.union(stringPatternMatchers))
+  zod.z.array(zod.z.string()),
+  zod.z.array(zod.z.union(stringPatternMatchers))
 ]);
-var HTTPMethodUnionSchema = import_zod11.z.union([
-  import_zod11.z.literal("GET"),
-  import_zod11.z.literal("POST"),
-  import_zod11.z.literal("PUT"),
-  import_zod11.z.literal("PATCH"),
-  import_zod11.z.literal("DELETE"),
-  import_zod11.z.literal("HEAD"),
-  import_zod11.z.literal("OPTIONS")
+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 = import_zod11.z.object({
+var RequestFilterSchema = zod.z.object({
   /** An array of HTTP methods to match.
   * For example, `["GET", "POST"]` will match both `GET` and `POST` Requests. */
-  method: import_zod11.z.array(HTTPMethodUnionSchema).optional(),
+  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).
   
@@ -866,7 +444,7 @@ var RequestFilterSchema = import_zod11.z.object({
       },
     },
     ``` */
-  headers: import_zod11.z.record(StringMatchSchema).optional(),
+  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).
   
@@ -878,7 +456,7 @@ var RequestFilterSchema = import_zod11.z.object({
       },
     },
     ``` */
-  query: import_zod11.z.record(StringMatchSchema).optional(),
+  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).
   */
@@ -888,304 +466,304 @@ var ResponseFilterSchema = RequestFilterSchema.omit({
   method: true,
   query: true
 }).extend({
-  status: import_zod11.z.array(import_zod11.z.number()).optional()
+  status: zod.z.array(zod.z.number()).optional()
 });
 
 // src/schemas/api.ts
-var UpdateTriggerSourceBodyV1Schema = import_zod12.z.object({
-  registeredEvents: import_zod12.z.array(import_zod12.z.string()),
-  secret: import_zod12.z.string().optional(),
+var UpdateTriggerSourceBodyV1Schema = zod.z.object({
+  registeredEvents: zod.z.array(zod.z.string()),
+  secret: zod.z.string().optional(),
   data: SerializableJsonSchema.optional()
 });
-var UpdateTriggerSourceBodyV2Schema = import_zod12.z.object({
-  secret: import_zod12.z.string().optional(),
+var UpdateTriggerSourceBodyV2Schema = zod.z.object({
+  secret: zod.z.string().optional(),
   data: SerializableJsonSchema.optional(),
-  options: import_zod12.z.object({
-    event: import_zod12.z.array(import_zod12.z.string())
-  }).and(import_zod12.z.record(import_zod12.z.string(), import_zod12.z.array(import_zod12.z.string())).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 = import_zod12.z.discriminatedUnion("active", [
-  import_zod12.z.object({
-    active: import_zod12.z.literal(false)
+var UpdateWebhookBodySchema = zod.z.discriminatedUnion("active", [
+  zod.z.object({
+    active: zod.z.literal(false)
   }),
-  import_zod12.z.object({
-    active: import_zod12.z.literal(true),
-    config: import_zod12.z.record(import_zod12.z.string().array())
+  zod.z.object({
+    active: zod.z.literal(true),
+    config: zod.z.record(zod.z.string().array())
   })
 ]);
-var RegisterHTTPTriggerSourceBodySchema = import_zod12.z.object({
-  type: import_zod12.z.literal("HTTP"),
-  url: import_zod12.z.string().url()
+var RegisterHTTPTriggerSourceBodySchema = zod.z.object({
+  type: zod.z.literal("HTTP"),
+  url: zod.z.string().url()
 });
-var RegisterSMTPTriggerSourceBodySchema = import_zod12.z.object({
-  type: import_zod12.z.literal("SMTP")
+var RegisterSMTPTriggerSourceBodySchema = zod.z.object({
+  type: zod.z.literal("SMTP")
 });
-var RegisterSQSTriggerSourceBodySchema = import_zod12.z.object({
-  type: import_zod12.z.literal("SQS")
+var RegisterSQSTriggerSourceBodySchema = zod.z.object({
+  type: zod.z.literal("SQS")
 });
-var RegisterSourceChannelBodySchema = import_zod12.z.discriminatedUnion("type", [
+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 = import_zod12.z.object({
-  key: import_zod12.z.string(),
-  params: import_zod12.z.any(),
-  config: import_zod12.z.any(),
-  active: import_zod12.z.boolean(),
-  secret: import_zod12.z.string(),
-  url: import_zod12.z.string(),
+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: import_zod12.z.string().optional()
-});
-var RegisterWebhookPayloadSchema = import_zod12.z.object({
-  active: import_zod12.z.boolean(),
-  params: import_zod12.z.any().optional(),
-  config: import_zod12.z.object({
-    current: import_zod12.z.record(import_zod12.z.string().array()),
-    desired: import_zod12.z.record(import_zod12.z.string().array())
+  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: import_zod12.z.string(),
-  secret: import_zod12.z.string()
+  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 = import_zod12.z.object({
-  key: import_zod12.z.string(),
-  params: import_zod12.z.any(),
-  active: import_zod12.z.boolean(),
-  secret: import_zod12.z.string(),
+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: import_zod12.z.string().optional()
+  clientId: zod.z.string().optional()
 });
-var SourceEventOptionSchema = import_zod12.z.object({
-  name: import_zod12.z.string(),
-  value: import_zod12.z.string()
+zod.z.object({
+  name: zod.z.string(),
+  value: zod.z.string()
 });
-var RegisterSourceEventSchemaV1 = import_zod12.z.object({
+var RegisterSourceEventSchemaV1 = zod.z.object({
   /** The id of the source */
-  id: import_zod12.z.string(),
+  id: zod.z.string(),
   source: RegisterTriggerSourceSchema,
-  events: import_zod12.z.array(import_zod12.z.string()),
-  missingEvents: import_zod12.z.array(import_zod12.z.string()),
-  orphanedEvents: import_zod12.z.array(import_zod12.z.string()),
-  dynamicTriggerId: import_zod12.z.string().optional()
+  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 = import_zod12.z.object({
-  desired: import_zod12.z.array(import_zod12.z.string()),
-  missing: import_zod12.z.array(import_zod12.z.string()),
-  orphaned: import_zod12.z.array(import_zod12.z.string())
+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 = import_zod12.z.object({
+var RegisterSourceEventOptionsSchema = zod.z.object({
   event: RegisteredOptionsDiffSchema
-}).and(import_zod12.z.record(import_zod12.z.string(), RegisteredOptionsDiffSchema));
-var RegisterSourceEventSchemaV2 = import_zod12.z.object({
+}).and(zod.z.record(zod.z.string(), RegisteredOptionsDiffSchema));
+var RegisterSourceEventSchemaV2 = zod.z.object({
   /** The id of the source */
-  id: import_zod12.z.string(),
+  id: zod.z.string(),
   source: RegisterTriggerSourceSchema,
   options: RegisterSourceEventOptionsSchema,
-  dynamicTriggerId: import_zod12.z.string().optional()
+  dynamicTriggerId: zod.z.string().optional()
 });
-var TriggerSourceSchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  key: import_zod12.z.string()
+var TriggerSourceSchema = zod.z.object({
+  id: zod.z.string(),
+  key: zod.z.string()
 });
 var HttpSourceResponseMetadataSchema = DeserializedJsonSchema;
-var HandleTriggerSourceSchema = import_zod12.z.object({
-  key: import_zod12.z.string(),
-  secret: import_zod12.z.string(),
-  data: import_zod12.z.any(),
-  params: import_zod12.z.any(),
+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 = import_zod12.z.object({
-  "x-ts-key": import_zod12.z.string(),
-  "x-ts-dynamic-id": import_zod12.z.string().optional(),
-  "x-ts-secret": import_zod12.z.string(),
-  "x-ts-data": import_zod12.z.string().transform((s) => JSON.parse(s)),
-  "x-ts-params": import_zod12.z.string().transform((s) => JSON.parse(s)),
-  "x-ts-http-url": import_zod12.z.string(),
-  "x-ts-http-method": import_zod12.z.string(),
-  "x-ts-http-headers": import_zod12.z.string().transform((s) => import_zod12.z.record(import_zod12.z.string()).parse(JSON.parse(s))),
-  "x-ts-auth": import_zod12.z.string().optional().transform((s) => {
+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": import_zod12.z.string().optional().transform((s) => {
+  "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 = import_zod12.z.object({
-  "x-ts-key": import_zod12.z.string(),
-  "x-ts-http-url": import_zod12.z.string(),
-  "x-ts-http-method": import_zod12.z.string(),
-  "x-ts-http-headers": import_zod12.z.string().transform((s) => import_zod12.z.record(import_zod12.z.string()).parse(JSON.parse(s)))
-});
-var WebhookSourceRequestHeadersSchema = import_zod12.z.object({
-  "x-ts-key": import_zod12.z.string(),
-  "x-ts-dynamic-id": import_zod12.z.string().optional(),
-  "x-ts-secret": import_zod12.z.string(),
-  "x-ts-params": import_zod12.z.string().transform((s) => JSON.parse(s)),
-  "x-ts-http-url": import_zod12.z.string(),
-  "x-ts-http-method": import_zod12.z.string(),
-  "x-ts-http-headers": import_zod12.z.string().transform((s) => import_zod12.z.record(import_zod12.z.string()).parse(JSON.parse(s)))
-});
-var PongSuccessResponseSchema = import_zod12.z.object({
-  ok: import_zod12.z.literal(true),
-  triggerVersion: import_zod12.z.string().optional(),
-  triggerSdkVersion: import_zod12.z.string().optional()
-});
-var PongErrorResponseSchema = import_zod12.z.object({
-  ok: import_zod12.z.literal(false),
-  error: import_zod12.z.string(),
-  triggerVersion: import_zod12.z.string().optional(),
-  triggerSdkVersion: import_zod12.z.string().optional()
-});
-var PongResponseSchema = import_zod12.z.discriminatedUnion("ok", [
+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 = import_zod12.z.object({
-  ok: import_zod12.z.literal(true),
-  endpointId: import_zod12.z.string(),
-  triggerVersion: import_zod12.z.string().optional()
+var ValidateSuccessResponseSchema = zod.z.object({
+  ok: zod.z.literal(true),
+  endpointId: zod.z.string(),
+  triggerVersion: zod.z.string().optional()
 });
-var ValidateErrorResponseSchema = import_zod12.z.object({
-  ok: import_zod12.z.literal(false),
-  error: import_zod12.z.string(),
-  triggerVersion: import_zod12.z.string().optional()
+var ValidateErrorResponseSchema = zod.z.object({
+  ok: zod.z.literal(false),
+  error: zod.z.string(),
+  triggerVersion: zod.z.string().optional()
 });
-var ValidateResponseSchema = import_zod12.z.discriminatedUnion("ok", [
+var ValidateResponseSchema = zod.z.discriminatedUnion("ok", [
   ValidateSuccessResponseSchema,
   ValidateErrorResponseSchema
 ]);
-var QueueOptionsSchema = import_zod12.z.object({
-  name: import_zod12.z.string(),
-  maxConcurrent: import_zod12.z.number().optional()
-});
-var ConcurrencyLimitOptionsSchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  limit: import_zod12.z.number()
-});
-var JobMetadataSchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  name: import_zod12.z.string(),
-  version: import_zod12.z.string(),
+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: import_zod12.z.record(IntegrationConfigSchema),
-  internal: import_zod12.z.boolean().default(false),
-  enabled: import_zod12.z.boolean(),
-  startPosition: import_zod12.z.enum([
+  integrations: zod.z.record(IntegrationConfigSchema),
+  internal: zod.z.boolean().default(false),
+  enabled: zod.z.boolean(),
+  startPosition: zod.z.enum([
     "initial",
     "latest"
   ]),
-  preprocessRuns: import_zod12.z.boolean(),
-  concurrencyLimit: ConcurrencyLimitOptionsSchema.or(import_zod12.z.number().int().positive()).optional()
+  preprocessRuns: zod.z.boolean(),
+  concurrencyLimit: ConcurrencyLimitOptionsSchema.or(zod.z.number().int().positive()).optional()
 });
-var SourceMetadataV1Schema = import_zod12.z.object({
-  version: import_zod12.z.literal("1"),
-  channel: import_zod12.z.enum([
+var SourceMetadataV1Schema = zod.z.object({
+  version: zod.z.literal("1"),
+  channel: zod.z.enum([
     "HTTP",
     "SQS",
     "SMTP"
   ]),
   integration: IntegrationConfigSchema,
-  key: import_zod12.z.string(),
-  params: import_zod12.z.any(),
-  events: import_zod12.z.array(import_zod12.z.string()),
-  registerSourceJob: import_zod12.z.object({
-    id: import_zod12.z.string(),
-    version: import_zod12.z.string()
+  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 = import_zod12.z.object({
-  version: import_zod12.z.literal("2"),
-  channel: import_zod12.z.enum([
+var SourceMetadataV2Schema = zod.z.object({
+  version: zod.z.literal("2"),
+  channel: zod.z.enum([
     "HTTP",
     "SQS",
     "SMTP"
   ]),
   integration: IntegrationConfigSchema,
-  key: import_zod12.z.string(),
-  params: import_zod12.z.any(),
-  options: import_zod12.z.record(import_zod12.z.array(import_zod12.z.string())),
-  registerSourceJob: import_zod12.z.object({
-    id: import_zod12.z.string(),
-    version: import_zod12.z.string()
+  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 = import_zod12.z.preprocess(addMissingVersionField, import_zod12.z.discriminatedUnion("version", [
+var SourceMetadataSchema = zod.z.preprocess(addMissingVersionField, zod.z.discriminatedUnion("version", [
   SourceMetadataV1Schema,
   SourceMetadataV2Schema
 ]));
-var WebhookMetadataSchema = import_zod12.z.object({
-  key: import_zod12.z.string(),
-  params: import_zod12.z.any(),
-  config: import_zod12.z.record(import_zod12.z.array(import_zod12.z.string())),
+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: import_zod12.z.object({
-    id: import_zod12.z.string()
+  httpEndpoint: zod.z.object({
+    id: zod.z.string()
   })
 });
-var WebhookContextMetadataSchema = import_zod12.z.object({
-  params: import_zod12.z.any(),
-  config: import_zod12.z.record(import_zod12.z.string().array()),
-  secret: import_zod12.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 = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  jobs: import_zod12.z.array(JobMetadataSchema.pick({
+var DynamicTriggerEndpointMetadataSchema = zod.z.object({
+  id: zod.z.string(),
+  jobs: zod.z.array(JobMetadataSchema.pick({
     id: true,
     version: true
   })),
-  registerSourceJob: import_zod12.z.object({
-    id: import_zod12.z.string(),
-    version: import_zod12.z.string()
+  registerSourceJob: zod.z.object({
+    id: zod.z.string(),
+    version: zod.z.string()
   }).optional()
 });
-var HttpEndpointMetadataSchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  version: import_zod12.z.string(),
-  enabled: import_zod12.z.boolean(),
-  title: import_zod12.z.string().optional(),
-  icon: import_zod12.z.string().optional(),
-  properties: import_zod12.z.array(DisplayPropertySchema).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: import_zod12.z.boolean().optional(),
-  source: import_zod12.z.string()
-});
-var IndexEndpointResponseSchema = import_zod12.z.object({
-  jobs: import_zod12.z.array(JobMetadataSchema),
-  sources: import_zod12.z.array(SourceMetadataSchema),
-  webhooks: import_zod12.z.array(WebhookMetadataSchema).optional(),
-  dynamicTriggers: import_zod12.z.array(DynamicTriggerEndpointMetadataSchema),
-  dynamicSchedules: import_zod12.z.array(RegisterDynamicSchedulePayloadSchema),
-  httpEndpoints: import_zod12.z.array(HttpEndpointMetadataSchema).optional()
-});
-var EndpointIndexErrorSchema = import_zod12.z.object({
-  message: import_zod12.z.string(),
-  raw: import_zod12.z.any().optional()
-});
-var IndexEndpointStatsSchema = import_zod12.z.object({
-  jobs: import_zod12.z.number(),
-  sources: import_zod12.z.number(),
-  webhooks: import_zod12.z.number().optional(),
-  dynamicTriggers: import_zod12.z.number(),
-  dynamicSchedules: import_zod12.z.number(),
-  disabledJobs: import_zod12.z.number().default(0),
-  httpEndpoints: import_zod12.z.number().default(0)
+  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) {
@@ -1194,227 +772,227 @@ function parseEndpointIndexStats(stats) {
   return IndexEndpointStatsSchema.parse(stats);
 }
 __name(parseEndpointIndexStats, "parseEndpointIndexStats");
-var GetEndpointIndexResponseSchema = import_zod12.z.discriminatedUnion("status", [
-  import_zod12.z.object({
-    status: import_zod12.z.literal("PENDING"),
-    updatedAt: import_zod12.z.coerce.date()
+var GetEndpointIndexResponseSchema = zod.z.discriminatedUnion("status", [
+  zod.z.object({
+    status: zod.z.literal("PENDING"),
+    updatedAt: zod.z.coerce.date()
   }),
-  import_zod12.z.object({
-    status: import_zod12.z.literal("STARTED"),
-    updatedAt: import_zod12.z.coerce.date()
+  zod.z.object({
+    status: zod.z.literal("STARTED"),
+    updatedAt: zod.z.coerce.date()
   }),
-  import_zod12.z.object({
-    status: import_zod12.z.literal("SUCCESS"),
+  zod.z.object({
+    status: zod.z.literal("SUCCESS"),
     stats: IndexEndpointStatsSchema,
-    updatedAt: import_zod12.z.coerce.date()
+    updatedAt: zod.z.coerce.date()
   }),
-  import_zod12.z.object({
-    status: import_zod12.z.literal("FAILURE"),
+  zod.z.object({
+    status: zod.z.literal("FAILURE"),
     error: EndpointIndexErrorSchema,
-    updatedAt: import_zod12.z.coerce.date()
+    updatedAt: zod.z.coerce.date()
   })
 ]);
-var EndpointHeadersSchema = import_zod12.z.object({
-  "trigger-version": import_zod12.z.string().optional(),
-  "trigger-sdk-version": import_zod12.z.string().optional()
+var EndpointHeadersSchema = zod.z.object({
+  "trigger-version": zod.z.string().optional(),
+  "trigger-sdk-version": zod.z.string().optional()
 });
-var ExecuteJobRunMetadataSchema = import_zod12.z.object({
-  successSubscription: import_zod12.z.boolean().optional(),
-  failedSubscription: import_zod12.z.boolean().optional()
+var ExecuteJobRunMetadataSchema = zod.z.object({
+  successSubscription: zod.z.boolean().optional(),
+  failedSubscription: zod.z.boolean().optional()
 });
 var ExecuteJobHeadersSchema = EndpointHeadersSchema.extend({
-  "x-trigger-run-metadata": import_zod12.z.preprocess((val) => typeof val === "string" && JSON.parse(val), ExecuteJobRunMetadataSchema).optional()
+  "x-trigger-run-metadata": zod.z.preprocess((val) => typeof val === "string" && JSON.parse(val), ExecuteJobRunMetadataSchema).optional()
 });
-var RawEventSchema = import_zod12.z.object({
+var RawEventSchema = zod.z.object({
   /** The `name` property must exactly match any subscriptions you want to
     trigger. */
-  name: import_zod12.z.string(),
+  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: import_zod12.z.any(),
+  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: import_zod12.z.any().optional(),
+  context: zod.z.any().optional(),
   /** The `id` property uniquely identify this particular event. If unset it
     will be set automatically using `ulid`. */
-  id: import_zod12.z.string().default(() => (0, import_ulidx.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: import_zod12.z.coerce.date().optional(),
+  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: import_zod12.z.string().optional(),
+  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: import_zod12.z.union([
-    import_zod12.z.literal("JSON"),
-    import_zod12.z.literal("REQUEST")
+  payloadType: zod.z.union([
+    zod.z.literal("JSON"),
+    zod.z.literal("REQUEST")
   ]).optional()
 });
-var ApiEventLogSchema = import_zod12.z.object({
+var ApiEventLogSchema = zod.z.object({
   /** The `id` of the event that was sent.
   */
-  id: import_zod12.z.string(),
+  id: zod.z.string(),
   /** The `name` of the event that was sent. */
-  name: import_zod12.z.string(),
+  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: import_zod12.z.coerce.date(),
+  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: import_zod12.z.coerce.date().optional().nullable(),
+  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: import_zod12.z.coerce.date().optional().nullable(),
+  deliveredAt: zod.z.coerce.date().optional().nullable(),
   /** The timestamp when the event was cancelled. Is `undefined` if the event
   * wasn't cancelled. */
-  cancelledAt: import_zod12.z.coerce.date().optional().nullable()
+  cancelledAt: zod.z.coerce.date().optional().nullable()
 });
-var SendEventOptionsSchema = import_zod12.z.object({
+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: import_zod12.z.coerce.date().optional(),
+  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: import_zod12.z.number().int().optional(),
+  deliverAfter: zod.z.number().int().optional(),
   /** This optional param will be used by Trigger.dev Connect, which
     is coming soon. */
-  accountId: import_zod12.z.string().optional()
+  accountId: zod.z.string().optional()
 });
-var SendEventBodySchema = import_zod12.z.object({
+var SendEventBodySchema = zod.z.object({
   event: RawEventSchema,
   options: SendEventOptionsSchema.optional()
 });
-var SendBulkEventsBodySchema = import_zod12.z.object({
+var SendBulkEventsBodySchema = zod.z.object({
   events: RawEventSchema.array(),
   options: SendEventOptionsSchema.optional()
 });
-var DeliverEventResponseSchema = import_zod12.z.object({
-  deliveredAt: import_zod12.z.string().datetime()
+var DeliverEventResponseSchema = zod.z.object({
+  deliveredAt: zod.z.string().datetime()
 });
-var RuntimeEnvironmentTypeSchema = import_zod12.z.enum([
+var RuntimeEnvironmentTypeSchema = zod.z.enum([
   "PRODUCTION",
   "STAGING",
   "DEVELOPMENT",
   "PREVIEW"
 ]);
-var RunSourceContextSchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  metadata: import_zod12.z.any()
+var RunSourceContextSchema = zod.z.object({
+  id: zod.z.string(),
+  metadata: zod.z.any()
 });
-var AutoYieldConfigSchema = import_zod12.z.object({
-  startTaskThreshold: import_zod12.z.number(),
-  beforeExecuteTaskThreshold: import_zod12.z.number(),
-  beforeCompleteTaskThreshold: import_zod12.z.number(),
-  afterCompleteTaskThreshold: import_zod12.z.number()
+var AutoYieldConfigSchema = zod.z.object({
+  startTaskThreshold: zod.z.number(),
+  beforeExecuteTaskThreshold: zod.z.number(),
+  beforeCompleteTaskThreshold: zod.z.number(),
+  afterCompleteTaskThreshold: zod.z.number()
 });
-var RunJobBodySchema = import_zod12.z.object({
+var RunJobBodySchema = zod.z.object({
   event: ApiEventLogSchema,
-  job: import_zod12.z.object({
-    id: import_zod12.z.string(),
-    version: import_zod12.z.string()
+  job: zod.z.object({
+    id: zod.z.string(),
+    version: zod.z.string()
   }),
-  run: import_zod12.z.object({
-    id: import_zod12.z.string(),
-    isTest: import_zod12.z.boolean(),
-    isRetry: import_zod12.z.boolean().default(false),
-    startedAt: import_zod12.z.coerce.date()
+  run: zod.z.object({
+    id: zod.z.string(),
+    isTest: zod.z.boolean(),
+    isRetry: zod.z.boolean().default(false),
+    startedAt: zod.z.coerce.date()
   }),
-  environment: import_zod12.z.object({
-    id: import_zod12.z.string(),
-    slug: import_zod12.z.string(),
+  environment: zod.z.object({
+    id: zod.z.string(),
+    slug: zod.z.string(),
     type: RuntimeEnvironmentTypeSchema
   }),
-  organization: import_zod12.z.object({
-    id: import_zod12.z.string(),
-    title: import_zod12.z.string(),
-    slug: import_zod12.z.string()
+  organization: zod.z.object({
+    id: zod.z.string(),
+    title: zod.z.string(),
+    slug: zod.z.string()
   }),
-  project: import_zod12.z.object({
-    id: import_zod12.z.string(),
-    name: import_zod12.z.string(),
-    slug: import_zod12.z.string()
+  project: zod.z.object({
+    id: zod.z.string(),
+    name: zod.z.string(),
+    slug: zod.z.string()
   }).optional(),
-  account: import_zod12.z.object({
-    id: import_zod12.z.string(),
-    metadata: import_zod12.z.any()
+  account: zod.z.object({
+    id: zod.z.string(),
+    metadata: zod.z.any()
   }).optional(),
   source: RunSourceContextSchema.optional(),
-  tasks: import_zod12.z.array(CachedTaskSchema).optional(),
-  cachedTaskCursor: import_zod12.z.string().optional(),
-  noopTasksSet: import_zod12.z.string().optional(),
-  connections: import_zod12.z.record(ConnectionAuthSchema).optional(),
-  yieldedExecutions: import_zod12.z.string().array().optional(),
-  runChunkExecutionLimit: import_zod12.z.number().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 = import_zod12.z.object({
-  status: import_zod12.z.literal("ERROR"),
+var RunJobErrorSchema = zod.z.object({
+  status: zod.z.literal("ERROR"),
   error: ErrorWithStackSchema,
   task: TaskSchema.optional()
 });
-var RunJobYieldExecutionErrorSchema = import_zod12.z.object({
-  status: import_zod12.z.literal("YIELD_EXECUTION"),
-  key: import_zod12.z.string()
+var RunJobYieldExecutionErrorSchema = zod.z.object({
+  status: zod.z.literal("YIELD_EXECUTION"),
+  key: zod.z.string()
 });
-var AutoYieldMetadataSchema = import_zod12.z.object({
-  location: import_zod12.z.string(),
-  timeRemaining: import_zod12.z.number(),
-  timeElapsed: import_zod12.z.number(),
-  limit: import_zod12.z.number().optional()
+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: import_zod12.z.literal("AUTO_YIELD_EXECUTION")
+  status: zod.z.literal("AUTO_YIELD_EXECUTION")
 });
-var RunJobAutoYieldWithCompletedTaskExecutionErrorSchema = import_zod12.z.object({
-  status: import_zod12.z.literal("AUTO_YIELD_EXECUTION_WITH_COMPLETED_TASK"),
-  id: import_zod12.z.string(),
-  properties: import_zod12.z.array(DisplayPropertySchema).optional(),
-  output: import_zod12.z.string().optional(),
+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 RunJobInvalidPayloadErrorSchema = import_zod12.z.object({
-  status: import_zod12.z.literal("INVALID_PAYLOAD"),
-  errors: import_zod12.z.array(SchemaErrorSchema)
+var RunJobInvalidPayloadErrorSchema = zod.z.object({
+  status: zod.z.literal("INVALID_PAYLOAD"),
+  errors: zod.z.array(SchemaErrorSchema)
 });
-var RunJobUnresolvedAuthErrorSchema = import_zod12.z.object({
-  status: import_zod12.z.literal("UNRESOLVED_AUTH_ERROR"),
-  issues: import_zod12.z.record(import_zod12.z.object({
-    id: import_zod12.z.string(),
-    error: import_zod12.z.string()
+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 = import_zod12.z.object({
-  status: import_zod12.z.literal("RESUME_WITH_TASK"),
+var RunJobResumeWithTaskSchema = zod.z.object({
+  status: zod.z.literal("RESUME_WITH_TASK"),
   task: TaskSchema
 });
-var RunJobRetryWithTaskSchema = import_zod12.z.object({
-  status: import_zod12.z.literal("RETRY_WITH_TASK"),
+var RunJobRetryWithTaskSchema = zod.z.object({
+  status: zod.z.literal("RETRY_WITH_TASK"),
   task: TaskSchema,
   error: ErrorWithStackSchema,
-  retryAt: import_zod12.z.coerce.date()
+  retryAt: zod.z.coerce.date()
 });
-var RunJobCanceledWithTaskSchema = import_zod12.z.object({
-  status: import_zod12.z.literal("CANCELED"),
+var RunJobCanceledWithTaskSchema = zod.z.object({
+  status: zod.z.literal("CANCELED"),
   task: TaskSchema
 });
-var RunJobSuccessSchema = import_zod12.z.object({
-  status: import_zod12.z.literal("SUCCESS"),
+var RunJobSuccessSchema = zod.z.object({
+  status: zod.z.literal("SUCCESS"),
   output: DeserializedJsonSchema.optional()
 });
-var RunJobErrorResponseSchema = import_zod12.z.union([
+var RunJobErrorResponseSchema = zod.z.union([
   RunJobAutoYieldExecutionErrorSchema,
   RunJobAutoYieldWithCompletedTaskExecutionErrorSchema,
   RunJobYieldExecutionErrorSchema,
@@ -1425,12 +1003,12 @@ var RunJobErrorResponseSchema = import_zod12.z.union([
   RunJobRetryWithTaskSchema,
   RunJobCanceledWithTaskSchema
 ]);
-var RunJobResumeWithParallelTaskSchema = import_zod12.z.object({
-  status: import_zod12.z.literal("RESUME_WITH_PARALLEL_TASK"),
+var RunJobResumeWithParallelTaskSchema = zod.z.object({
+  status: zod.z.literal("RESUME_WITH_PARALLEL_TASK"),
   task: TaskSchema,
-  childErrors: import_zod12.z.array(RunJobErrorResponseSchema)
+  childErrors: zod.z.array(RunJobErrorResponseSchema)
 });
-var RunJobResponseSchema = import_zod12.z.discriminatedUnion("status", [
+var RunJobResponseSchema = zod.z.discriminatedUnion("status", [
   RunJobAutoYieldExecutionErrorSchema,
   RunJobAutoYieldWithCompletedTaskExecutionErrorSchema,
   RunJobYieldExecutionErrorSchema,
@@ -1443,137 +1021,137 @@ var RunJobResponseSchema = import_zod12.z.discriminatedUnion("status", [
   RunJobCanceledWithTaskSchema,
   RunJobSuccessSchema
 ]);
-var PreprocessRunBodySchema = import_zod12.z.object({
+var PreprocessRunBodySchema = zod.z.object({
   event: ApiEventLogSchema,
-  job: import_zod12.z.object({
-    id: import_zod12.z.string(),
-    version: import_zod12.z.string()
+  job: zod.z.object({
+    id: zod.z.string(),
+    version: zod.z.string()
   }),
-  run: import_zod12.z.object({
-    id: import_zod12.z.string(),
-    isTest: import_zod12.z.boolean()
+  run: zod.z.object({
+    id: zod.z.string(),
+    isTest: zod.z.boolean()
   }),
-  environment: import_zod12.z.object({
-    id: import_zod12.z.string(),
-    slug: import_zod12.z.string(),
+  environment: zod.z.object({
+    id: zod.z.string(),
+    slug: zod.z.string(),
     type: RuntimeEnvironmentTypeSchema
   }),
-  organization: import_zod12.z.object({
-    id: import_zod12.z.string(),
-    title: import_zod12.z.string(),
-    slug: import_zod12.z.string()
+  organization: zod.z.object({
+    id: zod.z.string(),
+    title: zod.z.string(),
+    slug: zod.z.string()
   }),
-  account: import_zod12.z.object({
-    id: import_zod12.z.string(),
-    metadata: import_zod12.z.any()
+  account: zod.z.object({
+    id: zod.z.string(),
+    metadata: zod.z.any()
   }).optional()
 });
-var PreprocessRunResponseSchema = import_zod12.z.object({
-  abort: import_zod12.z.boolean(),
-  properties: import_zod12.z.array(DisplayPropertySchema).optional()
+var PreprocessRunResponseSchema = zod.z.object({
+  abort: zod.z.boolean(),
+  properties: zod.z.array(DisplayPropertySchema).optional()
 });
-var CreateRunResponseOkSchema = import_zod12.z.object({
-  ok: import_zod12.z.literal(true),
-  data: import_zod12.z.object({
-    id: import_zod12.z.string()
+var CreateRunResponseOkSchema = zod.z.object({
+  ok: zod.z.literal(true),
+  data: zod.z.object({
+    id: zod.z.string()
   })
 });
-var CreateRunResponseErrorSchema = import_zod12.z.object({
-  ok: import_zod12.z.literal(false),
-  error: import_zod12.z.string()
+var CreateRunResponseErrorSchema = zod.z.object({
+  ok: zod.z.literal(false),
+  error: zod.z.string()
 });
-var CreateRunResponseBodySchema = import_zod12.z.discriminatedUnion("ok", [
+var CreateRunResponseBodySchema = zod.z.discriminatedUnion("ok", [
   CreateRunResponseOkSchema,
   CreateRunResponseErrorSchema
 ]);
-var RedactStringSchema = import_zod12.z.object({
-  __redactedString: import_zod12.z.literal(true),
-  strings: import_zod12.z.array(import_zod12.z.string()),
-  interpolations: import_zod12.z.array(import_zod12.z.string())
+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 = import_zod12.z.object({
-  level: import_zod12.z.enum([
+var LogMessageSchema = zod.z.object({
+  level: zod.z.enum([
     "DEBUG",
     "INFO",
     "WARN",
     "ERROR"
   ]),
-  message: import_zod12.z.string(),
+  message: zod.z.string(),
   data: SerializableJsonSchema.optional()
 });
-var RedactSchema = import_zod12.z.object({
-  paths: import_zod12.z.array(import_zod12.z.string())
+var RedactSchema = zod.z.object({
+  paths: zod.z.array(zod.z.string())
 });
-var RetryOptionsSchema = import_zod12.z.object({
+var RetryOptionsSchema = zod.z.object({
   /** The maximum number of times to retry the request. */
-  limit: import_zod12.z.number().optional(),
+  limit: zod.z.number().optional(),
   /** The exponential factor to use when calculating the next retry time. */
-  factor: import_zod12.z.number().optional(),
+  factor: zod.z.number().optional(),
   /** The minimum amount of time to wait before retrying the request. */
-  minTimeoutInMs: import_zod12.z.number().optional(),
+  minTimeoutInMs: zod.z.number().optional(),
   /** The maximum amount of time to wait before retrying the request. */
-  maxTimeoutInMs: import_zod12.z.number().optional(),
+  maxTimeoutInMs: zod.z.number().optional(),
   /** Whether to randomize the retry time. */
-  randomize: import_zod12.z.boolean().optional()
+  randomize: zod.z.boolean().optional()
 });
-var RunTaskOptionsSchema = import_zod12.z.object({
+var RunTaskOptionsSchema = zod.z.object({
   /** The name of the Task is required. This is displayed on the Task in the logs. */
-  name: import_zod12.z.string().optional(),
+  name: zod.z.string().optional(),
   /** The Task will wait and only start at the specified Date  */
-  delayUntil: import_zod12.z.coerce.date().optional(),
+  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: import_zod12.z.string().optional(),
+  icon: zod.z.string().optional(),
   /** The key for the Task that you want to appear in the logs */
-  displayKey: import_zod12.z.string().optional(),
+  displayKey: zod.z.string().optional(),
   /** A description of the Task */
-  description: import_zod12.z.string().optional(),
+  description: zod.z.string().optional(),
   /** Properties that are displayed in the logs */
-  properties: import_zod12.z.array(DisplayPropertySchema).optional(),
+  properties: zod.z.array(DisplayPropertySchema).optional(),
   /** The input params to the Task, will be displayed in the logs  */
-  params: import_zod12.z.any(),
+  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: import_zod12.z.object({
+  callback: zod.z.object({
     /** Causes the task to wait for and return the data of the first request sent to `task.callbackUrl`. */
-    enabled: import_zod12.z.boolean(),
+    enabled: zod.z.boolean(),
     /** Time to wait for the first request to `task.callbackUrl`. Default: One hour. */
-    timeoutInSeconds: import_zod12.z.number()
+    timeoutInSeconds: zod.z.number()
   }).partial().optional(),
   /** Allows you to link the Integration connection in the logs. This is handled automatically in integrations.  */
-  connectionKey: import_zod12.z.string().optional(),
+  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: import_zod12.z.enum([
+  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: import_zod12.z.boolean().default(false),
+  noop: zod.z.boolean().default(false),
   redact: RedactSchema.optional(),
-  parallel: import_zod12.z.boolean().optional()
+  parallel: zod.z.boolean().optional()
 });
 var RunTaskBodyInputSchema = RunTaskOptionsSchema.extend({
-  idempotencyKey: import_zod12.z.string(),
-  parentId: import_zod12.z.string().optional()
+  idempotencyKey: zod.z.string(),
+  parentId: zod.z.string().optional()
 });
 var RunTaskBodyOutputSchema = RunTaskBodyInputSchema.extend({
-  properties: import_zod12.z.array(DisplayPropertySchema.partial()).optional(),
+  properties: zod.z.array(DisplayPropertySchema.partial()).optional(),
   params: DeserializedJsonSchema.optional().nullable(),
-  callback: import_zod12.z.object({
-    enabled: import_zod12.z.boolean(),
-    timeoutInSeconds: import_zod12.z.number().default(3600)
+  callback: zod.z.object({
+    enabled: zod.z.boolean(),
+    timeoutInSeconds: zod.z.number().default(3600)
   }).optional()
 });
-var RunTaskResponseWithCachedTasksBodySchema = import_zod12.z.object({
+var RunTaskResponseWithCachedTasksBodySchema = zod.z.object({
   task: ServerTaskSchema,
-  cachedTasks: import_zod12.z.object({
-    tasks: import_zod12.z.array(CachedTaskSchema),
-    cursor: import_zod12.z.string().optional()
+  cachedTasks: zod.z.object({
+    tasks: zod.z.array(CachedTaskSchema),
+    cursor: zod.z.string().optional()
   }).optional()
 });
 var CompleteTaskBodyInputSchema = RunTaskBodyInputSchema.pick({
@@ -1588,208 +1166,202 @@ var CompleteTaskBodyV2InputSchema = RunTaskBodyInputSchema.pick({
   description: true,
   params: true
 }).extend({
-  output: import_zod12.z.string().optional()
+  output: zod.z.string().optional()
 });
-var FailTaskBodyInputSchema = import_zod12.z.object({
+var FailTaskBodyInputSchema = zod.z.object({
   error: ErrorWithStackSchema
 });
-var NormalizedRequestSchema = import_zod12.z.object({
-  headers: import_zod12.z.record(import_zod12.z.string()),
-  method: import_zod12.z.string(),
-  query: import_zod12.z.record(import_zod12.z.string()),
-  url: import_zod12.z.string(),
-  body: import_zod12.z.any()
+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 = import_zod12.z.object({
-  status: import_zod12.z.number(),
-  body: import_zod12.z.any(),
-  headers: import_zod12.z.record(import_zod12.z.string()).optional()
+var NormalizedResponseSchema = zod.z.object({
+  status: zod.z.number(),
+  body: zod.z.any(),
+  headers: zod.z.record(zod.z.string()).optional()
 });
-var HttpSourceResponseSchema = import_zod12.z.object({
+var HttpSourceResponseSchema = zod.z.object({
   response: NormalizedResponseSchema,
-  events: import_zod12.z.array(RawEventSchema),
+  events: zod.z.array(RawEventSchema),
   metadata: HttpSourceResponseMetadataSchema.optional()
 });
-var WebhookDeliveryResponseSchema = import_zod12.z.object({
+var WebhookDeliveryResponseSchema = zod.z.object({
   response: NormalizedResponseSchema,
-  verified: import_zod12.z.boolean(),
-  error: import_zod12.z.string().optional()
+  verified: zod.z.boolean(),
+  error: zod.z.string().optional()
 });
-var RegisterTriggerBodySchemaV1 = import_zod12.z.object({
+var RegisterTriggerBodySchemaV1 = zod.z.object({
   rule: EventRuleSchema,
   source: SourceMetadataV1Schema
 });
-var RegisterTriggerBodySchemaV2 = import_zod12.z.object({
+var RegisterTriggerBodySchemaV2 = zod.z.object({
   rule: EventRuleSchema,
   source: SourceMetadataV2Schema,
-  accountId: import_zod12.z.string().optional()
+  accountId: zod.z.string().optional()
 });
-var InitializeTriggerBodySchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  params: import_zod12.z.any(),
-  accountId: import_zod12.z.string().optional(),
-  metadata: import_zod12.z.any().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 = import_zod12.z.object({
+var RegisterCommonScheduleBodySchema = zod.z.object({
   /** A unique id for the schedule. This is used to identify and unregister the schedule later. */
-  id: import_zod12.z.string(),
+  id: zod.z.string(),
   /** Any additional metadata about the schedule. */
-  metadata: import_zod12.z.any(),
+  metadata: zod.z.any(),
   /** An optional Account ID to associate with runs triggered by this schedule */
-  accountId: import_zod12.z.string().optional()
+  accountId: zod.z.string().optional()
 });
 var RegisterIntervalScheduleBodySchema = RegisterCommonScheduleBodySchema.merge(IntervalMetadataSchema);
 var InitializeCronScheduleBodySchema = RegisterCommonScheduleBodySchema.merge(CronMetadataSchema);
-var RegisterScheduleBodySchema = import_zod12.z.discriminatedUnion("type", [
+var RegisterScheduleBodySchema = zod.z.discriminatedUnion("type", [
   RegisterIntervalScheduleBodySchema,
   InitializeCronScheduleBodySchema
 ]);
-var RegisterScheduleResponseBodySchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
+var RegisterScheduleResponseBodySchema = zod.z.object({
+  id: zod.z.string(),
   schedule: ScheduleMetadataSchema,
-  metadata: import_zod12.z.any(),
-  active: import_zod12.z.boolean()
+  metadata: zod.z.any(),
+  active: zod.z.boolean()
 });
-var CreateExternalConnectionBodySchema = import_zod12.z.object({
-  accessToken: import_zod12.z.string(),
-  type: import_zod12.z.enum([
+var CreateExternalConnectionBodySchema = zod.z.object({
+  accessToken: zod.z.string(),
+  type: zod.z.enum([
     "oauth2"
   ]),
-  scopes: import_zod12.z.array(import_zod12.z.string()).optional(),
-  metadata: import_zod12.z.any()
+  scopes: zod.z.array(zod.z.string()).optional(),
+  metadata: zod.z.any()
 });
-var GetRunStatusesSchema = import_zod12.z.object({
-  run: import_zod12.z.object({
-    id: import_zod12.z.string(),
+var GetRunStatusesSchema = zod.z.object({
+  run: zod.z.object({
+    id: zod.z.string(),
     status: RunStatusSchema,
-    output: import_zod12.z.any().optional()
+    output: zod.z.any().optional()
   }),
-  statuses: import_zod12.z.array(JobRunStatusRecordSchema)
+  statuses: zod.z.array(JobRunStatusRecordSchema)
 });
-var InvokeJobResponseSchema = import_zod12.z.object({
-  id: import_zod12.z.string()
+var InvokeJobResponseSchema = zod.z.object({
+  id: zod.z.string()
 });
-var InvokeJobRequestBodySchema = import_zod12.z.object({
-  payload: import_zod12.z.any(),
-  context: import_zod12.z.any().optional(),
-  options: import_zod12.z.object({
-    accountId: import_zod12.z.string().optional(),
-    callbackUrl: import_zod12.z.string().optional()
+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 = import_zod12.z.object({
-  accountId: import_zod12.z.string().optional(),
-  idempotencyKey: import_zod12.z.string().optional(),
-  context: import_zod12.z.any().optional(),
-  callbackUrl: import_zod12.z.string().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 = import_zod12.z.object({
-  url: import_zod12.z.string(),
-  name: import_zod12.z.string().or(import_zod12.z.array(import_zod12.z.string())),
-  source: import_zod12.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: import_zod12.z.string().optional(),
-  timeoutInSeconds: import_zod12.z.number().int().positive().min(10).max(60 * 60 * 24 * 365).default(3600)
+  accountId: zod.z.string().optional(),
+  timeoutInSeconds: zod.z.number().int().positive().min(10).max(60 * 60 * 24 * 365).default(3600)
 });
-var EphemeralEventDispatcherResponseBodySchema = import_zod12.z.object({
-  id: import_zod12.z.string()
+var EphemeralEventDispatcherResponseBodySchema = zod.z.object({
+  id: zod.z.string()
 });
-var KeyValueStoreResponseBodySchema = import_zod12.z.discriminatedUnion("action", [
-  import_zod12.z.object({
-    action: import_zod12.z.literal("DELETE"),
-    key: import_zod12.z.string(),
-    deleted: import_zod12.z.boolean()
+var KeyValueStoreResponseBodySchema = zod.z.discriminatedUnion("action", [
+  zod.z.object({
+    action: zod.z.literal("DELETE"),
+    key: zod.z.string(),
+    deleted: zod.z.boolean()
   }),
-  import_zod12.z.object({
-    action: import_zod12.z.literal("GET"),
-    key: import_zod12.z.string(),
-    value: import_zod12.z.string().optional()
+  zod.z.object({
+    action: zod.z.literal("GET"),
+    key: zod.z.string(),
+    value: zod.z.string().optional()
   }),
-  import_zod12.z.object({
-    action: import_zod12.z.literal("HAS"),
-    key: import_zod12.z.string(),
-    has: import_zod12.z.boolean()
+  zod.z.object({
+    action: zod.z.literal("HAS"),
+    key: zod.z.string(),
+    has: zod.z.boolean()
   }),
-  import_zod12.z.object({
-    action: import_zod12.z.literal("SET"),
-    key: import_zod12.z.string(),
-    value: import_zod12.z.string().optional()
+  zod.z.object({
+    action: zod.z.literal("SET"),
+    key: zod.z.string(),
+    value: zod.z.string().optional()
   })
 ]);
-
-// src/schemas/notifications.ts
-var import_zod13 = require("zod");
 var MISSING_CONNECTION_NOTIFICATION = "dev.trigger.notifications.missingConnection";
 var MISSING_CONNECTION_RESOLVED_NOTIFICATION = "dev.trigger.notifications.missingConnectionResolved";
-var CommonMissingConnectionNotificationPayloadSchema = import_zod13.z.object({
-  id: import_zod13.z.string(),
-  client: import_zod13.z.object({
-    id: import_zod13.z.string(),
-    title: import_zod13.z.string(),
-    scopes: import_zod13.z.array(import_zod13.z.string()),
-    createdAt: import_zod13.z.coerce.date(),
-    updatedAt: import_zod13.z.coerce.date()
+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: import_zod13.z.string()
+  authorizationUrl: zod.z.string()
 });
 var MissingDeveloperConnectionNotificationPayloadSchema = CommonMissingConnectionNotificationPayloadSchema.extend({
-  type: import_zod13.z.literal("DEVELOPER")
+  type: zod.z.literal("DEVELOPER")
 });
 var MissingExternalConnectionNotificationPayloadSchema = CommonMissingConnectionNotificationPayloadSchema.extend({
-  type: import_zod13.z.literal("EXTERNAL"),
-  account: import_zod13.z.object({
-    id: import_zod13.z.string(),
-    metadata: import_zod13.z.any()
+  type: zod.z.literal("EXTERNAL"),
+  account: zod.z.object({
+    id: zod.z.string(),
+    metadata: zod.z.any()
   })
 });
-var MissingConnectionNotificationPayloadSchema = import_zod13.z.discriminatedUnion("type", [
+var MissingConnectionNotificationPayloadSchema = zod.z.discriminatedUnion("type", [
   MissingDeveloperConnectionNotificationPayloadSchema,
   MissingExternalConnectionNotificationPayloadSchema
 ]);
-var CommonMissingConnectionNotificationResolvedPayloadSchema = import_zod13.z.object({
-  id: import_zod13.z.string(),
-  client: import_zod13.z.object({
-    id: import_zod13.z.string(),
-    title: import_zod13.z.string(),
-    scopes: import_zod13.z.array(import_zod13.z.string()),
-    createdAt: import_zod13.z.coerce.date(),
-    updatedAt: import_zod13.z.coerce.date(),
-    integrationIdentifier: import_zod13.z.string(),
-    integrationAuthMethod: import_zod13.z.string()
+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: import_zod13.z.coerce.date()
+  expiresAt: zod.z.coerce.date()
 });
 var MissingDeveloperConnectionResolvedNotificationPayloadSchema = CommonMissingConnectionNotificationResolvedPayloadSchema.extend({
-  type: import_zod13.z.literal("DEVELOPER")
+  type: zod.z.literal("DEVELOPER")
 });
 var MissingExternalConnectionResolvedNotificationPayloadSchema = CommonMissingConnectionNotificationResolvedPayloadSchema.extend({
-  type: import_zod13.z.literal("EXTERNAL"),
-  account: import_zod13.z.object({
-    id: import_zod13.z.string(),
-    metadata: import_zod13.z.any()
+  type: zod.z.literal("EXTERNAL"),
+  account: zod.z.object({
+    id: zod.z.string(),
+    metadata: zod.z.any()
   })
 });
-var MissingConnectionResolvedNotificationPayloadSchema = import_zod13.z.discriminatedUnion("type", [
+var MissingConnectionResolvedNotificationPayloadSchema = zod.z.discriminatedUnion("type", [
   MissingDeveloperConnectionResolvedNotificationPayloadSchema,
   MissingExternalConnectionResolvedNotificationPayloadSchema
 ]);
-
-// src/schemas/fetch.ts
-var import_zod14 = require("zod");
-var FetchRetryHeadersStrategySchema = import_zod14.z.object({
+var FetchRetryHeadersStrategySchema = zod.z.object({
   /** The `headers` strategy retries the request using info from the response headers. */
-  strategy: import_zod14.z.literal("headers"),
+  strategy: zod.z.literal("headers"),
   /** The header to use to determine the maximum number of times to retry the request. */
-  limitHeader: import_zod14.z.string(),
+  limitHeader: zod.z.string(),
   /** The header to use to determine the number of remaining retries. */
-  remainingHeader: import_zod14.z.string(),
+  remainingHeader: zod.z.string(),
   /** The header to use to determine the time when the number of remaining retries will be reset. */
-  resetHeader: import_zod14.z.string(),
+  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: import_zod14.z.enum([
+  resetFormat: zod.z.enum([
     "unix_timestamp",
     "unix_timestamp_in_ms",
     "iso_8601",
@@ -1798,83 +1370,77 @@ var FetchRetryHeadersStrategySchema = import_zod14.z.object({
 });
 var FetchRetryBackoffStrategySchema = RetryOptionsSchema.extend({
   /** The `backoff` strategy retries the request with an exponential backoff. */
-  strategy: import_zod14.z.literal("backoff"),
+  strategy: zod.z.literal("backoff"),
   /** The event filter to use to determine if the request should be retried. */
   bodyFilter: EventFilterSchema.optional()
 });
-var FetchRetryStrategySchema = import_zod14.z.discriminatedUnion("strategy", [
+var FetchRetryStrategySchema = zod.z.discriminatedUnion("strategy", [
   FetchRetryHeadersStrategySchema,
   FetchRetryBackoffStrategySchema
 ]);
-var FetchRequestInitSchema = import_zod14.z.object({
+var FetchRequestInitSchema = zod.z.object({
   /** The HTTP method to use for the request. */
-  method: import_zod14.z.string().optional(),
+  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: import_zod14.z.record(import_zod14.z.union([
-    import_zod14.z.string(),
+  headers: zod.z.record(zod.z.union([
+    zod.z.string(),
     RedactStringSchema
   ])).optional(),
   /** The body of the request. */
-  body: import_zod14.z.union([
-    import_zod14.z.string(),
-    import_zod14.z.instanceof(ArrayBuffer)
+  body: zod.z.union([
+    zod.z.string(),
+    zod.z.instanceof(ArrayBuffer)
   ]).optional()
 });
-var FetchRetryOptionsSchema = import_zod14.z.record(FetchRetryStrategySchema);
-var FetchTimeoutOptionsSchema = import_zod14.z.object({
-  durationInMs: import_zod14.z.number(),
+var FetchRetryOptionsSchema = zod.z.record(FetchRetryStrategySchema);
+var FetchTimeoutOptionsSchema = zod.z.object({
+  durationInMs: zod.z.number(),
   retry: RetryOptionsSchema.optional()
 });
-var FetchOperationSchema = import_zod14.z.object({
-  url: import_zod14.z.string(),
+var FetchOperationSchema = zod.z.object({
+  url: zod.z.string(),
   requestInit: FetchRequestInitSchema.optional(),
-  retry: import_zod14.z.record(FetchRetryStrategySchema).optional(),
+  retry: zod.z.record(FetchRetryStrategySchema).optional(),
   timeout: FetchTimeoutOptionsSchema.optional()
 });
-var FetchPollOperationSchema = import_zod14.z.object({
-  url: import_zod14.z.string(),
-  interval: import_zod14.z.number().int().positive().min(10).max(600).default(10),
-  timeout: import_zod14.z.number().int().positive().min(30).max(3600).default(600),
+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()
 });
-
-// src/schemas/events.ts
-var import_zod15 = require("zod");
-var GetEventSchema = import_zod15.z.object({
+var GetEventSchema = zod.z.object({
   /** The event id */
-  id: import_zod15.z.string(),
+  id: zod.z.string(),
   /** The event name */
-  name: import_zod15.z.string(),
+  name: zod.z.string(),
   /** When the event was created */
-  createdAt: import_zod15.z.coerce.date(),
+  createdAt: zod.z.coerce.date(),
   /** When the event was last updated */
-  updatedAt: import_zod15.z.coerce.date(),
+  updatedAt: zod.z.coerce.date(),
   /** The runs that were triggered by the event */
-  runs: import_zod15.z.array(import_zod15.z.object({
+  runs: zod.z.array(zod.z.object({
     /** The Run id */
-    id: import_zod15.z.string(),
+    id: zod.z.string(),
     /** The Run status */
     status: RunStatusSchema,
     /** When the run started */
-    startedAt: import_zod15.z.coerce.date().optional().nullable(),
+    startedAt: zod.z.coerce.date().optional().nullable(),
     /** When the run completed */
-    completedAt: import_zod15.z.coerce.date().optional().nullable()
+    completedAt: zod.z.coerce.date().optional().nullable()
   }))
 });
-var CancelRunsForEventSchema = import_zod15.z.object({
-  cancelledRunIds: import_zod15.z.array(import_zod15.z.string()),
-  failedToCancelRunIds: import_zod15.z.array(import_zod15.z.string())
+var CancelRunsForEventSchema = zod.z.object({
+  cancelledRunIds: zod.z.array(zod.z.string()),
+  failedToCancelRunIds: zod.z.array(zod.z.string())
 });
-
-// src/schemas/request.ts
-var import_zod16 = require("zod");
-var RequestWithRawBodySchema = import_zod16.z.object({
-  url: import_zod16.z.string(),
-  method: import_zod16.z.string(),
-  headers: import_zod16.z.record(import_zod16.z.string()),
-  rawBody: import_zod16.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()
 });
 
 // src/utils.ts
@@ -2086,7 +1652,7 @@ __name(eventFilterMatches, "eventFilterMatches");
 function contentFiltersMatches(actualValue, contentFilters) {
   for (const contentFilter of contentFilters) {
     if (typeof contentFilter === "object") {
-      const [key, value] = Object.entries(contentFilter)[0];
+      Object.entries(contentFilter)[0];
       if (!contentFilterMatches(actualValue, contentFilter)) {
         return false;
       }
@@ -2271,4 +1837,185 @@ function supportsFeature(featureName, version) {
   return version >= supportedVersion;
 }
 __name(supportsFeature, "supportsFeature");
+
+exports.API_VERSIONS = API_VERSIONS;
+exports.ApiEventLogSchema = ApiEventLogSchema;
+exports.AutoYieldConfigSchema = AutoYieldConfigSchema;
+exports.AutoYieldMetadataSchema = AutoYieldMetadataSchema;
+exports.CachedTaskSchema = CachedTaskSchema;
+exports.CancelRunsForEventSchema = CancelRunsForEventSchema;
+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.PLATFORM_FEATURES = PLATFORM_FEATURES;
+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.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.assertExhaustive = assertExhaustive;
+exports.calculateResetAt = calculateResetAt;
+exports.calculateRetryAt = calculateRetryAt;
+exports.currentDate = currentDate;
+exports.currentTimestampMilliseconds = currentTimestampMilliseconds;
+exports.currentTimestampSeconds = currentTimestampSeconds;
+exports.deepMergeFilters = deepMergeFilters;
+exports.eventFilterMatches = eventFilterMatches;
+exports.parseEndpointIndexStats = parseEndpointIndexStats;
+exports.replacements = replacements;
+exports.requestFilterMatches = requestFilterMatches;
+exports.responseFilterMatches = responseFilterMatches;
+exports.stringPatternMatchers = stringPatternMatchers;
+exports.supportsFeature = supportsFeature;
+exports.urlWithSearchParams = urlWithSearchParams;
+//# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map