@trigger.dev/core 0.0.0-auto-yield-20231020151736 → 0.0.0-beta-20240327133444

package/dist/index.js

@@ -1,351 +1,10 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-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 __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-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;
-};
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  API_VERSIONS: () => API_VERSIONS,
-  ApiEventLogSchema: () => ApiEventLogSchema,
-  AutoYieldConfigSchema: () => AutoYieldConfigSchema,
-  BloomFilter: () => BloomFilter,
-  CachedTaskSchema: () => CachedTaskSchema,
-  CommonMissingConnectionNotificationPayloadSchema: () => CommonMissingConnectionNotificationPayloadSchema,
-  CommonMissingConnectionNotificationResolvedPayloadSchema: () => CommonMissingConnectionNotificationResolvedPayloadSchema,
-  CompleteTaskBodyInputSchema: () => CompleteTaskBodyInputSchema,
-  ConnectionAuthSchema: () => ConnectionAuthSchema,
-  CreateExternalConnectionBodySchema: () => CreateExternalConnectionBodySchema,
-  CreateRunResponseBodySchema: () => CreateRunResponseBodySchema,
-  CronMetadataSchema: () => CronMetadataSchema,
-  CronOptionsSchema: () => CronOptionsSchema,
-  DeliverEventResponseSchema: () => DeliverEventResponseSchema,
-  DeserializedJsonSchema: () => DeserializedJsonSchema,
-  DisplayPropertiesSchema: () => DisplayPropertiesSchema,
-  DisplayPropertySchema: () => DisplayPropertySchema,
-  DynamicTriggerEndpointMetadataSchema: () => DynamicTriggerEndpointMetadataSchema,
-  DynamicTriggerMetadataSchema: () => DynamicTriggerMetadataSchema,
-  EndpointHeadersSchema: () => EndpointHeadersSchema,
-  EndpointIndexErrorSchema: () => EndpointIndexErrorSchema,
-  ErrorWithStackSchema: () => ErrorWithStackSchema,
-  EventExampleSchema: () => EventExampleSchema,
-  EventFilterSchema: () => EventFilterSchema,
-  EventRuleSchema: () => EventRuleSchema,
-  EventSpecificationSchema: () => EventSpecificationSchema,
-  FailTaskBodyInputSchema: () => FailTaskBodyInputSchema,
-  FetchOperationSchema: () => FetchOperationSchema,
-  FetchRequestInitSchema: () => FetchRequestInitSchema,
-  FetchRetryBackoffStrategySchema: () => FetchRetryBackoffStrategySchema,
-  FetchRetryHeadersStrategySchema: () => FetchRetryHeadersStrategySchema,
-  FetchRetryOptionsSchema: () => FetchRetryOptionsSchema,
-  FetchRetryStrategySchema: () => FetchRetryStrategySchema,
-  GetEndpointIndexResponseSchema: () => GetEndpointIndexResponseSchema,
-  GetEventSchema: () => GetEventSchema,
-  GetRunSchema: () => GetRunSchema,
-  GetRunStatusesSchema: () => GetRunStatusesSchema,
-  GetRunsSchema: () => GetRunsSchema,
-  HandleTriggerSourceSchema: () => HandleTriggerSourceSchema,
-  HttpSourceRequestHeadersSchema: () => HttpSourceRequestHeadersSchema,
-  HttpSourceRequestSchema: () => HttpSourceRequestSchema,
-  HttpSourceResponseSchema: () => HttpSourceResponseSchema,
-  IndexEndpointResponseSchema: () => IndexEndpointResponseSchema,
-  InitializeCronScheduleBodySchema: () => InitializeCronScheduleBodySchema,
-  InitializeTriggerBodySchema: () => InitializeTriggerBodySchema,
-  IntegrationConfigSchema: () => IntegrationConfigSchema,
-  IntegrationMetadataSchema: () => IntegrationMetadataSchema,
-  IntervalMetadataSchema: () => IntervalMetadataSchema,
-  IntervalOptionsSchema: () => IntervalOptionsSchema,
-  JobMetadataSchema: () => JobMetadataSchema,
-  JobRunStatusRecordSchema: () => JobRunStatusRecordSchema,
-  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,
-  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,
-  RetryOptionsSchema: () => RetryOptionsSchema,
-  RunJobAutoYieldExecutionErrorSchema: () => RunJobAutoYieldExecutionErrorSchema,
-  RunJobAutoYieldWithCompletedTaskExecutionErrorSchema: () => RunJobAutoYieldWithCompletedTaskExecutionErrorSchema,
-  RunJobBodySchema: () => RunJobBodySchema,
-  RunJobCanceledWithTaskSchema: () => RunJobCanceledWithTaskSchema,
-  RunJobErrorSchema: () => RunJobErrorSchema,
-  RunJobInvalidPayloadErrorSchema: () => RunJobInvalidPayloadErrorSchema,
-  RunJobResponseSchema: () => RunJobResponseSchema,
-  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,
-  SendEventBodySchema: () => SendEventBodySchema,
-  SendEventOptionsSchema: () => SendEventOptionsSchema,
-  SerializableJsonSchema: () => SerializableJsonSchema,
-  ServerTaskSchema: () => ServerTaskSchema,
-  SourceMetadataV2Schema: () => SourceMetadataV2Schema,
-  StaticTriggerMetadataSchema: () => StaticTriggerMetadataSchema,
-  StatusHistorySchema: () => StatusHistorySchema,
-  StatusUpdateSchema: () => StatusUpdateSchema,
-  StatusUpdateStateSchema: () => StatusUpdateStateSchema,
-  StyleSchema: () => StyleSchema,
-  TaskSchema: () => TaskSchema,
-  TaskStatusSchema: () => TaskStatusSchema,
-  TriggerMetadataSchema: () => TriggerMetadataSchema,
-  TriggerSourceSchema: () => TriggerSourceSchema,
-  UpdateTriggerSourceBodyV1Schema: () => UpdateTriggerSourceBodyV1Schema,
-  UpdateTriggerSourceBodyV2Schema: () => UpdateTriggerSourceBodyV2Schema,
-  ValidateErrorResponseSchema: () => ValidateErrorResponseSchema,
-  ValidateResponseSchema: () => ValidateResponseSchema,
-  ValidateSuccessResponseSchema: () => ValidateSuccessResponseSchema,
-  addMissingVersionField: () => addMissingVersionField,
-  calculateRetryAt: () => calculateRetryAt,
-  currentDate: () => currentDate,
-  currentTimestampMilliseconds: () => currentTimestampMilliseconds,
-  currentTimestampSeconds: () => currentTimestampSeconds,
-  deepMergeFilters: () => deepMergeFilters,
-  eventFilterMatches: () => eventFilterMatches,
-  parseEndpointIndexStats: () => parseEndpointIndexStats,
-  replacements: () => replacements,
-  supportsFeature: () => supportsFeature,
-  urlWithSearchParams: () => urlWithSearchParams
-});
-module.exports = __toCommonJS(src_exports);
+'use strict';
 
-// src/logger.ts
-var logLevels = [
-  "log",
-  "error",
-  "warn",
-  "info",
-  "debug"
-];
-var _name, _level, _filteredKeys, _jsonReplacer, _structuredLog, structuredLog_fn;
-var _Logger = class _Logger {
-  constructor(name, level = "info", filteredKeys = [], jsonReplacer) {
-    __privateAdd(this, _structuredLog);
-    __privateAdd(this, _name, void 0);
-    __privateAdd(this, _level, void 0);
-    __privateAdd(this, _filteredKeys, []);
-    __privateAdd(this, _jsonReplacer, void 0);
-    __privateSet(this, _name, name);
-    __privateSet(this, _level, logLevels.indexOf(process.env.TRIGGER_LOG_LEVEL ?? level));
-    __privateSet(this, _filteredKeys, filteredKeys);
-    __privateSet(this, _jsonReplacer, jsonReplacer);
-  }
-  // 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, ...args);
-  }
-  error(message, ...args) {
-    if (__privateGet(this, _level) < 1)
-      return;
-    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.error, message, ...args);
-  }
-  warn(message, ...args) {
-    if (__privateGet(this, _level) < 2)
-      return;
-    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.warn, message, ...args);
-  }
-  info(message, ...args) {
-    if (__privateGet(this, _level) < 3)
-      return;
-    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.info, message, ...args);
-  }
-  debug(message, ...args) {
-    if (__privateGet(this, _level) < 4)
-      return;
-    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.debug, message, ...args);
-  }
-};
-_name = new WeakMap();
-_level = new WeakMap();
-_filteredKeys = new WeakMap();
-_jsonReplacer = new WeakMap();
-_structuredLog = new WeakSet();
-structuredLog_fn = /* @__PURE__ */ __name(function(loggerFunction, message, ...args) {
-  const structuredLog = {
-    ...structureArgs(safeJsonClone(args), __privateGet(this, _filteredKeys)),
-    timestamp: /* @__PURE__ */ new Date(),
-    name: __privateGet(this, _name),
-    message
-  };
-  loggerFunction(JSON.stringify(structuredLog, createReplacer(__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 obj;
-  }
-}
-__name(safeJsonClone, "safeJsonClone");
-function structureArgs(args, filteredKeys = []) {
-  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 = Buffer.byteLength(JSON.stringify(value), "utf8");
-  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");
+var ulidx = require('ulidx');
+var zod = require('zod');
 
-// src/schemas/api.ts
-var import_ulid = require("ulid");
-var import_zod11 = require("zod");
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/schemas/addMissingVersionField.ts
 function addMissingVersionField(val) {
@@ -358,220 +17,211 @@ 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 SchemaErrorSchema = import_zod.z.object({
-  path: import_zod.z.array(import_zod.z.string()),
-  message: import_zod.z.string()
-});
-
-// src/schemas/eventFilter.ts
-var import_zod2 = require("zod");
-var EventMatcherSchema = import_zod2.z.union([
+var ErrorWithStackSchema = zod.z.object({
+  message: zod.z.string(),
+  name: zod.z.string().optional(),
+  stack: zod.z.string().optional()
+});
+var SchemaErrorSchema = zod.z.object({
+  path: zod.z.array(zod.z.string()),
+  message: zod.z.string()
+});
+var stringPatternMatchers = [
+  zod.z.object({
+    $endsWith: zod.z.string()
+  }),
+  zod.z.object({
+    $startsWith: zod.z.string()
+  }),
+  zod.z.object({
+    $ignoreCaseEquals: zod.z.string()
+  })
+];
+var EventMatcherSchema = zod.z.union([
   /** Match against a string */
-  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([
-    import_zod2.z.object({
-      $endsWith: import_zod2.z.string()
-    }),
-    import_zod2.z.object({
-      $startsWith: import_zod2.z.string()
+  zod.z.array(zod.z.boolean()),
+  zod.z.array(zod.z.union([
+    ...stringPatternMatchers,
+    zod.z.object({
+      $exists: zod.z.boolean()
     }),
-    import_zod2.z.object({
-      $exists: import_zod2.z.boolean()
+    zod.z.object({
+      $isNull: zod.z.boolean()
     }),
-    import_zod2.z.object({
-      $isNull: import_zod2.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()
       ])
     }),
-    import_zod2.z.object({
-      $ignoreCaseEquals: import_zod2.z.string()
+    zod.z.object({
+      $not: 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: 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({
-  /** 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)
+var IntervalOptionsSchema = zod.z.object({
+  /** The number of seconds for the interval. Min = 20, Max = 2_592_000 (30 days) */
+  seconds: zod.z.number().int().positive().min(20).max(2592e3)
 });
-var CronOptionsSchema = 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",
@@ -579,408 +229,548 @@ 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(),
-  error: import_zod7.z.string().optional().nullable(),
-  parentId: import_zod7.z.string().optional().nullable(),
+  context: DeserializedJsonSchema.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()
+  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 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())
+  properties: zod.z.array(DisplayPropertySchema).optional(),
+  schema: zod.z.any().optional(),
+  examples: zod.z.array(EventExampleSchema).optional()
+});
+var DynamicTriggerMetadataSchema = zod.z.object({
+  type: zod.z.literal("dynamic"),
+  id: zod.z.string()
+});
+var TriggerHelpSchema = zod.z.object({
+  noRuns: zod.z.object({
+    text: zod.z.string(),
+    link: zod.z.string().optional()
+  }).optional()
+});
+var StaticTriggerMetadataSchema = zod.z.object({
+  type: zod.z.literal("static"),
+  title: zod.z.union([
+    zod.z.string(),
+    zod.z.array(zod.z.string())
   ]),
-  properties: import_zod8.z.array(DisplayPropertySchema).optional(),
-  rule: EventRuleSchema
+  properties: zod.z.array(DisplayPropertySchema).optional(),
+  rule: EventRuleSchema,
+  link: zod.z.string().optional(),
+  help: TriggerHelpSchema.optional()
+});
+var InvokeTriggerMetadataSchema = zod.z.object({
+  type: zod.z.literal("invoke")
 });
-var ScheduledTriggerMetadataSchema = 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
+  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")
+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()
+});
+var StringMatchSchema = zod.z.union([
+  /** Match against a string */
+  zod.z.array(zod.z.string()),
+  zod.z.array(zod.z.union(stringPatternMatchers))
+]);
+var HTTPMethodUnionSchema = zod.z.union([
+  zod.z.literal("GET"),
+  zod.z.literal("POST"),
+  zod.z.literal("PUT"),
+  zod.z.literal("PATCH"),
+  zod.z.literal("DELETE"),
+  zod.z.literal("HEAD"),
+  zod.z.literal("OPTIONS")
+]);
+var RequestFilterSchema = zod.z.object({
+  /** An array of HTTP methods to match.
+  * For example, `["GET", "POST"]` will match both `GET` and `POST` Requests. */
+  method: zod.z.array(HTTPMethodUnionSchema).optional(),
+  /** An object of header key/values to match. 
+     * This uses the [EventFilter matching syntax](https://trigger.dev/docs/documentation/guides/event-filter).
+  
+      @example
+    ```ts
+    filter: {
+      header: {
+        "content-type": ["application/json"],
+      },
+    },
+    ``` */
+  headers: zod.z.record(StringMatchSchema).optional(),
+  /** An object of query parameters to match. 
+     * This uses the [EventFilter matching syntax](https://trigger.dev/docs/documentation/guides/event-filter).
+  
+    @example
+    ```ts
+    filter: {
+      query: {
+        "hub.mode": [{ $startsWith: "sub" }],
+      },
+    },
+    ``` */
+  query: zod.z.record(StringMatchSchema).optional(),
+  /** An object of key/values to match.
+  * This uses the [EventFilter matching syntax](https://trigger.dev/docs/documentation/guides/event-filter).
+  */
+  body: EventFilterSchema.optional()
+});
+var ResponseFilterSchema = RequestFilterSchema.omit({
+  method: true,
+  query: true
+}).extend({
+  status: zod.z.array(zod.z.number()).optional()
 });
 
 // src/schemas/api.ts
-var UpdateTriggerSourceBodyV1Schema = import_zod11.z.object({
-  registeredEvents: import_zod11.z.array(import_zod11.z.string()),
-  secret: import_zod11.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_zod11.z.object({
-  secret: import_zod11.z.string().optional(),
+var UpdateTriggerSourceBodyV2Schema = zod.z.object({
+  secret: zod.z.string().optional(),
   data: SerializableJsonSchema.optional(),
-  options: import_zod11.z.object({
-    event: import_zod11.z.array(import_zod11.z.string())
-  }).and(import_zod11.z.record(import_zod11.z.string(), import_zod11.z.array(import_zod11.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 RegisterHTTPTriggerSourceBodySchema = import_zod11.z.object({
-  type: import_zod11.z.literal("HTTP"),
-  url: import_zod11.z.string().url()
+var UpdateWebhookBodySchema = zod.z.discriminatedUnion("active", [
+  zod.z.object({
+    active: zod.z.literal(false)
+  }),
+  zod.z.object({
+    active: zod.z.literal(true),
+    config: zod.z.record(zod.z.string().array())
+  })
+]);
+var RegisterHTTPTriggerSourceBodySchema = zod.z.object({
+  type: zod.z.literal("HTTP"),
+  url: zod.z.string().url()
 });
-var RegisterSMTPTriggerSourceBodySchema = import_zod11.z.object({
-  type: import_zod11.z.literal("SMTP")
+var RegisterSMTPTriggerSourceBodySchema = zod.z.object({
+  type: zod.z.literal("SMTP")
 });
-var RegisterSQSTriggerSourceBodySchema = import_zod11.z.object({
-  type: import_zod11.z.literal("SQS")
+var RegisterSQSTriggerSourceBodySchema = zod.z.object({
+  type: zod.z.literal("SQS")
 });
-var RegisterSourceChannelBodySchema = import_zod11.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 = zod.z.object({
+  key: zod.z.string(),
+  params: zod.z.any(),
+  config: zod.z.any(),
+  active: zod.z.boolean(),
+  secret: zod.z.string(),
+  url: zod.z.string(),
+  data: DeserializedJsonSchema.optional(),
+  clientId: zod.z.string().optional()
+});
+var RegisterWebhookPayloadSchema = zod.z.object({
+  active: zod.z.boolean(),
+  params: zod.z.any().optional(),
+  config: zod.z.object({
+    current: zod.z.record(zod.z.string().array()),
+    desired: zod.z.record(zod.z.string().array())
+  }),
+  // from HTTP Endpoint
+  url: zod.z.string(),
+  secret: zod.z.string()
+});
 var REGISTER_SOURCE_EVENT_V1 = "dev.trigger.source.register";
 var REGISTER_SOURCE_EVENT_V2 = "dev.trigger.source.register.v2";
-var RegisterTriggerSourceSchema = import_zod11.z.object({
-  key: import_zod11.z.string(),
-  params: import_zod11.z.any(),
-  active: import_zod11.z.boolean(),
-  secret: import_zod11.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_zod11.z.string().optional()
+  clientId: zod.z.string().optional()
 });
-var SourceEventOptionSchema = import_zod11.z.object({
-  name: import_zod11.z.string(),
-  value: import_zod11.z.string()
+zod.z.object({
+  name: zod.z.string(),
+  value: zod.z.string()
 });
-var RegisterSourceEventSchemaV1 = import_zod11.z.object({
+var RegisterSourceEventSchemaV1 = zod.z.object({
   /** The id of the source */
-  id: import_zod11.z.string(),
+  id: zod.z.string(),
   source: RegisterTriggerSourceSchema,
-  events: import_zod11.z.array(import_zod11.z.string()),
-  missingEvents: import_zod11.z.array(import_zod11.z.string()),
-  orphanedEvents: import_zod11.z.array(import_zod11.z.string()),
-  dynamicTriggerId: import_zod11.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_zod11.z.object({
-  desired: import_zod11.z.array(import_zod11.z.string()),
-  missing: import_zod11.z.array(import_zod11.z.string()),
-  orphaned: import_zod11.z.array(import_zod11.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_zod11.z.object({
+var RegisterSourceEventOptionsSchema = zod.z.object({
   event: RegisteredOptionsDiffSchema
-}).and(import_zod11.z.record(import_zod11.z.string(), RegisteredOptionsDiffSchema));
-var RegisterSourceEventSchemaV2 = import_zod11.z.object({
+}).and(zod.z.record(zod.z.string(), RegisteredOptionsDiffSchema));
+var RegisterSourceEventSchemaV2 = zod.z.object({
   /** The id of the source */
-  id: import_zod11.z.string(),
+  id: zod.z.string(),
   source: RegisterTriggerSourceSchema,
   options: RegisterSourceEventOptionsSchema,
-  dynamicTriggerId: import_zod11.z.string().optional()
+  dynamicTriggerId: zod.z.string().optional()
 });
-var TriggerSourceSchema = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  key: import_zod11.z.string()
+var TriggerSourceSchema = zod.z.object({
+  id: zod.z.string(),
+  key: zod.z.string()
 });
 var HttpSourceResponseMetadataSchema = DeserializedJsonSchema;
-var HandleTriggerSourceSchema = import_zod11.z.object({
-  key: import_zod11.z.string(),
-  secret: import_zod11.z.string(),
-  data: import_zod11.z.any(),
-  params: import_zod11.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 HttpSourceRequestSchema = import_zod11.z.object({
-  url: import_zod11.z.string().url(),
-  method: import_zod11.z.string(),
-  headers: import_zod11.z.record(import_zod11.z.string()),
-  rawBody: import_zod11.z.instanceof(Buffer).optional().nullable()
-});
-var HttpSourceRequestHeadersSchema = import_zod11.z.object({
-  "x-ts-key": import_zod11.z.string(),
-  "x-ts-dynamic-id": import_zod11.z.string().optional(),
-  "x-ts-secret": import_zod11.z.string(),
-  "x-ts-data": import_zod11.z.string().transform((s) => JSON.parse(s)),
-  "x-ts-params": import_zod11.z.string().transform((s) => JSON.parse(s)),
-  "x-ts-http-url": import_zod11.z.string(),
-  "x-ts-http-method": import_zod11.z.string(),
-  "x-ts-http-headers": import_zod11.z.string().transform((s) => import_zod11.z.record(import_zod11.z.string()).parse(JSON.parse(s))),
-  "x-ts-auth": import_zod11.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_zod11.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 PongSuccessResponseSchema = import_zod11.z.object({
-  ok: import_zod11.z.literal(true),
-  triggerVersion: import_zod11.z.string().optional(),
-  triggerSdkVersion: import_zod11.z.string().optional()
-});
-var PongErrorResponseSchema = import_zod11.z.object({
-  ok: import_zod11.z.literal(false),
-  error: import_zod11.z.string(),
-  triggerVersion: import_zod11.z.string().optional(),
-  triggerSdkVersion: import_zod11.z.string().optional()
-});
-var PongResponseSchema = import_zod11.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_zod11.z.object({
-  ok: import_zod11.z.literal(true),
-  endpointId: import_zod11.z.string(),
-  triggerVersion: import_zod11.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_zod11.z.object({
-  ok: import_zod11.z.literal(false),
-  error: import_zod11.z.string(),
-  triggerVersion: import_zod11.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_zod11.z.discriminatedUnion("ok", [
+var ValidateResponseSchema = zod.z.discriminatedUnion("ok", [
   ValidateSuccessResponseSchema,
   ValidateErrorResponseSchema
 ]);
-var QueueOptionsSchema = import_zod11.z.object({
-  name: import_zod11.z.string(),
-  maxConcurrent: import_zod11.z.number().optional()
-});
-var JobMetadataSchema = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  name: import_zod11.z.string(),
-  version: import_zod11.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_zod11.z.record(IntegrationConfigSchema),
-  internal: import_zod11.z.boolean().default(false),
-  enabled: import_zod11.z.boolean(),
-  startPosition: import_zod11.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_zod11.z.boolean()
+  preprocessRuns: zod.z.boolean(),
+  concurrencyLimit: ConcurrencyLimitOptionsSchema.or(zod.z.number().int().positive()).optional()
 });
-var SourceMetadataV1Schema = import_zod11.z.object({
-  version: import_zod11.z.literal("1"),
-  channel: import_zod11.z.enum([
+var SourceMetadataV1Schema = zod.z.object({
+  version: zod.z.literal("1"),
+  channel: zod.z.enum([
     "HTTP",
     "SQS",
     "SMTP"
   ]),
   integration: IntegrationConfigSchema,
-  key: import_zod11.z.string(),
-  params: import_zod11.z.any(),
-  events: import_zod11.z.array(import_zod11.z.string()),
-  registerSourceJob: import_zod11.z.object({
-    id: import_zod11.z.string(),
-    version: import_zod11.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_zod11.z.object({
-  version: import_zod11.z.literal("2"),
-  channel: import_zod11.z.enum([
+var SourceMetadataV2Schema = zod.z.object({
+  version: zod.z.literal("2"),
+  channel: zod.z.enum([
     "HTTP",
     "SQS",
     "SMTP"
   ]),
   integration: IntegrationConfigSchema,
-  key: import_zod11.z.string(),
-  params: import_zod11.z.any(),
-  options: import_zod11.z.record(import_zod11.z.array(import_zod11.z.string())),
-  registerSourceJob: import_zod11.z.object({
-    id: import_zod11.z.string(),
-    version: import_zod11.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_zod11.z.preprocess(addMissingVersionField, import_zod11.z.discriminatedUnion("version", [
+var SourceMetadataSchema = zod.z.preprocess(addMissingVersionField, zod.z.discriminatedUnion("version", [
   SourceMetadataV1Schema,
   SourceMetadataV2Schema
 ]));
-var DynamicTriggerEndpointMetadataSchema = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  jobs: import_zod11.z.array(JobMetadataSchema.pick({
+var WebhookMetadataSchema = zod.z.object({
+  key: zod.z.string(),
+  params: zod.z.any(),
+  config: zod.z.record(zod.z.array(zod.z.string())),
+  integration: IntegrationConfigSchema,
+  httpEndpoint: zod.z.object({
+    id: zod.z.string()
+  })
+});
+var WebhookContextMetadataSchema = zod.z.object({
+  params: zod.z.any(),
+  config: zod.z.record(zod.z.string().array()),
+  secret: zod.z.string()
+});
+var DynamicTriggerEndpointMetadataSchema = zod.z.object({
+  id: zod.z.string(),
+  jobs: zod.z.array(JobMetadataSchema.pick({
     id: true,
     version: true
   })),
-  registerSourceJob: import_zod11.z.object({
-    id: import_zod11.z.string(),
-    version: import_zod11.z.string()
+  registerSourceJob: zod.z.object({
+    id: zod.z.string(),
+    version: zod.z.string()
   }).optional()
 });
-var IndexEndpointResponseSchema = import_zod11.z.object({
-  jobs: import_zod11.z.array(JobMetadataSchema),
-  sources: import_zod11.z.array(SourceMetadataSchema),
-  dynamicTriggers: import_zod11.z.array(DynamicTriggerEndpointMetadataSchema),
-  dynamicSchedules: import_zod11.z.array(RegisterDynamicSchedulePayloadSchema)
-});
-var EndpointIndexErrorSchema = import_zod11.z.object({
-  message: import_zod11.z.string(),
-  raw: import_zod11.z.any().optional()
-});
-var IndexEndpointStatsSchema = import_zod11.z.object({
-  jobs: import_zod11.z.number(),
-  sources: import_zod11.z.number(),
-  dynamicTriggers: import_zod11.z.number(),
-  dynamicSchedules: import_zod11.z.number(),
-  disabledJobs: import_zod11.z.number().default(0)
+var HttpEndpointMetadataSchema = zod.z.object({
+  id: zod.z.string(),
+  version: zod.z.string(),
+  enabled: zod.z.boolean(),
+  title: zod.z.string().optional(),
+  icon: zod.z.string().optional(),
+  properties: zod.z.array(DisplayPropertySchema).optional(),
+  event: EventSpecificationSchema,
+  immediateResponseFilter: RequestFilterSchema.optional(),
+  skipTriggeringRuns: zod.z.boolean().optional(),
+  source: zod.z.string()
+});
+var IndexEndpointResponseSchema = zod.z.object({
+  jobs: zod.z.array(JobMetadataSchema),
+  sources: zod.z.array(SourceMetadataSchema),
+  webhooks: zod.z.array(WebhookMetadataSchema).optional(),
+  dynamicTriggers: zod.z.array(DynamicTriggerEndpointMetadataSchema),
+  dynamicSchedules: zod.z.array(RegisterDynamicSchedulePayloadSchema),
+  httpEndpoints: zod.z.array(HttpEndpointMetadataSchema).optional()
+});
+var EndpointIndexErrorSchema = zod.z.object({
+  message: zod.z.string(),
+  raw: zod.z.any().optional()
+});
+var IndexEndpointStatsSchema = zod.z.object({
+  jobs: zod.z.number(),
+  sources: zod.z.number(),
+  webhooks: zod.z.number().optional(),
+  dynamicTriggers: zod.z.number(),
+  dynamicSchedules: zod.z.number(),
+  disabledJobs: zod.z.number().default(0),
+  httpEndpoints: zod.z.number().default(0)
 });
 function parseEndpointIndexStats(stats) {
   if (stats === null || stats === void 0) {
@@ -989,208 +779,227 @@ function parseEndpointIndexStats(stats) {
   return IndexEndpointStatsSchema.parse(stats);
 }
 __name(parseEndpointIndexStats, "parseEndpointIndexStats");
-var GetEndpointIndexResponseSchema = import_zod11.z.discriminatedUnion("status", [
-  import_zod11.z.object({
-    status: import_zod11.z.literal("PENDING"),
-    updatedAt: import_zod11.z.coerce.date()
+var GetEndpointIndexResponseSchema = zod.z.discriminatedUnion("status", [
+  zod.z.object({
+    status: zod.z.literal("PENDING"),
+    updatedAt: zod.z.coerce.date()
   }),
-  import_zod11.z.object({
-    status: import_zod11.z.literal("STARTED"),
-    updatedAt: import_zod11.z.coerce.date()
+  zod.z.object({
+    status: zod.z.literal("STARTED"),
+    updatedAt: zod.z.coerce.date()
   }),
-  import_zod11.z.object({
-    status: import_zod11.z.literal("SUCCESS"),
+  zod.z.object({
+    status: zod.z.literal("SUCCESS"),
     stats: IndexEndpointStatsSchema,
-    updatedAt: import_zod11.z.coerce.date()
+    updatedAt: zod.z.coerce.date()
   }),
-  import_zod11.z.object({
-    status: import_zod11.z.literal("FAILURE"),
+  zod.z.object({
+    status: zod.z.literal("FAILURE"),
     error: EndpointIndexErrorSchema,
-    updatedAt: import_zod11.z.coerce.date()
+    updatedAt: zod.z.coerce.date()
   })
 ]);
-var EndpointHeadersSchema = import_zod11.z.object({
-  "trigger-version": import_zod11.z.string().optional(),
-  "trigger-sdk-version": import_zod11.z.string().optional()
+var EndpointHeadersSchema = zod.z.object({
+  "trigger-version": zod.z.string().optional(),
+  "trigger-sdk-version": zod.z.string().optional()
+});
+var ExecuteJobRunMetadataSchema = zod.z.object({
+  successSubscription: zod.z.boolean().optional(),
+  failedSubscription: zod.z.boolean().optional()
 });
-var RawEventSchema = import_zod11.z.object({
+var ExecuteJobHeadersSchema = EndpointHeadersSchema.extend({
+  "x-trigger-run-metadata": zod.z.preprocess((val) => typeof val === "string" && JSON.parse(val), ExecuteJobRunMetadataSchema).optional()
+});
+var RawEventSchema = zod.z.object({
   /** The `name` property must exactly match any subscriptions you want to
     trigger. */
-  name: import_zod11.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_zod11.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_zod11.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_zod11.z.string().default(() => (0, import_ulid.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_zod11.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_zod11.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: zod.z.union([
+    zod.z.literal("JSON"),
+    zod.z.literal("REQUEST")
+  ]).optional()
 });
-var ApiEventLogSchema = import_zod11.z.object({
+var ApiEventLogSchema = zod.z.object({
   /** The `id` of the event that was sent.
   */
-  id: import_zod11.z.string(),
+  id: zod.z.string(),
   /** The `name` of the event that was sent. */
-  name: import_zod11.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_zod11.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_zod11.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_zod11.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_zod11.z.coerce.date().optional().nullable()
+  cancelledAt: zod.z.coerce.date().optional().nullable()
 });
-var SendEventOptionsSchema = import_zod11.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_zod11.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_zod11.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_zod11.z.string().optional()
+  accountId: zod.z.string().optional()
 });
-var SendEventBodySchema = import_zod11.z.object({
+var SendEventBodySchema = zod.z.object({
   event: RawEventSchema,
   options: SendEventOptionsSchema.optional()
 });
-var DeliverEventResponseSchema = import_zod11.z.object({
-  deliveredAt: import_zod11.z.string().datetime()
+var SendBulkEventsBodySchema = zod.z.object({
+  events: RawEventSchema.array(),
+  options: SendEventOptionsSchema.optional()
 });
-var RuntimeEnvironmentTypeSchema = import_zod11.z.enum([
+var DeliverEventResponseSchema = zod.z.object({
+  deliveredAt: zod.z.string().datetime()
+});
+var RuntimeEnvironmentTypeSchema = zod.z.enum([
   "PRODUCTION",
   "STAGING",
   "DEVELOPMENT",
   "PREVIEW"
 ]);
-var RunSourceContextSchema = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  metadata: import_zod11.z.any()
+var RunSourceContextSchema = zod.z.object({
+  id: zod.z.string(),
+  metadata: zod.z.any()
 });
-var AutoYieldConfigSchema = import_zod11.z.object({
-  startTaskThreshold: import_zod11.z.number(),
-  beforeExecuteTaskThreshold: import_zod11.z.number(),
-  beforeCompleteTaskThreshold: import_zod11.z.number(),
-  afterCompleteTaskThreshold: import_zod11.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_zod11.z.object({
+var RunJobBodySchema = zod.z.object({
   event: ApiEventLogSchema,
-  job: import_zod11.z.object({
-    id: import_zod11.z.string(),
-    version: import_zod11.z.string()
+  job: zod.z.object({
+    id: zod.z.string(),
+    version: zod.z.string()
   }),
-  run: import_zod11.z.object({
-    id: import_zod11.z.string(),
-    isTest: import_zod11.z.boolean(),
-    isRetry: import_zod11.z.boolean().default(false),
-    startedAt: import_zod11.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_zod11.z.object({
-    id: import_zod11.z.string(),
-    slug: import_zod11.z.string(),
+  environment: zod.z.object({
+    id: zod.z.string(),
+    slug: zod.z.string(),
     type: RuntimeEnvironmentTypeSchema
   }),
-  organization: import_zod11.z.object({
-    id: import_zod11.z.string(),
-    title: import_zod11.z.string(),
-    slug: import_zod11.z.string()
+  organization: zod.z.object({
+    id: zod.z.string(),
+    title: zod.z.string(),
+    slug: zod.z.string()
   }),
-  account: import_zod11.z.object({
-    id: import_zod11.z.string(),
-    metadata: import_zod11.z.any()
+  project: zod.z.object({
+    id: zod.z.string(),
+    name: zod.z.string(),
+    slug: zod.z.string()
+  }).optional(),
+  account: zod.z.object({
+    id: zod.z.string(),
+    metadata: zod.z.any()
   }).optional(),
   source: RunSourceContextSchema.optional(),
-  tasks: import_zod11.z.array(CachedTaskSchema).optional(),
-  cachedTaskCursor: import_zod11.z.string().optional(),
-  noopTasksSet: import_zod11.z.string().optional(),
-  connections: import_zod11.z.record(ConnectionAuthSchema).optional(),
-  yieldedExecutions: import_zod11.z.string().array().optional(),
-  runChunkExecutionLimit: import_zod11.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_zod11.z.object({
-  status: import_zod11.z.literal("ERROR"),
+var RunJobErrorSchema = zod.z.object({
+  status: zod.z.literal("ERROR"),
   error: ErrorWithStackSchema,
   task: TaskSchema.optional()
 });
-var RunJobYieldExecutionErrorSchema = import_zod11.z.object({
-  status: import_zod11.z.literal("YIELD_EXECUTION"),
-  key: import_zod11.z.string()
-});
-var RunJobAutoYieldExecutionErrorSchema = import_zod11.z.object({
-  status: import_zod11.z.literal("AUTO_YIELD_EXECUTION"),
-  location: import_zod11.z.string(),
-  timeRemaining: import_zod11.z.number(),
-  timeElapsed: import_zod11.z.number(),
-  limit: import_zod11.z.number().optional()
-});
-var RunJobAutoYieldWithCompletedTaskExecutionErrorSchema = import_zod11.z.object({
-  status: import_zod11.z.literal("AUTO_YIELD_EXECUTION_WITH_COMPLETED_TASK"),
-  id: import_zod11.z.string(),
-  properties: import_zod11.z.array(DisplayPropertySchema).optional(),
-  output: import_zod11.z.any(),
-  data: import_zod11.z.object({
-    location: import_zod11.z.string(),
-    timeRemaining: import_zod11.z.number(),
-    timeElapsed: import_zod11.z.number(),
-    limit: import_zod11.z.number().optional()
-  })
-});
-var RunJobInvalidPayloadErrorSchema = import_zod11.z.object({
-  status: import_zod11.z.literal("INVALID_PAYLOAD"),
-  errors: import_zod11.z.array(SchemaErrorSchema)
-});
-var RunJobUnresolvedAuthErrorSchema = import_zod11.z.object({
-  status: import_zod11.z.literal("UNRESOLVED_AUTH_ERROR"),
-  issues: import_zod11.z.record(import_zod11.z.object({
-    id: import_zod11.z.string(),
-    error: import_zod11.z.string()
+var RunJobYieldExecutionErrorSchema = zod.z.object({
+  status: zod.z.literal("YIELD_EXECUTION"),
+  key: zod.z.string()
+});
+var AutoYieldMetadataSchema = zod.z.object({
+  location: zod.z.string(),
+  timeRemaining: zod.z.number(),
+  timeElapsed: zod.z.number(),
+  limit: zod.z.number().optional()
+});
+var RunJobAutoYieldExecutionErrorSchema = AutoYieldMetadataSchema.extend({
+  status: zod.z.literal("AUTO_YIELD_EXECUTION")
+});
+var RunJobAutoYieldWithCompletedTaskExecutionErrorSchema = zod.z.object({
+  status: zod.z.literal("AUTO_YIELD_EXECUTION_WITH_COMPLETED_TASK"),
+  id: zod.z.string(),
+  properties: zod.z.array(DisplayPropertySchema).optional(),
+  output: zod.z.string().optional(),
+  data: AutoYieldMetadataSchema
+});
+var RunJobInvalidPayloadErrorSchema = zod.z.object({
+  status: zod.z.literal("INVALID_PAYLOAD"),
+  errors: zod.z.array(SchemaErrorSchema)
+});
+var RunJobUnresolvedAuthErrorSchema = zod.z.object({
+  status: zod.z.literal("UNRESOLVED_AUTH_ERROR"),
+  issues: zod.z.record(zod.z.object({
+    id: zod.z.string(),
+    error: zod.z.string()
   }))
 });
-var RunJobResumeWithTaskSchema = import_zod11.z.object({
-  status: import_zod11.z.literal("RESUME_WITH_TASK"),
+var RunJobResumeWithTaskSchema = zod.z.object({
+  status: zod.z.literal("RESUME_WITH_TASK"),
   task: TaskSchema
 });
-var RunJobRetryWithTaskSchema = import_zod11.z.object({
-  status: import_zod11.z.literal("RETRY_WITH_TASK"),
+var RunJobRetryWithTaskSchema = zod.z.object({
+  status: zod.z.literal("RETRY_WITH_TASK"),
   task: TaskSchema,
   error: ErrorWithStackSchema,
-  retryAt: import_zod11.z.coerce.date()
+  retryAt: zod.z.coerce.date()
 });
-var RunJobCanceledWithTaskSchema = import_zod11.z.object({
-  status: import_zod11.z.literal("CANCELED"),
+var RunJobCanceledWithTaskSchema = zod.z.object({
+  status: zod.z.literal("CANCELED"),
   task: TaskSchema
 });
-var RunJobSuccessSchema = import_zod11.z.object({
-  status: import_zod11.z.literal("SUCCESS"),
+var RunJobSuccessSchema = zod.z.object({
+  status: zod.z.literal("SUCCESS"),
   output: DeserializedJsonSchema.optional()
 });
-var RunJobResponseSchema = import_zod11.z.discriminatedUnion("status", [
+var RunJobErrorResponseSchema = zod.z.union([
   RunJobAutoYieldExecutionErrorSchema,
   RunJobAutoYieldWithCompletedTaskExecutionErrorSchema,
   RunJobYieldExecutionErrorSchema,
@@ -1199,138 +1008,157 @@ var RunJobResponseSchema = import_zod11.z.discriminatedUnion("status", [
   RunJobInvalidPayloadErrorSchema,
   RunJobResumeWithTaskSchema,
   RunJobRetryWithTaskSchema,
+  RunJobCanceledWithTaskSchema
+]);
+var RunJobResumeWithParallelTaskSchema = zod.z.object({
+  status: zod.z.literal("RESUME_WITH_PARALLEL_TASK"),
+  task: TaskSchema,
+  childErrors: zod.z.array(RunJobErrorResponseSchema)
+});
+var RunJobResponseSchema = zod.z.discriminatedUnion("status", [
+  RunJobAutoYieldExecutionErrorSchema,
+  RunJobAutoYieldWithCompletedTaskExecutionErrorSchema,
+  RunJobYieldExecutionErrorSchema,
+  RunJobErrorSchema,
+  RunJobUnresolvedAuthErrorSchema,
+  RunJobInvalidPayloadErrorSchema,
+  RunJobResumeWithTaskSchema,
+  RunJobResumeWithParallelTaskSchema,
+  RunJobRetryWithTaskSchema,
   RunJobCanceledWithTaskSchema,
   RunJobSuccessSchema
 ]);
-var PreprocessRunBodySchema = import_zod11.z.object({
+var PreprocessRunBodySchema = zod.z.object({
   event: ApiEventLogSchema,
-  job: import_zod11.z.object({
-    id: import_zod11.z.string(),
-    version: import_zod11.z.string()
+  job: zod.z.object({
+    id: zod.z.string(),
+    version: zod.z.string()
   }),
-  run: import_zod11.z.object({
-    id: import_zod11.z.string(),
-    isTest: import_zod11.z.boolean()
+  run: zod.z.object({
+    id: zod.z.string(),
+    isTest: zod.z.boolean()
   }),
-  environment: import_zod11.z.object({
-    id: import_zod11.z.string(),
-    slug: import_zod11.z.string(),
+  environment: zod.z.object({
+    id: zod.z.string(),
+    slug: zod.z.string(),
     type: RuntimeEnvironmentTypeSchema
   }),
-  organization: import_zod11.z.object({
-    id: import_zod11.z.string(),
-    title: import_zod11.z.string(),
-    slug: import_zod11.z.string()
+  organization: zod.z.object({
+    id: zod.z.string(),
+    title: zod.z.string(),
+    slug: zod.z.string()
   }),
-  account: import_zod11.z.object({
-    id: import_zod11.z.string(),
-    metadata: import_zod11.z.any()
+  account: zod.z.object({
+    id: zod.z.string(),
+    metadata: zod.z.any()
   }).optional()
 });
-var PreprocessRunResponseSchema = import_zod11.z.object({
-  abort: import_zod11.z.boolean(),
-  properties: import_zod11.z.array(DisplayPropertySchema).optional()
+var PreprocessRunResponseSchema = zod.z.object({
+  abort: zod.z.boolean(),
+  properties: zod.z.array(DisplayPropertySchema).optional()
 });
-var CreateRunResponseOkSchema = import_zod11.z.object({
-  ok: import_zod11.z.literal(true),
-  data: import_zod11.z.object({
-    id: import_zod11.z.string()
+var CreateRunResponseOkSchema = zod.z.object({
+  ok: zod.z.literal(true),
+  data: zod.z.object({
+    id: zod.z.string()
   })
 });
-var CreateRunResponseErrorSchema = import_zod11.z.object({
-  ok: import_zod11.z.literal(false),
-  error: import_zod11.z.string()
+var CreateRunResponseErrorSchema = zod.z.object({
+  ok: zod.z.literal(false),
+  error: zod.z.string()
 });
-var CreateRunResponseBodySchema = import_zod11.z.discriminatedUnion("ok", [
+var CreateRunResponseBodySchema = zod.z.discriminatedUnion("ok", [
   CreateRunResponseOkSchema,
   CreateRunResponseErrorSchema
 ]);
-var RedactStringSchema = import_zod11.z.object({
-  __redactedString: import_zod11.z.literal(true),
-  strings: import_zod11.z.array(import_zod11.z.string()),
-  interpolations: import_zod11.z.array(import_zod11.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_zod11.z.object({
-  level: import_zod11.z.enum([
+var LogMessageSchema = zod.z.object({
+  level: zod.z.enum([
     "DEBUG",
     "INFO",
     "WARN",
     "ERROR"
   ]),
-  message: import_zod11.z.string(),
+  message: zod.z.string(),
   data: SerializableJsonSchema.optional()
 });
-var RedactSchema = import_zod11.z.object({
-  paths: import_zod11.z.array(import_zod11.z.string())
+var RedactSchema = zod.z.object({
+  paths: zod.z.array(zod.z.string())
 });
-var RetryOptionsSchema = import_zod11.z.object({
+var RetryOptionsSchema = zod.z.object({
   /** The maximum number of times to retry the request. */
-  limit: import_zod11.z.number().optional(),
+  limit: zod.z.number().optional(),
   /** The exponential factor to use when calculating the next retry time. */
-  factor: import_zod11.z.number().optional(),
+  factor: zod.z.number().optional(),
   /** The minimum amount of time to wait before retrying the request. */
-  minTimeoutInMs: import_zod11.z.number().optional(),
+  minTimeoutInMs: zod.z.number().optional(),
   /** The maximum amount of time to wait before retrying the request. */
-  maxTimeoutInMs: import_zod11.z.number().optional(),
+  maxTimeoutInMs: zod.z.number().optional(),
   /** Whether to randomize the retry time. */
-  randomize: import_zod11.z.boolean().optional()
+  randomize: zod.z.boolean().optional()
 });
-var RunTaskOptionsSchema = import_zod11.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_zod11.z.string().optional(),
+  name: zod.z.string().optional(),
   /** The Task will wait and only start at the specified Date  */
-  delayUntil: import_zod11.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 [Font Awesome](https://fontawesome.com/icons) supports. */
-  icon: import_zod11.z.string().optional(),
+  *  Or any icon name that [Tabler Icons](https://tabler-icons.io/) supports. */
+  icon: zod.z.string().optional(),
   /** The key for the Task that you want to appear in the logs */
-  displayKey: import_zod11.z.string().optional(),
+  displayKey: zod.z.string().optional(),
   /** A description of the Task */
-  description: import_zod11.z.string().optional(),
+  description: zod.z.string().optional(),
   /** Properties that are displayed in the logs */
-  properties: import_zod11.z.array(DisplayPropertySchema).optional(),
+  properties: zod.z.array(DisplayPropertySchema).optional(),
   /** The input params to the Task, will be displayed in the logs  */
-  params: import_zod11.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_zod11.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_zod11.z.boolean(),
+    enabled: zod.z.boolean(),
     /** Time to wait for the first request to `task.callbackUrl`. Default: One hour. */
-    timeoutInSeconds: import_zod11.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_zod11.z.string().optional(),
-  /** An operation you want to perform on the Trigger.dev platform, current only "fetch" is supported. If you wish to `fetch` use [`io.backgroundFetch()`](https://trigger.dev/docs/sdk/io/backgroundfetch) instead. */
-  operation: import_zod11.z.enum([
-    "fetch"
+  connectionKey: zod.z.string().optional(),
+  /** An operation you want to perform on the Trigger.dev platform, current only "fetch", "fetch-response", and "fetch-poll" is supported. If you wish to `fetch` use [`io.backgroundFetch()`](https://trigger.dev/docs/sdk/io/backgroundfetch) instead. */
+  operation: zod.z.enum([
+    "fetch",
+    "fetch-response",
+    "fetch-poll"
   ]).optional(),
   /** A No Operation means that the code won't be executed. This is used internally to implement features like [io.wait()](https://trigger.dev/docs/sdk/io/wait).  */
-  noop: import_zod11.z.boolean().default(false),
+  noop: zod.z.boolean().default(false),
   redact: RedactSchema.optional(),
-  trigger: TriggerMetadataSchema.optional()
+  parallel: zod.z.boolean().optional()
 });
 var RunTaskBodyInputSchema = RunTaskOptionsSchema.extend({
-  idempotencyKey: import_zod11.z.string(),
-  parentId: import_zod11.z.string().optional()
+  idempotencyKey: zod.z.string(),
+  parentId: zod.z.string().optional()
 });
 var RunTaskBodyOutputSchema = RunTaskBodyInputSchema.extend({
-  properties: import_zod11.z.array(DisplayPropertySchema.partial()).optional(),
+  properties: zod.z.array(DisplayPropertySchema.partial()).optional(),
   params: DeserializedJsonSchema.optional().nullable(),
-  callback: import_zod11.z.object({
-    enabled: import_zod11.z.boolean(),
-    timeoutInSeconds: import_zod11.z.number().default(3600)
+  callback: zod.z.object({
+    enabled: zod.z.boolean(),
+    timeoutInSeconds: zod.z.number().default(3600)
   }).optional()
 });
-var RunTaskResponseWithCachedTasksBodySchema = import_zod11.z.object({
+var RunTaskResponseWithCachedTasksBodySchema = zod.z.object({
   task: ServerTaskSchema,
-  cachedTasks: import_zod11.z.object({
-    tasks: import_zod11.z.array(CachedTaskSchema),
-    cursor: import_zod11.z.string().optional()
+  cachedTasks: zod.z.object({
+    tasks: zod.z.array(CachedTaskSchema),
+    cursor: zod.z.string().optional()
   }).optional()
 });
 var CompleteTaskBodyInputSchema = RunTaskBodyInputSchema.pick({
@@ -1340,199 +1168,291 @@ var CompleteTaskBodyInputSchema = RunTaskBodyInputSchema.pick({
 }).extend({
   output: SerializableJsonSchema.optional().transform((v) => v ? DeserializedJsonSchema.parse(JSON.parse(JSON.stringify(v))) : {})
 });
-var FailTaskBodyInputSchema = import_zod11.z.object({
+var CompleteTaskBodyV2InputSchema = RunTaskBodyInputSchema.pick({
+  properties: true,
+  description: true,
+  params: true
+}).extend({
+  output: zod.z.string().optional()
+});
+var FailTaskBodyInputSchema = zod.z.object({
   error: ErrorWithStackSchema
 });
-var NormalizedRequestSchema = import_zod11.z.object({
-  headers: import_zod11.z.record(import_zod11.z.string()),
-  method: import_zod11.z.string(),
-  query: import_zod11.z.record(import_zod11.z.string()),
-  url: import_zod11.z.string(),
-  body: import_zod11.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_zod11.z.object({
-  status: import_zod11.z.number(),
-  body: import_zod11.z.any(),
-  headers: import_zod11.z.record(import_zod11.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_zod11.z.object({
+var HttpSourceResponseSchema = zod.z.object({
   response: NormalizedResponseSchema,
-  events: import_zod11.z.array(RawEventSchema),
+  events: zod.z.array(RawEventSchema),
   metadata: HttpSourceResponseMetadataSchema.optional()
 });
-var RegisterTriggerBodySchemaV1 = import_zod11.z.object({
+var WebhookDeliveryResponseSchema = zod.z.object({
+  response: NormalizedResponseSchema,
+  verified: zod.z.boolean(),
+  error: zod.z.string().optional()
+});
+var RegisterTriggerBodySchemaV1 = zod.z.object({
   rule: EventRuleSchema,
   source: SourceMetadataV1Schema
 });
-var RegisterTriggerBodySchemaV2 = import_zod11.z.object({
+var RegisterTriggerBodySchemaV2 = zod.z.object({
   rule: EventRuleSchema,
   source: SourceMetadataV2Schema,
-  accountId: import_zod11.z.string().optional()
+  accountId: zod.z.string().optional()
 });
-var InitializeTriggerBodySchema = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  params: import_zod11.z.any(),
-  accountId: import_zod11.z.string().optional(),
-  metadata: import_zod11.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_zod11.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_zod11.z.string(),
+  id: zod.z.string(),
   /** Any additional metadata about the schedule. */
-  metadata: import_zod11.z.any(),
+  metadata: zod.z.any(),
   /** An optional Account ID to associate with runs triggered by this schedule */
-  accountId: import_zod11.z.string().optional()
+  accountId: zod.z.string().optional()
 });
 var RegisterIntervalScheduleBodySchema = RegisterCommonScheduleBodySchema.merge(IntervalMetadataSchema);
 var InitializeCronScheduleBodySchema = RegisterCommonScheduleBodySchema.merge(CronMetadataSchema);
-var RegisterScheduleBodySchema = import_zod11.z.discriminatedUnion("type", [
+var RegisterScheduleBodySchema = zod.z.discriminatedUnion("type", [
   RegisterIntervalScheduleBodySchema,
   InitializeCronScheduleBodySchema
 ]);
-var RegisterScheduleResponseBodySchema = import_zod11.z.object({
-  id: import_zod11.z.string(),
+var RegisterScheduleResponseBodySchema = zod.z.object({
+  id: zod.z.string(),
   schedule: ScheduleMetadataSchema,
-  metadata: import_zod11.z.any(),
-  active: import_zod11.z.boolean()
+  metadata: zod.z.any(),
+  active: zod.z.boolean()
 });
-var CreateExternalConnectionBodySchema = import_zod11.z.object({
-  accessToken: import_zod11.z.string(),
-  type: import_zod11.z.enum([
+var CreateExternalConnectionBodySchema = zod.z.object({
+  accessToken: zod.z.string(),
+  type: zod.z.enum([
     "oauth2"
   ]),
-  scopes: import_zod11.z.array(import_zod11.z.string()).optional(),
-  metadata: import_zod11.z.any()
+  scopes: zod.z.array(zod.z.string()).optional(),
+  metadata: zod.z.any()
 });
-var GetRunStatusesSchema = import_zod11.z.object({
-  run: import_zod11.z.object({
-    id: import_zod11.z.string(),
+var GetRunStatusesSchema = zod.z.object({
+  run: zod.z.object({
+    id: zod.z.string(),
     status: RunStatusSchema,
-    output: import_zod11.z.any().optional()
+    output: zod.z.any().optional()
   }),
-  statuses: import_zod11.z.array(JobRunStatusRecordSchema)
+  statuses: zod.z.array(JobRunStatusRecordSchema)
 });
-
-// src/schemas/notifications.ts
-var import_zod12 = require("zod");
+var InvokeJobResponseSchema = zod.z.object({
+  id: zod.z.string()
+});
+var InvokeJobRequestBodySchema = zod.z.object({
+  payload: zod.z.any(),
+  context: zod.z.any().optional(),
+  options: zod.z.object({
+    accountId: zod.z.string().optional(),
+    callbackUrl: zod.z.string().optional()
+  }).optional()
+});
+var InvokeOptionsSchema = zod.z.object({
+  accountId: zod.z.string().optional(),
+  idempotencyKey: zod.z.string().optional(),
+  context: zod.z.any().optional(),
+  callbackUrl: zod.z.string().optional()
+});
+var EphemeralEventDispatcherRequestBodySchema = zod.z.object({
+  url: zod.z.string(),
+  name: zod.z.string().or(zod.z.array(zod.z.string())),
+  source: zod.z.string().optional(),
+  filter: EventFilterSchema.optional(),
+  contextFilter: EventFilterSchema.optional(),
+  accountId: zod.z.string().optional(),
+  timeoutInSeconds: zod.z.number().int().positive().min(10).max(60 * 60 * 24 * 365).default(3600)
+});
+var EphemeralEventDispatcherResponseBodySchema = zod.z.object({
+  id: zod.z.string()
+});
+var KeyValueStoreResponseBodySchema = zod.z.discriminatedUnion("action", [
+  zod.z.object({
+    action: zod.z.literal("DELETE"),
+    key: zod.z.string(),
+    deleted: zod.z.boolean()
+  }),
+  zod.z.object({
+    action: zod.z.literal("GET"),
+    key: zod.z.string(),
+    value: zod.z.string().optional()
+  }),
+  zod.z.object({
+    action: zod.z.literal("HAS"),
+    key: zod.z.string(),
+    has: zod.z.boolean()
+  }),
+  zod.z.object({
+    action: zod.z.literal("SET"),
+    key: zod.z.string(),
+    value: zod.z.string().optional()
+  })
+]);
 var MISSING_CONNECTION_NOTIFICATION = "dev.trigger.notifications.missingConnection";
 var MISSING_CONNECTION_RESOLVED_NOTIFICATION = "dev.trigger.notifications.missingConnectionResolved";
-var CommonMissingConnectionNotificationPayloadSchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  client: import_zod12.z.object({
-    id: import_zod12.z.string(),
-    title: import_zod12.z.string(),
-    scopes: import_zod12.z.array(import_zod12.z.string()),
-    createdAt: import_zod12.z.coerce.date(),
-    updatedAt: import_zod12.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_zod12.z.string()
+  authorizationUrl: zod.z.string()
 });
 var MissingDeveloperConnectionNotificationPayloadSchema = CommonMissingConnectionNotificationPayloadSchema.extend({
-  type: import_zod12.z.literal("DEVELOPER")
+  type: zod.z.literal("DEVELOPER")
 });
 var MissingExternalConnectionNotificationPayloadSchema = CommonMissingConnectionNotificationPayloadSchema.extend({
-  type: import_zod12.z.literal("EXTERNAL"),
-  account: import_zod12.z.object({
-    id: import_zod12.z.string(),
-    metadata: import_zod12.z.any()
+  type: zod.z.literal("EXTERNAL"),
+  account: zod.z.object({
+    id: zod.z.string(),
+    metadata: zod.z.any()
   })
 });
-var MissingConnectionNotificationPayloadSchema = import_zod12.z.discriminatedUnion("type", [
+var MissingConnectionNotificationPayloadSchema = zod.z.discriminatedUnion("type", [
   MissingDeveloperConnectionNotificationPayloadSchema,
   MissingExternalConnectionNotificationPayloadSchema
 ]);
-var CommonMissingConnectionNotificationResolvedPayloadSchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  client: import_zod12.z.object({
-    id: import_zod12.z.string(),
-    title: import_zod12.z.string(),
-    scopes: import_zod12.z.array(import_zod12.z.string()),
-    createdAt: import_zod12.z.coerce.date(),
-    updatedAt: import_zod12.z.coerce.date(),
-    integrationIdentifier: import_zod12.z.string(),
-    integrationAuthMethod: import_zod12.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_zod12.z.coerce.date()
+  expiresAt: zod.z.coerce.date()
 });
 var MissingDeveloperConnectionResolvedNotificationPayloadSchema = CommonMissingConnectionNotificationResolvedPayloadSchema.extend({
-  type: import_zod12.z.literal("DEVELOPER")
+  type: zod.z.literal("DEVELOPER")
 });
 var MissingExternalConnectionResolvedNotificationPayloadSchema = CommonMissingConnectionNotificationResolvedPayloadSchema.extend({
-  type: import_zod12.z.literal("EXTERNAL"),
-  account: import_zod12.z.object({
-    id: import_zod12.z.string(),
-    metadata: import_zod12.z.any()
+  type: zod.z.literal("EXTERNAL"),
+  account: zod.z.object({
+    id: zod.z.string(),
+    metadata: zod.z.any()
   })
 });
-var MissingConnectionResolvedNotificationPayloadSchema = import_zod12.z.discriminatedUnion("type", [
+var MissingConnectionResolvedNotificationPayloadSchema = zod.z.discriminatedUnion("type", [
   MissingDeveloperConnectionResolvedNotificationPayloadSchema,
   MissingExternalConnectionResolvedNotificationPayloadSchema
 ]);
-
-// src/schemas/fetch.ts
-var import_zod13 = require("zod");
-var FetchRetryHeadersStrategySchema = import_zod13.z.object({
+var FetchRetryHeadersStrategySchema = zod.z.object({
   /** The `headers` strategy retries the request using info from the response headers. */
-  strategy: import_zod13.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_zod13.z.string(),
+  limitHeader: zod.z.string(),
   /** The header to use to determine the number of remaining retries. */
-  remainingHeader: import_zod13.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_zod13.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: zod.z.enum([
+    "unix_timestamp",
+    "unix_timestamp_in_ms",
+    "iso_8601",
+    "iso_8601_duration_openai_variant"
+  ]).default("unix_timestamp")
 });
 var FetchRetryBackoffStrategySchema = RetryOptionsSchema.extend({
   /** The `backoff` strategy retries the request with an exponential backoff. */
-  strategy: import_zod13.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_zod13.z.discriminatedUnion("strategy", [
+var FetchRetryStrategySchema = zod.z.discriminatedUnion("strategy", [
   FetchRetryHeadersStrategySchema,
   FetchRetryBackoffStrategySchema
 ]);
-var FetchRequestInitSchema = import_zod13.z.object({
+var FetchRequestInitSchema = zod.z.object({
   /** The HTTP method to use for the request. */
-  method: import_zod13.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_zod13.z.record(import_zod13.z.union([
-    import_zod13.z.string(),
+  headers: zod.z.record(zod.z.union([
+    zod.z.string(),
     RedactStringSchema
   ])).optional(),
   /** The body of the request. */
-  body: import_zod13.z.union([
-    import_zod13.z.string(),
-    import_zod13.z.instanceof(ArrayBuffer)
+  body: zod.z.union([
+    zod.z.string(),
+    zod.z.instanceof(ArrayBuffer)
   ]).optional()
 });
-var FetchRetryOptionsSchema = import_zod13.z.record(FetchRetryStrategySchema);
-var FetchOperationSchema = import_zod13.z.object({
-  url: import_zod13.z.string(),
+var FetchRetryOptionsSchema = zod.z.record(FetchRetryStrategySchema);
+var FetchTimeoutOptionsSchema = zod.z.object({
+  durationInMs: zod.z.number(),
+  retry: RetryOptionsSchema.optional()
+});
+var FetchOperationSchema = zod.z.object({
+  url: zod.z.string(),
   requestInit: FetchRequestInitSchema.optional(),
-  retry: import_zod13.z.record(FetchRetryStrategySchema).optional()
+  retry: zod.z.record(FetchRetryStrategySchema).optional(),
+  timeout: FetchTimeoutOptionsSchema.optional()
+});
+var FetchPollOperationSchema = zod.z.object({
+  url: zod.z.string(),
+  interval: zod.z.number().int().positive().min(10).max(600).default(10),
+  timeout: zod.z.number().int().positive().min(30).max(3600).default(600),
+  responseFilter: ResponseFilterSchema,
+  requestInit: FetchRequestInitSchema.optional(),
+  requestTimeout: FetchTimeoutOptionsSchema.optional()
 });
-
-// src/schemas/events.ts
-var import_zod14 = require("zod");
-var GetEventSchema = import_zod14.z.object({
+var GetEventSchema = zod.z.object({
   /** The event id */
-  id: import_zod14.z.string(),
+  id: zod.z.string(),
   /** The event name */
-  name: import_zod14.z.string(),
+  name: zod.z.string(),
   /** When the event was created */
-  createdAt: import_zod14.z.coerce.date(),
+  createdAt: zod.z.coerce.date(),
   /** When the event was last updated */
-  updatedAt: import_zod14.z.coerce.date(),
+  updatedAt: zod.z.coerce.date(),
   /** The runs that were triggered by the event */
-  runs: import_zod14.z.array(import_zod14.z.object({
+  runs: zod.z.array(zod.z.object({
     /** The Run id */
-    id: import_zod14.z.string(),
+    id: zod.z.string(),
     /** The Run status */
     status: RunStatusSchema,
     /** When the run started */
-    startedAt: import_zod14.z.coerce.date().optional().nullable(),
+    startedAt: zod.z.coerce.date().optional().nullable(),
     /** When the run completed */
-    completedAt: import_zod14.z.coerce.date().optional().nullable()
+    completedAt: zod.z.coerce.date().optional().nullable()
   }))
 });
+var CancelRunsForEventSchema = zod.z.object({
+  cancelledRunIds: zod.z.array(zod.z.string()),
+  failedToCancelRunIds: zod.z.array(zod.z.string())
+});
+var RequestWithRawBodySchema = zod.z.object({
+  url: zod.z.string(),
+  method: zod.z.string(),
+  headers: zod.z.record(zod.z.string()),
+  rawBody: zod.z.string()
+});
+var CancelRunsForJobSchema = zod.z.object({
+  cancelledRunIds: zod.z.array(zod.z.string()),
+  failedToCancelRunIds: zod.z.array(zod.z.string())
+});
 
 // src/utils.ts
 function deepMergeFilters(...filters) {
@@ -1553,6 +1473,10 @@ function deepMergeFilters(...filters) {
   return result;
 }
 __name(deepMergeFilters, "deepMergeFilters");
+function assertExhaustive(x) {
+  throw new Error("Unexpected object: " + x);
+}
+__name(assertExhaustive, "assertExhaustive");
 
 // src/retry.ts
 var DEFAULT_RETRY_OPTIONS = {
@@ -1577,6 +1501,73 @@ function calculateRetryAt(retryOptions, attempts) {
   return new Date(Date.now() + timeoutInMs);
 }
 __name(calculateRetryAt, "calculateRetryAt");
+function calculateResetAt(resets, format, now = /* @__PURE__ */ new Date()) {
+  if (!resets)
+    return;
+  switch (format) {
+    case "iso_8601_duration_openai_variant": {
+      return calculateISO8601DurationOpenAIVariantResetAt(resets, now);
+    }
+    case "iso_8601": {
+      return calculateISO8601ResetAt(resets, now);
+    }
+    case "unix_timestamp": {
+      return calculateUnixTimestampResetAt(resets, now);
+    }
+    case "unix_timestamp_in_ms": {
+      return calculateUnixTimestampInMsResetAt(resets, now);
+    }
+  }
+}
+__name(calculateResetAt, "calculateResetAt");
+function calculateUnixTimestampResetAt(resets, now = /* @__PURE__ */ new Date()) {
+  if (!resets)
+    return void 0;
+  const resetAt = parseInt(resets, 10);
+  if (isNaN(resetAt))
+    return void 0;
+  return new Date(resetAt * 1e3);
+}
+__name(calculateUnixTimestampResetAt, "calculateUnixTimestampResetAt");
+function calculateUnixTimestampInMsResetAt(resets, now = /* @__PURE__ */ new Date()) {
+  if (!resets)
+    return void 0;
+  const resetAt = parseInt(resets, 10);
+  if (isNaN(resetAt))
+    return void 0;
+  return new Date(resetAt);
+}
+__name(calculateUnixTimestampInMsResetAt, "calculateUnixTimestampInMsResetAt");
+function calculateISO8601ResetAt(resets, now = /* @__PURE__ */ new Date()) {
+  if (!resets)
+    return void 0;
+  const resetAt = new Date(resets);
+  if (isNaN(resetAt.getTime()))
+    return void 0;
+  return resetAt;
+}
+__name(calculateISO8601ResetAt, "calculateISO8601ResetAt");
+function calculateISO8601DurationOpenAIVariantResetAt(resets, now = /* @__PURE__ */ new Date()) {
+  if (!resets)
+    return void 0;
+  const pattern = /^(?:(\d+)d)?(?:(\d+)h)?(?:(\d+)m)?(?:(\d+(?:\.\d+)?)s)?(?:(\d+)ms)?$/;
+  const match = resets.match(pattern);
+  if (!match)
+    return void 0;
+  const days = parseInt(match[1], 10) || 0;
+  const hours = parseInt(match[2], 10) || 0;
+  const minutes = parseInt(match[3], 10) || 0;
+  const seconds = parseFloat(match[4]) || 0;
+  const milliseconds = parseInt(match[5], 10) || 0;
+  const resetAt = new Date(now);
+  resetAt.setDate(resetAt.getDate() + days);
+  resetAt.setHours(resetAt.getHours() + hours);
+  resetAt.setMinutes(resetAt.getMinutes() + minutes);
+  resetAt.setSeconds(resetAt.getSeconds() + Math.floor(seconds));
+  resetAt.setMilliseconds(resetAt.getMilliseconds() + (seconds - Math.floor(seconds)) * 1e3 + milliseconds);
+  return resetAt;
+}
+__name(calculateISO8601DurationOpenAIVariantResetAt, "calculateISO8601DurationOpenAIVariantResetAt");
 
 // src/replacements.ts
 var currentDate = {
@@ -1610,7 +1601,9 @@ function urlWithSearchParams(url, params) {
   }
   const urlObj = new URL(url);
   for (const [key, value] of Object.entries(params)) {
-    urlObj.searchParams.append(key, String(value));
+    if (value !== void 0) {
+      urlObj.searchParams.append(key, String(value));
+    }
   }
   return urlObj.toString();
 }
@@ -1618,6 +1611,13 @@ __name(urlWithSearchParams, "urlWithSearchParams");
 
 // src/eventFilterMatches.ts
 function eventFilterMatches(payload, filter) {
+  if (payload === void 0 || payload === null) {
+    if (Object.entries(filter).length === 0) {
+      return true;
+    } else {
+      return false;
+    }
+  }
   for (const [patternKey, patternValue] of Object.entries(filter)) {
     const payloadValue = payload[patternKey];
     if (Array.isArray(patternValue)) {
@@ -1665,7 +1665,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;
       }
@@ -1754,65 +1754,94 @@ function contentFilterMatches(actualValue, contentFilter) {
     }
     return actualValue !== null;
   }
+  if ("$not" in contentFilter) {
+    if (Array.isArray(actualValue)) {
+      return !actualValue.includes(contentFilter.$not);
+    } else if (typeof actualValue === "number" || typeof actualValue === "boolean" || typeof actualValue === "string") {
+      return actualValue !== contentFilter.$not;
+    }
+    return false;
+  }
   return true;
 }
 __name(contentFilterMatches, "contentFilterMatches");
 
-// src/bloom.ts
-var import_node_buffer = require("buffer");
-var _BloomFilter = class _BloomFilter {
-  constructor(size) {
-    this.size = size;
-    this.bitArray = new Uint8Array(Math.ceil(size / 8));
+// src/requestFilterMatches.ts
+async function requestFilterMatches(request, filter) {
+  const clonedRequest = request.clone();
+  if (!requestMethodMatches(clonedRequest.method, filter.method)) {
+    return false;
   }
-  add(item) {
-    const index = murmurHash3(item) % this.size;
-    this.bitArray[Math.floor(index / 8)] |= 1 << index % 8;
+  const headersObj = Object.fromEntries(clonedRequest.headers.entries());
+  if (filter.headers && !eventFilterMatches(headersObj, filter.headers)) {
+    return false;
   }
-  test(item) {
-    const index = murmurHash3(item) % this.size;
-    return (this.bitArray[Math.floor(index / 8)] & 1 << index % 8) !== 0;
+  const searchParams = new URL(clonedRequest.url).searchParams;
+  const searchParamsObject = {};
+  for (const [key, value] of searchParams.entries()) {
+    searchParamsObject[key] = value;
   }
-  // Serialize to a Base64 string
-  serialize() {
-    return import_node_buffer.Buffer.from(this.bitArray).toString("base64");
+  if (filter.query && !eventFilterMatches(searchParamsObject, filter.query)) {
+    return false;
   }
-  // Deserialize from a Base64 string
-  static deserialize(str, size) {
-    const filter = new _BloomFilter(size);
-    filter.bitArray = Uint8Array.from(import_node_buffer.Buffer.from(str, "base64"));
-    return filter;
+  try {
+    const json = await clonedRequest.json();
+    if (filter.body && !eventFilterMatches(json, filter.body)) {
+      return false;
+    }
+  } catch (e) {
+    if (filter.body) {
+      return false;
+    }
   }
-};
-__name(_BloomFilter, "BloomFilter");
-__publicField(_BloomFilter, "NOOP_TASK_SET_SIZE", 32768);
-var BloomFilter = _BloomFilter;
-function murmurHash3(str, seed = 0) {
-  let h1 = 3735928559 ^ seed, h2 = 1103547991 ^ seed;
-  for (let i = 0, ch; i < str.length; i++) {
-    ch = str.charCodeAt(i);
-    h1 = Math.imul(h1 ^ ch, 3432918353);
-    h1 = h1 << 15 | h1 >>> 17;
-    h1 = Math.imul(h1, 461845907);
-    h2 = Math.imul(h2 ^ ch, 2246822507);
-    h2 = h2 << 13 | h2 >>> 19;
-    h2 = Math.imul(h2, 3266489909);
+  return true;
+}
+__name(requestFilterMatches, "requestFilterMatches");
+async function responseFilterMatches(response, filter) {
+  if (filter.headers && !eventFilterMatches(response.headers, filter.headers)) {
+    return {
+      match: false
+    };
+  }
+  try {
+    const json = await response.json();
+    if (filter.body && !eventFilterMatches(json, filter.body)) {
+      return {
+        match: false,
+        body: json
+      };
+    } else {
+      return {
+        match: true,
+        body: json
+      };
+    }
+  } catch (e) {
+    if (filter.body) {
+      return {
+        match: false,
+        body: void 0
+      };
+    }
+  }
+  return {
+    match: true,
+    body: void 0
+  };
+}
+__name(responseFilterMatches, "responseFilterMatches");
+function requestMethodMatches(method, filter) {
+  if (!filter) {
+    return true;
   }
-  h1 ^= str.length;
-  h2 ^= str.length;
-  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507);
-  h1 = Math.imul(h1 ^ h1 >>> 13, 3266489909);
-  h1 ^= h1 >>> 16;
-  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507);
-  h2 = Math.imul(h2 ^ h2 >>> 13, 3266489909);
-  h2 ^= h2 >>> 16;
-  return 4294967296 * (2097151 & h2) + (h1 >>> 0);
+  return filter.includes(method);
 }
-__name(murmurHash3, "murmurHash3");
+__name(requestMethodMatches, "requestMethodMatches");
 
 // src/index.ts
 var API_VERSIONS = {
-  LAZY_LOADED_CACHED_TASKS: "2023-09-29"
+  LAZY_LOADED_CACHED_TASKS: "2023-09-29",
+  SERIALIZED_TASK_OUTPUT: "2023-11-01"
 };
 var PLATFORM_FEATURES = {
   yieldExecution: API_VERSIONS.LAZY_LOADED_CACHED_TASKS,
@@ -1829,4 +1858,186 @@ 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.CancelRunsForJobSchema = CancelRunsForJobSchema;
+exports.CommonMissingConnectionNotificationPayloadSchema = CommonMissingConnectionNotificationPayloadSchema;
+exports.CommonMissingConnectionNotificationResolvedPayloadSchema = CommonMissingConnectionNotificationResolvedPayloadSchema;
+exports.CompleteTaskBodyInputSchema = CompleteTaskBodyInputSchema;
+exports.CompleteTaskBodyV2InputSchema = CompleteTaskBodyV2InputSchema;
+exports.ConcurrencyLimitOptionsSchema = ConcurrencyLimitOptionsSchema;
+exports.ConnectionAuthSchema = ConnectionAuthSchema;
+exports.CreateExternalConnectionBodySchema = CreateExternalConnectionBodySchema;
+exports.CreateRunResponseBodySchema = CreateRunResponseBodySchema;
+exports.CronMetadataSchema = CronMetadataSchema;
+exports.CronOptionsSchema = CronOptionsSchema;
+exports.DELIVER_WEBHOOK_REQUEST = DELIVER_WEBHOOK_REQUEST;
+exports.DeliverEventResponseSchema = DeliverEventResponseSchema;
+exports.DeserializedJsonSchema = DeserializedJsonSchema;
+exports.DisplayPropertiesSchema = DisplayPropertiesSchema;
+exports.DisplayPropertySchema = DisplayPropertySchema;
+exports.DynamicTriggerEndpointMetadataSchema = DynamicTriggerEndpointMetadataSchema;
+exports.DynamicTriggerMetadataSchema = DynamicTriggerMetadataSchema;
+exports.EndpointHeadersSchema = EndpointHeadersSchema;
+exports.EndpointIndexErrorSchema = EndpointIndexErrorSchema;
+exports.EphemeralEventDispatcherRequestBodySchema = EphemeralEventDispatcherRequestBodySchema;
+exports.EphemeralEventDispatcherResponseBodySchema = EphemeralEventDispatcherResponseBodySchema;
+exports.ErrorWithStackSchema = ErrorWithStackSchema;
+exports.EventExampleSchema = EventExampleSchema;
+exports.EventFilterSchema = EventFilterSchema;
+exports.EventRuleSchema = EventRuleSchema;
+exports.EventSpecificationSchema = EventSpecificationSchema;
+exports.ExecuteJobHeadersSchema = ExecuteJobHeadersSchema;
+exports.ExecuteJobRunMetadataSchema = ExecuteJobRunMetadataSchema;
+exports.FailTaskBodyInputSchema = FailTaskBodyInputSchema;
+exports.FetchOperationSchema = FetchOperationSchema;
+exports.FetchPollOperationSchema = FetchPollOperationSchema;
+exports.FetchRequestInitSchema = FetchRequestInitSchema;
+exports.FetchRetryBackoffStrategySchema = FetchRetryBackoffStrategySchema;
+exports.FetchRetryHeadersStrategySchema = FetchRetryHeadersStrategySchema;
+exports.FetchRetryOptionsSchema = FetchRetryOptionsSchema;
+exports.FetchRetryStrategySchema = FetchRetryStrategySchema;
+exports.FetchTimeoutOptionsSchema = FetchTimeoutOptionsSchema;
+exports.GetEndpointIndexResponseSchema = GetEndpointIndexResponseSchema;
+exports.GetEventSchema = GetEventSchema;
+exports.GetRunSchema = GetRunSchema;
+exports.GetRunStatusesSchema = GetRunStatusesSchema;
+exports.GetRunsSchema = GetRunsSchema;
+exports.HTTPMethodUnionSchema = HTTPMethodUnionSchema;
+exports.HandleTriggerSourceSchema = HandleTriggerSourceSchema;
+exports.HttpEndpointRequestHeadersSchema = HttpEndpointRequestHeadersSchema;
+exports.HttpSourceRequestHeadersSchema = HttpSourceRequestHeadersSchema;
+exports.HttpSourceResponseSchema = HttpSourceResponseSchema;
+exports.IndexEndpointResponseSchema = IndexEndpointResponseSchema;
+exports.InitializeCronScheduleBodySchema = InitializeCronScheduleBodySchema;
+exports.InitializeTriggerBodySchema = InitializeTriggerBodySchema;
+exports.IntegrationConfigSchema = IntegrationConfigSchema;
+exports.IntegrationMetadataSchema = IntegrationMetadataSchema;
+exports.IntervalMetadataSchema = IntervalMetadataSchema;
+exports.IntervalOptionsSchema = IntervalOptionsSchema;
+exports.InvokeJobRequestBodySchema = InvokeJobRequestBodySchema;
+exports.InvokeJobResponseSchema = InvokeJobResponseSchema;
+exports.InvokeOptionsSchema = InvokeOptionsSchema;
+exports.InvokeTriggerMetadataSchema = InvokeTriggerMetadataSchema;
+exports.JobMetadataSchema = JobMetadataSchema;
+exports.JobRunStatusRecordSchema = JobRunStatusRecordSchema;
+exports.KeyValueStoreResponseBodySchema = KeyValueStoreResponseBodySchema;
+exports.LogMessageSchema = LogMessageSchema;
+exports.MISSING_CONNECTION_NOTIFICATION = MISSING_CONNECTION_NOTIFICATION;
+exports.MISSING_CONNECTION_RESOLVED_NOTIFICATION = MISSING_CONNECTION_RESOLVED_NOTIFICATION;
+exports.MissingConnectionNotificationPayloadSchema = MissingConnectionNotificationPayloadSchema;
+exports.MissingConnectionResolvedNotificationPayloadSchema = MissingConnectionResolvedNotificationPayloadSchema;
+exports.MissingDeveloperConnectionNotificationPayloadSchema = MissingDeveloperConnectionNotificationPayloadSchema;
+exports.MissingDeveloperConnectionResolvedNotificationPayloadSchema = MissingDeveloperConnectionResolvedNotificationPayloadSchema;
+exports.MissingExternalConnectionNotificationPayloadSchema = MissingExternalConnectionNotificationPayloadSchema;
+exports.MissingExternalConnectionResolvedNotificationPayloadSchema = MissingExternalConnectionResolvedNotificationPayloadSchema;
+exports.NormalizedRequestSchema = NormalizedRequestSchema;
+exports.NormalizedResponseSchema = NormalizedResponseSchema;
+exports.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