@trigger.dev/core 0.0.0-isomorphic-sdk-20230918151405 → 0.0.0-langsmith-ai-20250111212321

package/dist/index.js

@@ -1,1697 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet = (obj, member, value, setter) => {
-  __accessCheck(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
-};
-var __privateMethod = (obj, member, method) => {
-  __accessCheck(obj, member, "access private method");
-  return method;
-};
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  ApiEventLogSchema: () => ApiEventLogSchema,
-  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,
-  ErrorWithStackSchema: () => ErrorWithStackSchema,
-  EventExampleSchema: () => EventExampleSchema,
-  EventFilterSchema: () => EventFilterSchema,
-  EventRuleSchema: () => EventRuleSchema,
-  EventSpecificationSchema: () => EventSpecificationSchema,
-  FailTaskBodyInputSchema: () => FailTaskBodyInputSchema,
-  FetchOperationSchema: () => FetchOperationSchema,
-  FetchRequestInitSchema: () => FetchRequestInitSchema,
-  FetchRetryBackoffStrategySchema: () => FetchRetryBackoffStrategySchema,
-  FetchRetryHeadersStrategySchema: () => FetchRetryHeadersStrategySchema,
-  FetchRetryOptionsSchema: () => FetchRetryOptionsSchema,
-  FetchRetryStrategySchema: () => FetchRetryStrategySchema,
-  GetEventSchema: () => GetEventSchema,
-  GetRunSchema: () => GetRunSchema,
-  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,
-  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,
-  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,
-  RunJobBodySchema: () => RunJobBodySchema,
-  RunJobCanceledWithTaskSchema: () => RunJobCanceledWithTaskSchema,
-  RunJobErrorSchema: () => RunJobErrorSchema,
-  RunJobResponseSchema: () => RunJobResponseSchema,
-  RunJobResumeWithTaskSchema: () => RunJobResumeWithTaskSchema,
-  RunJobRetryWithTaskSchema: () => RunJobRetryWithTaskSchema,
-  RunJobSuccessSchema: () => RunJobSuccessSchema,
-  RunSourceContextSchema: () => RunSourceContextSchema,
-  RunStatusSchema: () => RunStatusSchema,
-  RunTaskBodyInputSchema: () => RunTaskBodyInputSchema,
-  RunTaskBodyOutputSchema: () => RunTaskBodyOutputSchema,
-  RunTaskOptionsSchema: () => RunTaskOptionsSchema,
-  RunTaskSchema: () => RunTaskSchema,
-  RuntimeEnvironmentTypeSchema: () => RuntimeEnvironmentTypeSchema,
-  SCHEDULED_EVENT: () => SCHEDULED_EVENT,
-  ScheduleMetadataSchema: () => ScheduleMetadataSchema,
-  ScheduledPayloadSchema: () => ScheduledPayloadSchema,
-  ScheduledTriggerMetadataSchema: () => ScheduledTriggerMetadataSchema,
-  SendEventBodySchema: () => SendEventBodySchema,
-  SendEventOptionsSchema: () => SendEventOptionsSchema,
-  SerializableJsonSchema: () => SerializableJsonSchema,
-  ServerTaskSchema: () => ServerTaskSchema,
-  SourceMetadataV2Schema: () => SourceMetadataV2Schema,
-  StaticTriggerMetadataSchema: () => StaticTriggerMetadataSchema,
-  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,
-  replacements: () => replacements,
-  urlWithSearchParams: () => urlWithSearchParams
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/logger.ts
-var import_node_buffer = require("buffer");
-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 = import_node_buffer.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");
-
-// src/schemas/api.ts
-var import_ulidx = require("ulidx");
-var import_zod9 = require("zod");
-
-// src/schemas/addMissingVersionField.ts
-function addMissingVersionField(val) {
-  if (val !== null && typeof val === "object" && !("version" in val)) {
-    return {
-      ...val,
-      version: "1"
-    };
-  }
-  return val;
-}
-__name(addMissingVersionField, "addMissingVersionField");
-
-// 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()
-});
-
-// src/schemas/eventFilter.ts
-var import_zod2 = require("zod");
-var EventMatcherSchema = import_zod2.z.union([
-  /** Match against a string */
-  import_zod2.z.array(import_zod2.z.string()),
-  /** Match against a number */
-  import_zod2.z.array(import_zod2.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()
-    }),
-    import_zod2.z.object({
-      $exists: import_zod2.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()
-      ])
-    }),
-    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())
-      ])
-    }),
-    import_zod2.z.object({
-      $gt: import_zod2.z.number()
-    }),
-    import_zod2.z.object({
-      $lt: import_zod2.z.number()
-    }),
-    import_zod2.z.object({
-      $gte: import_zod2.z.number()
-    }),
-    import_zod2.z.object({
-      $lte: import_zod2.z.number()
-    }),
-    import_zod2.z.object({
-      $between: import_zod2.z.tuple([
-        import_zod2.z.number(),
-        import_zod2.z.number()
-      ])
-    }),
-    import_zod2.z.object({
-      $includes: import_zod2.z.union([
-        import_zod2.z.string(),
-        import_zod2.z.number(),
-        import_zod2.z.boolean()
-      ])
-    }),
-    import_zod2.z.object({
-      $ignoreCaseEquals: import_zod2.z.string()
-    })
-  ]))
-]);
-var EventFilterSchema = import_zod2.z.lazy(() => import_zod2.z.record(import_zod2.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(),
-  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([
-    "oauth2"
-  ]),
-  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()
-});
-var IntegrationMetadataSchema = import_zod3.z.object({
-  id: import_zod3.z.string(),
-  name: import_zod3.z.string(),
-  instructions: import_zod3.z.string().optional()
-});
-var IntegrationConfigSchema = import_zod3.z.object({
-  id: import_zod3.z.string(),
-  metadata: IntegrationMetadataSchema,
-  authSource: import_zod3.z.enum([
-    "HOSTED",
-    "LOCAL"
-  ])
-});
-
-// 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 DeserializedJsonSchema = import_zod4.z.lazy(() => import_zod4.z.union([
-  LiteralSchema,
-  import_zod4.z.array(DeserializedJsonSchema),
-  import_zod4.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 SerializableJsonSchema = import_zod4.z.lazy(() => import_zod4.z.union([
-  SerializableSchema,
-  import_zod4.z.array(SerializableJsonSchema),
-  import_zod4.z.record(SerializableJsonSchema)
-]));
-
-// src/schemas/properties.ts
-var import_zod5 = require("zod");
-var DisplayPropertySchema = import_zod5.z.object({
-  /** The label for the property */
-  label: import_zod5.z.string(),
-  /** The value of the property */
-  text: import_zod5.z.string(),
-  /** The URL to link to when the property is clicked */
-  url: import_zod5.z.string().optional()
-});
-var DisplayPropertiesSchema = import_zod5.z.array(DisplayPropertySchema);
-var StyleSchema = import_zod5.z.object({
-  /** The style, `normal` or `minimal` */
-  style: import_zod5.z.enum([
-    "normal",
-    "minimal"
-  ]),
-  /** A variant of the style. */
-  variant: import_zod5.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 IntervalOptionsSchema = import_zod6.z.object({
-  /** The number of seconds for the interval. Min = 60, Max = 86400 (1 day) */
-  seconds: import_zod6.z.number().int().positive().min(60).max(86400)
-});
-var CronOptionsSchema = import_zod6.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()
-});
-var CronMetadataSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("cron"),
-  options: CronOptionsSchema,
-  metadata: import_zod6.z.any()
-});
-var IntervalMetadataSchema = import_zod6.z.object({
-  /** An interval reoccurs at the specified number of seconds  */
-  type: import_zod6.z.literal("interval"),
-  /** An object containing options about the interval. */
-  options: IntervalOptionsSchema,
-  /** Any additional metadata about the schedule. */
-  metadata: import_zod6.z.any()
-});
-var ScheduleMetadataSchema = import_zod6.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()
-  }))
-});
-
-// src/schemas/tasks.ts
-var import_zod7 = require("zod");
-var TaskStatusSchema = import_zod7.z.enum([
-  "PENDING",
-  "WAITING",
-  "RUNNING",
-  "COMPLETED",
-  "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(),
-  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(),
-  params: DeserializedJsonSchema.optional().nullable(),
-  output: DeserializedJsonSchema.optional().nullable(),
-  error: import_zod7.z.string().optional().nullable(),
-  parentId: import_zod7.z.string().optional().nullable(),
-  style: StyleSchema.optional().nullable(),
-  operation: import_zod7.z.string().optional().nullable()
-});
-var ServerTaskSchema = TaskSchema.extend({
-  idempotencyKey: import_zod7.z.string(),
-  attempts: import_zod7.z.number()
-});
-var CachedTaskSchema = import_zod7.z.object({
-  id: import_zod7.z.string(),
-  idempotencyKey: import_zod7.z.string(),
-  status: TaskStatusSchema,
-  noop: import_zod7.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(),
-  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: import_zod8.z.array(DisplayPropertySchema).optional(),
-  rule: EventRuleSchema
-});
-var ScheduledTriggerMetadataSchema = import_zod8.z.object({
-  type: import_zod8.z.literal("scheduled"),
-  schedule: ScheduleMetadataSchema
-});
-var TriggerMetadataSchema = import_zod8.z.discriminatedUnion("type", [
-  DynamicTriggerMetadataSchema,
-  StaticTriggerMetadataSchema,
-  ScheduledTriggerMetadataSchema
-]);
-
-// src/schemas/api.ts
-var UpdateTriggerSourceBodyV1Schema = import_zod9.z.object({
-  registeredEvents: import_zod9.z.array(import_zod9.z.string()),
-  secret: import_zod9.z.string().optional(),
-  data: SerializableJsonSchema.optional()
-});
-var UpdateTriggerSourceBodyV2Schema = import_zod9.z.object({
-  secret: import_zod9.z.string().optional(),
-  data: SerializableJsonSchema.optional(),
-  options: import_zod9.z.object({
-    event: import_zod9.z.array(import_zod9.z.string())
-  }).and(import_zod9.z.record(import_zod9.z.string(), import_zod9.z.array(import_zod9.z.string())).optional())
-});
-var RegisterHTTPTriggerSourceBodySchema = import_zod9.z.object({
-  type: import_zod9.z.literal("HTTP"),
-  url: import_zod9.z.string().url()
-});
-var RegisterSMTPTriggerSourceBodySchema = import_zod9.z.object({
-  type: import_zod9.z.literal("SMTP")
-});
-var RegisterSQSTriggerSourceBodySchema = import_zod9.z.object({
-  type: import_zod9.z.literal("SQS")
-});
-var RegisterSourceChannelBodySchema = import_zod9.z.discriminatedUnion("type", [
-  RegisterHTTPTriggerSourceBodySchema,
-  RegisterSMTPTriggerSourceBodySchema,
-  RegisterSQSTriggerSourceBodySchema
-]);
-var REGISTER_SOURCE_EVENT_V1 = "dev.trigger.source.register";
-var REGISTER_SOURCE_EVENT_V2 = "dev.trigger.source.register.v2";
-var RegisterTriggerSourceSchema = import_zod9.z.object({
-  key: import_zod9.z.string(),
-  params: import_zod9.z.any(),
-  active: import_zod9.z.boolean(),
-  secret: import_zod9.z.string(),
-  data: DeserializedJsonSchema.optional(),
-  channel: RegisterSourceChannelBodySchema,
-  clientId: import_zod9.z.string().optional()
-});
-var SourceEventOptionSchema = import_zod9.z.object({
-  name: import_zod9.z.string(),
-  value: import_zod9.z.string()
-});
-var RegisterSourceEventSchemaV1 = import_zod9.z.object({
-  /** The id of the source */
-  id: import_zod9.z.string(),
-  source: RegisterTriggerSourceSchema,
-  events: import_zod9.z.array(import_zod9.z.string()),
-  missingEvents: import_zod9.z.array(import_zod9.z.string()),
-  orphanedEvents: import_zod9.z.array(import_zod9.z.string()),
-  dynamicTriggerId: import_zod9.z.string().optional()
-});
-var RegisteredOptionsDiffSchema = import_zod9.z.object({
-  desired: import_zod9.z.array(import_zod9.z.string()),
-  missing: import_zod9.z.array(import_zod9.z.string()),
-  orphaned: import_zod9.z.array(import_zod9.z.string())
-});
-var RegisterSourceEventOptionsSchema = import_zod9.z.object({
-  event: RegisteredOptionsDiffSchema
-}).and(import_zod9.z.record(import_zod9.z.string(), RegisteredOptionsDiffSchema));
-var RegisterSourceEventSchemaV2 = import_zod9.z.object({
-  /** The id of the source */
-  id: import_zod9.z.string(),
-  source: RegisterTriggerSourceSchema,
-  options: RegisterSourceEventOptionsSchema,
-  dynamicTriggerId: import_zod9.z.string().optional()
-});
-var TriggerSourceSchema = import_zod9.z.object({
-  id: import_zod9.z.string(),
-  key: import_zod9.z.string()
-});
-var HttpSourceResponseMetadataSchema = DeserializedJsonSchema;
-var HandleTriggerSourceSchema = import_zod9.z.object({
-  key: import_zod9.z.string(),
-  secret: import_zod9.z.string(),
-  data: import_zod9.z.any(),
-  params: import_zod9.z.any(),
-  auth: ConnectionAuthSchema.optional(),
-  metadata: HttpSourceResponseMetadataSchema.optional()
-});
-var HttpSourceRequestSchema = import_zod9.z.object({
-  url: import_zod9.z.string().url(),
-  method: import_zod9.z.string(),
-  headers: import_zod9.z.record(import_zod9.z.string()),
-  rawBody: import_zod9.z.instanceof(Uint8Array).optional().nullable()
-});
-var HttpSourceRequestHeadersSchema = import_zod9.z.object({
-  "x-ts-key": import_zod9.z.string(),
-  "x-ts-dynamic-id": import_zod9.z.string().optional(),
-  "x-ts-secret": import_zod9.z.string(),
-  "x-ts-data": import_zod9.z.string().transform((s) => JSON.parse(s)),
-  "x-ts-params": import_zod9.z.string().transform((s) => JSON.parse(s)),
-  "x-ts-http-url": import_zod9.z.string(),
-  "x-ts-http-method": import_zod9.z.string(),
-  "x-ts-http-headers": import_zod9.z.string().transform((s) => import_zod9.z.record(import_zod9.z.string()).parse(JSON.parse(s))),
-  "x-ts-auth": import_zod9.z.string().optional().transform((s) => {
-    if (s === void 0)
-      return;
-    const json = JSON.parse(s);
-    return ConnectionAuthSchema.parse(json);
-  }),
-  "x-ts-metadata": import_zod9.z.string().optional().transform((s) => {
-    if (s === void 0)
-      return;
-    const json = JSON.parse(s);
-    return DeserializedJsonSchema.parse(json);
-  })
-});
-var PongSuccessResponseSchema = import_zod9.z.object({
-  ok: import_zod9.z.literal(true)
-});
-var PongErrorResponseSchema = import_zod9.z.object({
-  ok: import_zod9.z.literal(false),
-  error: import_zod9.z.string()
-});
-var PongResponseSchema = import_zod9.z.discriminatedUnion("ok", [
-  PongSuccessResponseSchema,
-  PongErrorResponseSchema
-]);
-var ValidateSuccessResponseSchema = import_zod9.z.object({
-  ok: import_zod9.z.literal(true),
-  endpointId: import_zod9.z.string()
-});
-var ValidateErrorResponseSchema = import_zod9.z.object({
-  ok: import_zod9.z.literal(false),
-  error: import_zod9.z.string()
-});
-var ValidateResponseSchema = import_zod9.z.discriminatedUnion("ok", [
-  ValidateSuccessResponseSchema,
-  ValidateErrorResponseSchema
-]);
-var QueueOptionsSchema = import_zod9.z.object({
-  name: import_zod9.z.string(),
-  maxConcurrent: import_zod9.z.number().optional()
-});
-var JobMetadataSchema = import_zod9.z.object({
-  id: import_zod9.z.string(),
-  name: import_zod9.z.string(),
-  version: import_zod9.z.string(),
-  event: EventSpecificationSchema,
-  trigger: TriggerMetadataSchema,
-  integrations: import_zod9.z.record(IntegrationConfigSchema),
-  internal: import_zod9.z.boolean().default(false),
-  enabled: import_zod9.z.boolean(),
-  startPosition: import_zod9.z.enum([
-    "initial",
-    "latest"
-  ]),
-  preprocessRuns: import_zod9.z.boolean()
-});
-var SourceMetadataV1Schema = import_zod9.z.object({
-  version: import_zod9.z.literal("1"),
-  channel: import_zod9.z.enum([
-    "HTTP",
-    "SQS",
-    "SMTP"
-  ]),
-  integration: IntegrationConfigSchema,
-  key: import_zod9.z.string(),
-  params: import_zod9.z.any(),
-  events: import_zod9.z.array(import_zod9.z.string()),
-  registerSourceJob: import_zod9.z.object({
-    id: import_zod9.z.string(),
-    version: import_zod9.z.string()
-  }).optional()
-});
-var SourceMetadataV2Schema = import_zod9.z.object({
-  version: import_zod9.z.literal("2"),
-  channel: import_zod9.z.enum([
-    "HTTP",
-    "SQS",
-    "SMTP"
-  ]),
-  integration: IntegrationConfigSchema,
-  key: import_zod9.z.string(),
-  params: import_zod9.z.any(),
-  options: import_zod9.z.record(import_zod9.z.array(import_zod9.z.string())),
-  registerSourceJob: import_zod9.z.object({
-    id: import_zod9.z.string(),
-    version: import_zod9.z.string()
-  }).optional()
-});
-var SourceMetadataSchema = import_zod9.z.preprocess(addMissingVersionField, import_zod9.z.discriminatedUnion("version", [
-  SourceMetadataV1Schema,
-  SourceMetadataV2Schema
-]));
-var DynamicTriggerEndpointMetadataSchema = import_zod9.z.object({
-  id: import_zod9.z.string(),
-  jobs: import_zod9.z.array(JobMetadataSchema.pick({
-    id: true,
-    version: true
-  })),
-  registerSourceJob: import_zod9.z.object({
-    id: import_zod9.z.string(),
-    version: import_zod9.z.string()
-  }).optional()
-});
-var IndexEndpointResponseSchema = import_zod9.z.object({
-  jobs: import_zod9.z.array(JobMetadataSchema),
-  sources: import_zod9.z.array(SourceMetadataSchema),
-  dynamicTriggers: import_zod9.z.array(DynamicTriggerEndpointMetadataSchema),
-  dynamicSchedules: import_zod9.z.array(RegisterDynamicSchedulePayloadSchema)
-});
-var RawEventSchema = import_zod9.z.object({
-  /** The `name` property must exactly match any subscriptions you want to
-    trigger. */
-  name: import_zod9.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_zod9.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_zod9.z.any().optional(),
-  /** The `id` property uniquely identify this particular event. If unset it
-    will be set automatically using `ulid`. */
-  id: import_zod9.z.string().default(() => (0, import_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_zod9.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_zod9.z.string().optional()
-});
-var ApiEventLogSchema = import_zod9.z.object({
-  /** The `id` of the event that was sent.
-  */
-  id: import_zod9.z.string(),
-  /** The `name` of the event that was sent. */
-  name: import_zod9.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_zod9.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_zod9.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_zod9.z.coerce.date().optional().nullable(),
-  /** The timestamp when the event was cancelled. Is `undefined` if the event
-  * wasn't cancelled. */
-  cancelledAt: import_zod9.z.coerce.date().optional().nullable()
-});
-var SendEventOptionsSchema = import_zod9.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_zod9.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_zod9.z.number().int().optional(),
-  /** This optional param will be used by Trigger.dev Connect, which
-    is coming soon. */
-  accountId: import_zod9.z.string().optional()
-});
-var SendEventBodySchema = import_zod9.z.object({
-  event: RawEventSchema,
-  options: SendEventOptionsSchema.optional()
-});
-var DeliverEventResponseSchema = import_zod9.z.object({
-  deliveredAt: import_zod9.z.string().datetime()
-});
-var RuntimeEnvironmentTypeSchema = import_zod9.z.enum([
-  "PRODUCTION",
-  "STAGING",
-  "DEVELOPMENT",
-  "PREVIEW"
-]);
-var RunSourceContextSchema = import_zod9.z.object({
-  id: import_zod9.z.string(),
-  metadata: import_zod9.z.any()
-});
-var RunJobBodySchema = import_zod9.z.object({
-  event: ApiEventLogSchema,
-  job: import_zod9.z.object({
-    id: import_zod9.z.string(),
-    version: import_zod9.z.string()
-  }),
-  run: import_zod9.z.object({
-    id: import_zod9.z.string(),
-    isTest: import_zod9.z.boolean(),
-    isRetry: import_zod9.z.boolean().default(false),
-    startedAt: import_zod9.z.coerce.date()
-  }),
-  environment: import_zod9.z.object({
-    id: import_zod9.z.string(),
-    slug: import_zod9.z.string(),
-    type: RuntimeEnvironmentTypeSchema
-  }),
-  organization: import_zod9.z.object({
-    id: import_zod9.z.string(),
-    title: import_zod9.z.string(),
-    slug: import_zod9.z.string()
-  }),
-  account: import_zod9.z.object({
-    id: import_zod9.z.string(),
-    metadata: import_zod9.z.any()
-  }).optional(),
-  source: RunSourceContextSchema.optional(),
-  tasks: import_zod9.z.array(CachedTaskSchema).optional(),
-  connections: import_zod9.z.record(ConnectionAuthSchema).optional()
-});
-var RunJobErrorSchema = import_zod9.z.object({
-  status: import_zod9.z.literal("ERROR"),
-  error: ErrorWithStackSchema,
-  task: TaskSchema.optional()
-});
-var RunJobResumeWithTaskSchema = import_zod9.z.object({
-  status: import_zod9.z.literal("RESUME_WITH_TASK"),
-  task: TaskSchema
-});
-var RunJobRetryWithTaskSchema = import_zod9.z.object({
-  status: import_zod9.z.literal("RETRY_WITH_TASK"),
-  task: TaskSchema,
-  error: ErrorWithStackSchema,
-  retryAt: import_zod9.z.coerce.date()
-});
-var RunJobCanceledWithTaskSchema = import_zod9.z.object({
-  status: import_zod9.z.literal("CANCELED"),
-  task: TaskSchema
-});
-var RunJobSuccessSchema = import_zod9.z.object({
-  status: import_zod9.z.literal("SUCCESS"),
-  output: DeserializedJsonSchema.optional()
-});
-var RunJobResponseSchema = import_zod9.z.discriminatedUnion("status", [
-  RunJobErrorSchema,
-  RunJobResumeWithTaskSchema,
-  RunJobRetryWithTaskSchema,
-  RunJobCanceledWithTaskSchema,
-  RunJobSuccessSchema
-]);
-var PreprocessRunBodySchema = import_zod9.z.object({
-  event: ApiEventLogSchema,
-  job: import_zod9.z.object({
-    id: import_zod9.z.string(),
-    version: import_zod9.z.string()
-  }),
-  run: import_zod9.z.object({
-    id: import_zod9.z.string(),
-    isTest: import_zod9.z.boolean()
-  }),
-  environment: import_zod9.z.object({
-    id: import_zod9.z.string(),
-    slug: import_zod9.z.string(),
-    type: RuntimeEnvironmentTypeSchema
-  }),
-  organization: import_zod9.z.object({
-    id: import_zod9.z.string(),
-    title: import_zod9.z.string(),
-    slug: import_zod9.z.string()
-  }),
-  account: import_zod9.z.object({
-    id: import_zod9.z.string(),
-    metadata: import_zod9.z.any()
-  }).optional()
-});
-var PreprocessRunResponseSchema = import_zod9.z.object({
-  abort: import_zod9.z.boolean(),
-  properties: import_zod9.z.array(DisplayPropertySchema).optional()
-});
-var CreateRunResponseOkSchema = import_zod9.z.object({
-  ok: import_zod9.z.literal(true),
-  data: import_zod9.z.object({
-    id: import_zod9.z.string()
-  })
-});
-var CreateRunResponseErrorSchema = import_zod9.z.object({
-  ok: import_zod9.z.literal(false),
-  error: import_zod9.z.string()
-});
-var CreateRunResponseBodySchema = import_zod9.z.discriminatedUnion("ok", [
-  CreateRunResponseOkSchema,
-  CreateRunResponseErrorSchema
-]);
-var RedactStringSchema = import_zod9.z.object({
-  __redactedString: import_zod9.z.literal(true),
-  strings: import_zod9.z.array(import_zod9.z.string()),
-  interpolations: import_zod9.z.array(import_zod9.z.string())
-});
-var LogMessageSchema = import_zod9.z.object({
-  level: import_zod9.z.enum([
-    "DEBUG",
-    "INFO",
-    "WARN",
-    "ERROR"
-  ]),
-  message: import_zod9.z.string(),
-  data: SerializableJsonSchema.optional()
-});
-var RedactSchema = import_zod9.z.object({
-  paths: import_zod9.z.array(import_zod9.z.string())
-});
-var RetryOptionsSchema = import_zod9.z.object({
-  /** The maximum number of times to retry the request. */
-  limit: import_zod9.z.number().optional(),
-  /** The exponential factor to use when calculating the next retry time. */
-  factor: import_zod9.z.number().optional(),
-  /** The minimum amount of time to wait before retrying the request. */
-  minTimeoutInMs: import_zod9.z.number().optional(),
-  /** The maximum amount of time to wait before retrying the request. */
-  maxTimeoutInMs: import_zod9.z.number().optional(),
-  /** Whether to randomize the retry time. */
-  randomize: import_zod9.z.boolean().optional()
-});
-var RunTaskOptionsSchema = import_zod9.z.object({
-  /** The name of the Task is required. This is displayed on the Task in the logs. */
-  name: import_zod9.z.string().optional(),
-  /** The Task will wait and only start at the specified Date  */
-  delayUntil: import_zod9.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_zod9.z.string().optional(),
-  /** The key for the Task that you want to appear in the logs */
-  displayKey: import_zod9.z.string().optional(),
-  /** A description of the Task */
-  description: import_zod9.z.string().optional(),
-  /** Properties that are displayed in the logs */
-  properties: import_zod9.z.array(DisplayPropertySchema).optional(),
-  /** The input params to the Task, will be displayed in the logs  */
-  params: import_zod9.z.any(),
-  /** The style of the log entry. */
-  style: StyleSchema.optional(),
-  /** Allows you to link the Integration connection in the logs. This is handled automatically in integrations.  */
-  connectionKey: import_zod9.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_zod9.z.enum([
-    "fetch"
-  ]).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_zod9.z.boolean().default(false),
-  redact: RedactSchema.optional(),
-  trigger: TriggerMetadataSchema.optional()
-});
-var RunTaskBodyInputSchema = RunTaskOptionsSchema.extend({
-  idempotencyKey: import_zod9.z.string(),
-  parentId: import_zod9.z.string().optional()
-});
-var RunTaskBodyOutputSchema = RunTaskBodyInputSchema.extend({
-  params: DeserializedJsonSchema.optional().nullable()
-});
-var CompleteTaskBodyInputSchema = RunTaskBodyInputSchema.pick({
-  properties: true,
-  description: true,
-  params: true
-}).extend({
-  output: SerializableJsonSchema.optional().transform((v) => v ? DeserializedJsonSchema.parse(JSON.parse(JSON.stringify(v))) : {})
-});
-var FailTaskBodyInputSchema = import_zod9.z.object({
-  error: ErrorWithStackSchema
-});
-var NormalizedRequestSchema = import_zod9.z.object({
-  headers: import_zod9.z.record(import_zod9.z.string()),
-  method: import_zod9.z.string(),
-  query: import_zod9.z.record(import_zod9.z.string()),
-  url: import_zod9.z.string(),
-  body: import_zod9.z.any()
-});
-var NormalizedResponseSchema = import_zod9.z.object({
-  status: import_zod9.z.number(),
-  body: import_zod9.z.any(),
-  headers: import_zod9.z.record(import_zod9.z.string()).optional()
-});
-var HttpSourceResponseSchema = import_zod9.z.object({
-  response: NormalizedResponseSchema,
-  events: import_zod9.z.array(RawEventSchema),
-  metadata: HttpSourceResponseMetadataSchema.optional()
-});
-var RegisterTriggerBodySchemaV1 = import_zod9.z.object({
-  rule: EventRuleSchema,
-  source: SourceMetadataV1Schema
-});
-var RegisterTriggerBodySchemaV2 = import_zod9.z.object({
-  rule: EventRuleSchema,
-  source: SourceMetadataV2Schema
-});
-var InitializeTriggerBodySchema = import_zod9.z.object({
-  id: import_zod9.z.string(),
-  params: import_zod9.z.any(),
-  accountId: import_zod9.z.string().optional(),
-  metadata: import_zod9.z.any().optional()
-});
-var RegisterCommonScheduleBodySchema = import_zod9.z.object({
-  /** A unique id for the schedule. This is used to identify and unregister the schedule later. */
-  id: import_zod9.z.string(),
-  /** Any additional metadata about the schedule. */
-  metadata: import_zod9.z.any(),
-  /** This will be used by the Trigger.dev Connect feature, which is coming soon. */
-  accountId: import_zod9.z.string().optional()
-});
-var RegisterIntervalScheduleBodySchema = RegisterCommonScheduleBodySchema.merge(IntervalMetadataSchema);
-var InitializeCronScheduleBodySchema = RegisterCommonScheduleBodySchema.merge(CronMetadataSchema);
-var RegisterScheduleBodySchema = import_zod9.z.discriminatedUnion("type", [
-  RegisterIntervalScheduleBodySchema,
-  InitializeCronScheduleBodySchema
-]);
-var RegisterScheduleResponseBodySchema = import_zod9.z.object({
-  id: import_zod9.z.string(),
-  schedule: ScheduleMetadataSchema,
-  metadata: import_zod9.z.any(),
-  active: import_zod9.z.boolean()
-});
-var CreateExternalConnectionBodySchema = import_zod9.z.object({
-  accessToken: import_zod9.z.string(),
-  type: import_zod9.z.enum([
-    "oauth2"
-  ]),
-  scopes: import_zod9.z.array(import_zod9.z.string()).optional(),
-  metadata: import_zod9.z.any()
-});
-
-// src/schemas/notifications.ts
-var import_zod10 = require("zod");
-var MISSING_CONNECTION_NOTIFICATION = "dev.trigger.notifications.missingConnection";
-var MISSING_CONNECTION_RESOLVED_NOTIFICATION = "dev.trigger.notifications.missingConnectionResolved";
-var CommonMissingConnectionNotificationPayloadSchema = import_zod10.z.object({
-  id: import_zod10.z.string(),
-  client: import_zod10.z.object({
-    id: import_zod10.z.string(),
-    title: import_zod10.z.string(),
-    scopes: import_zod10.z.array(import_zod10.z.string()),
-    createdAt: import_zod10.z.coerce.date(),
-    updatedAt: import_zod10.z.coerce.date()
-  }),
-  authorizationUrl: import_zod10.z.string()
-});
-var MissingDeveloperConnectionNotificationPayloadSchema = CommonMissingConnectionNotificationPayloadSchema.extend({
-  type: import_zod10.z.literal("DEVELOPER")
-});
-var MissingExternalConnectionNotificationPayloadSchema = CommonMissingConnectionNotificationPayloadSchema.extend({
-  type: import_zod10.z.literal("EXTERNAL"),
-  account: import_zod10.z.object({
-    id: import_zod10.z.string(),
-    metadata: import_zod10.z.any()
-  })
-});
-var MissingConnectionNotificationPayloadSchema = import_zod10.z.discriminatedUnion("type", [
-  MissingDeveloperConnectionNotificationPayloadSchema,
-  MissingExternalConnectionNotificationPayloadSchema
-]);
-var CommonMissingConnectionNotificationResolvedPayloadSchema = import_zod10.z.object({
-  id: import_zod10.z.string(),
-  client: import_zod10.z.object({
-    id: import_zod10.z.string(),
-    title: import_zod10.z.string(),
-    scopes: import_zod10.z.array(import_zod10.z.string()),
-    createdAt: import_zod10.z.coerce.date(),
-    updatedAt: import_zod10.z.coerce.date(),
-    integrationIdentifier: import_zod10.z.string(),
-    integrationAuthMethod: import_zod10.z.string()
-  }),
-  expiresAt: import_zod10.z.coerce.date()
-});
-var MissingDeveloperConnectionResolvedNotificationPayloadSchema = CommonMissingConnectionNotificationResolvedPayloadSchema.extend({
-  type: import_zod10.z.literal("DEVELOPER")
-});
-var MissingExternalConnectionResolvedNotificationPayloadSchema = CommonMissingConnectionNotificationResolvedPayloadSchema.extend({
-  type: import_zod10.z.literal("EXTERNAL"),
-  account: import_zod10.z.object({
-    id: import_zod10.z.string(),
-    metadata: import_zod10.z.any()
-  })
-});
-var MissingConnectionResolvedNotificationPayloadSchema = import_zod10.z.discriminatedUnion("type", [
-  MissingDeveloperConnectionResolvedNotificationPayloadSchema,
-  MissingExternalConnectionResolvedNotificationPayloadSchema
-]);
-
-// src/schemas/fetch.ts
-var import_zod11 = require("zod");
-var FetchRetryHeadersStrategySchema = import_zod11.z.object({
-  /** The `headers` strategy retries the request using info from the response headers. */
-  strategy: import_zod11.z.literal("headers"),
-  /** The header to use to determine the maximum number of times to retry the request. */
-  limitHeader: import_zod11.z.string(),
-  /** The header to use to determine the number of remaining retries. */
-  remainingHeader: import_zod11.z.string(),
-  /** The header to use to determine the time when the number of remaining retries will be reset. */
-  resetHeader: import_zod11.z.string()
-});
-var FetchRetryBackoffStrategySchema = RetryOptionsSchema.extend({
-  /** The `backoff` strategy retries the request with an exponential backoff. */
-  strategy: import_zod11.z.literal("backoff")
-});
-var FetchRetryStrategySchema = import_zod11.z.discriminatedUnion("strategy", [
-  FetchRetryHeadersStrategySchema,
-  FetchRetryBackoffStrategySchema
-]);
-var FetchRequestInitSchema = import_zod11.z.object({
-  /** The HTTP method to use for the request. */
-  method: import_zod11.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_zod11.z.record(import_zod11.z.union([
-    import_zod11.z.string(),
-    RedactStringSchema
-  ])).optional(),
-  /** The body of the request. */
-  body: import_zod11.z.union([
-    import_zod11.z.string(),
-    import_zod11.z.instanceof(ArrayBuffer)
-  ]).optional()
-});
-var FetchRetryOptionsSchema = import_zod11.z.record(FetchRetryStrategySchema);
-var FetchOperationSchema = import_zod11.z.object({
-  url: import_zod11.z.string(),
-  requestInit: FetchRequestInitSchema.optional(),
-  retry: import_zod11.z.record(FetchRetryStrategySchema).optional()
-});
-
-// src/schemas/events.ts
-var import_zod13 = require("zod");
-
-// src/schemas/runs.ts
-var import_zod12 = require("zod");
-var RunStatusSchema = import_zod12.z.union([
-  import_zod12.z.literal("PENDING"),
-  import_zod12.z.literal("QUEUED"),
-  import_zod12.z.literal("WAITING_ON_CONNECTIONS"),
-  import_zod12.z.literal("PREPROCESSING"),
-  import_zod12.z.literal("STARTED"),
-  import_zod12.z.literal("SUCCESS"),
-  import_zod12.z.literal("FAILURE"),
-  import_zod12.z.literal("TIMED_OUT"),
-  import_zod12.z.literal("ABORTED"),
-  import_zod12.z.literal("CANCELED")
-]);
-var RunTaskSchema = import_zod12.z.object({
-  /** The Task id */
-  id: import_zod12.z.string(),
-  /** The key that you defined when creating the Task, the first param in any task. */
-  displayKey: import_zod12.z.string().nullable(),
-  /** The Task status */
-  status: TaskStatusSchema,
-  /** The name of the Task */
-  name: import_zod12.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_zod12.z.string().nullable(),
-  /** When the task started */
-  startedAt: import_zod12.z.coerce.date().nullable(),
-  /** When the task completed */
-  completedAt: import_zod12.z.coerce.date().nullable()
-});
-var RunTaskWithSubtasksSchema = RunTaskSchema.extend({
-  subtasks: import_zod12.z.lazy(() => RunTaskWithSubtasksSchema.array()).optional()
-});
-var GetRunOptionsSchema = import_zod12.z.object({
-  /** Return subtasks, which appear in a `subtasks` array on a task. @default false */
-  subtasks: import_zod12.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_zod12.z.string().optional(),
-  /** How many tasks you want to return in one go, max 50. @default 20 */
-  take: import_zod12.z.number().optional()
-});
-var GetRunOptionsWithTaskDetailsSchema = GetRunOptionsSchema.extend({
-  /** If `true`, it returns the `params` and `output` of all tasks. @default false */
-  taskdetails: import_zod12.z.boolean().optional()
-});
-var RunSchema = import_zod12.z.object({
-  /** The Run id */
-  id: import_zod12.z.string(),
-  /** The Run status */
-  status: RunStatusSchema,
-  /** When the run started */
-  startedAt: import_zod12.z.coerce.date().nullable(),
-  /** When the run was last updated */
-  updatedAt: import_zod12.z.coerce.date().nullable(),
-  /** When the run was completed */
-  completedAt: import_zod12.z.coerce.date().nullable()
-});
-var GetRunSchema = RunSchema.extend({
-  /** The output of the run */
-  output: import_zod12.z.any().optional(),
-  /** The tasks from the run */
-  tasks: import_zod12.z.array(RunTaskWithSubtasksSchema),
-  /** If there are more tasks, you can use this to get them */
-  nextCursor: import_zod12.z.string().optional()
-});
-var GetRunsOptionsSchema = import_zod12.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_zod12.z.string().optional(),
-  /** How many runs you want to return in one go, max 50. @default 20 */
-  take: import_zod12.z.number().optional()
-});
-var GetRunsSchema = import_zod12.z.object({
-  /** The runs from the query */
-  runs: RunSchema.array(),
-  /** If there are more runs, you can use this to get them */
-  nextCursor: import_zod12.z.string().optional()
-});
-
-// src/schemas/events.ts
-var GetEventSchema = import_zod13.z.object({
-  /** The event id */
-  id: import_zod13.z.string(),
-  /** The event name */
-  name: import_zod13.z.string(),
-  /** When the event was created */
-  createdAt: import_zod13.z.coerce.date(),
-  /** When the event was last updated */
-  updatedAt: import_zod13.z.coerce.date(),
-  /** The runs that were triggered by the event */
-  runs: import_zod13.z.array(import_zod13.z.object({
-    /** The Run id */
-    id: import_zod13.z.string(),
-    /** The Run status */
-    status: RunStatusSchema,
-    /** When the run started */
-    startedAt: import_zod13.z.coerce.date().optional().nullable(),
-    /** When the run completed */
-    completedAt: import_zod13.z.coerce.date().optional().nullable()
-  }))
-});
-
-// src/utils.ts
-function deepMergeFilters(...filters) {
-  const result = {};
-  for (const filter of filters) {
-    for (const key in filter) {
-      if (filter.hasOwnProperty(key)) {
-        const filterValue = filter[key];
-        const existingValue = result[key];
-        if (existingValue && typeof existingValue === "object" && typeof filterValue === "object" && !Array.isArray(existingValue) && !Array.isArray(filterValue) && existingValue !== null && filterValue !== null) {
-          result[key] = deepMergeFilters(existingValue, filterValue);
-        } else {
-          result[key] = filterValue;
-        }
-      }
-    }
-  }
-  return result;
-}
-__name(deepMergeFilters, "deepMergeFilters");
-
-// src/retry.ts
-var DEFAULT_RETRY_OPTIONS = {
-  limit: 5,
-  factor: 1.8,
-  minTimeoutInMs: 1e3,
-  maxTimeoutInMs: 6e4,
-  randomize: true
-};
-function calculateRetryAt(retryOptions, attempts) {
-  const options = {
-    ...DEFAULT_RETRY_OPTIONS,
-    ...retryOptions
-  };
-  const retryCount = attempts + 1;
-  if (retryCount >= options.limit) {
-    return;
-  }
-  const random = options.randomize ? Math.random() + 1 : 1;
-  let timeoutInMs = Math.round(random * Math.max(options.minTimeoutInMs, 1) * Math.pow(options.factor, Math.max(attempts - 1, 0)));
-  timeoutInMs = Math.min(timeoutInMs, options.maxTimeoutInMs);
-  return new Date(Date.now() + timeoutInMs);
-}
-__name(calculateRetryAt, "calculateRetryAt");
-
-// src/replacements.ts
-var currentDate = {
-  marker: "__CURRENT_DATE__",
-  replace({ data: { now } }) {
-    return now.toISOString();
-  }
-};
-var currentTimestampMilliseconds = {
-  marker: "__CURRENT_TIMESTAMP_MS__",
-  replace({ data: { now } }) {
-    return now.getTime();
-  }
-};
-var currentTimestampSeconds = {
-  marker: "__CURRENT_TIMESTAMP_S__",
-  replace({ data: { now } }) {
-    return now.getTime() / 1e3;
-  }
-};
-var replacements = [
-  currentDate,
-  currentTimestampMilliseconds,
-  currentTimestampSeconds
-];
-
-// src/searchParams.ts
-function urlWithSearchParams(url, params) {
-  if (!params) {
-    return url;
-  }
-  const urlObj = new URL(url);
-  for (const [key, value] of Object.entries(params)) {
-    urlObj.searchParams.append(key, String(value));
-  }
-  return urlObj.toString();
-}
-__name(urlWithSearchParams, "urlWithSearchParams");
-
-// src/eventFilterMatches.ts
-function eventFilterMatches(payload, filter) {
-  for (const [patternKey, patternValue] of Object.entries(filter)) {
-    const payloadValue = payload[patternKey];
-    if (Array.isArray(patternValue)) {
-      if (patternValue.length === 0) {
-        continue;
-      }
-      if (patternValue.every((item) => typeof item === "string")) {
-        if (patternValue.includes(payloadValue)) {
-          continue;
-        }
-        return false;
-      }
-      if (patternValue.every((item) => typeof item === "number")) {
-        if (patternValue.includes(payloadValue)) {
-          continue;
-        }
-        return false;
-      }
-      if (patternValue.every((item) => typeof item === "boolean")) {
-        if (patternValue.includes(payloadValue)) {
-          continue;
-        }
-        return false;
-      }
-      const objectArray = patternValue;
-      if (!contentFiltersMatches(payloadValue, objectArray)) {
-        return false;
-      }
-      continue;
-    } else if (typeof patternValue === "object") {
-      if (Array.isArray(payloadValue)) {
-        if (!payloadValue.some((item) => eventFilterMatches(item, patternValue))) {
-          return false;
-        }
-      } else {
-        if (!eventFilterMatches(payloadValue, patternValue)) {
-          return false;
-        }
-      }
-    }
-  }
-  return true;
-}
-__name(eventFilterMatches, "eventFilterMatches");
-function contentFiltersMatches(actualValue, contentFilters) {
-  for (const contentFilter of contentFilters) {
-    if (typeof contentFilter === "object") {
-      const [key, value] = Object.entries(contentFilter)[0];
-      if (!contentFilterMatches(actualValue, contentFilter)) {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-__name(contentFiltersMatches, "contentFiltersMatches");
-function contentFilterMatches(actualValue, contentFilter) {
-  if ("$endsWith" in contentFilter) {
-    if (typeof actualValue !== "string") {
-      return false;
-    }
-    return actualValue.endsWith(contentFilter.$endsWith);
-  }
-  if ("$startsWith" in contentFilter) {
-    if (typeof actualValue !== "string") {
-      return false;
-    }
-    return actualValue.startsWith(contentFilter.$startsWith);
-  }
-  if ("$anythingBut" in contentFilter) {
-    if (Array.isArray(contentFilter.$anythingBut)) {
-      if (contentFilter.$anythingBut.includes(actualValue)) {
-        return false;
-      }
-    }
-    if (contentFilter.$anythingBut === actualValue) {
-      return false;
-    }
-    return true;
-  }
-  if ("$exists" in contentFilter) {
-    if (contentFilter.$exists) {
-      return actualValue !== void 0;
-    }
-    return actualValue === void 0;
-  }
-  if ("$gt" in contentFilter) {
-    if (typeof actualValue !== "number") {
-      return false;
-    }
-    return actualValue > contentFilter.$gt;
-  }
-  if ("$lt" in contentFilter) {
-    if (typeof actualValue !== "number") {
-      return false;
-    }
-    return actualValue < contentFilter.$lt;
-  }
-  if ("$gte" in contentFilter) {
-    if (typeof actualValue !== "number") {
-      return false;
-    }
-    return actualValue >= contentFilter.$gte;
-  }
-  if ("$lte" in contentFilter) {
-    if (typeof actualValue !== "number") {
-      return false;
-    }
-    return actualValue <= contentFilter.$lte;
-  }
-  if ("$between" in contentFilter) {
-    if (typeof actualValue !== "number") {
-      return false;
-    }
-    return actualValue >= contentFilter.$between[0] && actualValue <= contentFilter.$between[1];
-  }
-  if ("$includes" in contentFilter) {
-    if (Array.isArray(actualValue)) {
-      return actualValue.includes(contentFilter.$includes);
-    }
-    return false;
-  }
-  if ("$ignoreCaseEquals" in contentFilter) {
-    if (typeof actualValue !== "string") {
-      return false;
-    }
-    return actualValue.localeCompare(contentFilter.$ignoreCaseEquals, void 0, {
-      sensitivity: "accent"
-    }) === 0;
-  }
-  if ("$isNull" in contentFilter) {
-    if (contentFilter.$isNull) {
-      return actualValue === null;
-    }
-    return actualValue !== null;
-  }
-  return true;
-}
-__name(contentFilterMatches, "contentFilterMatches");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ApiEventLogSchema,
-  CachedTaskSchema,
-  CommonMissingConnectionNotificationPayloadSchema,
-  CommonMissingConnectionNotificationResolvedPayloadSchema,
-  CompleteTaskBodyInputSchema,
-  ConnectionAuthSchema,
-  CreateExternalConnectionBodySchema,
-  CreateRunResponseBodySchema,
-  CronMetadataSchema,
-  CronOptionsSchema,
-  DeliverEventResponseSchema,
-  DeserializedJsonSchema,
-  DisplayPropertiesSchema,
-  DisplayPropertySchema,
-  DynamicTriggerEndpointMetadataSchema,
-  DynamicTriggerMetadataSchema,
-  ErrorWithStackSchema,
-  EventExampleSchema,
-  EventFilterSchema,
-  EventRuleSchema,
-  EventSpecificationSchema,
-  FailTaskBodyInputSchema,
-  FetchOperationSchema,
-  FetchRequestInitSchema,
-  FetchRetryBackoffStrategySchema,
-  FetchRetryHeadersStrategySchema,
-  FetchRetryOptionsSchema,
-  FetchRetryStrategySchema,
-  GetEventSchema,
-  GetRunSchema,
-  GetRunsSchema,
-  HandleTriggerSourceSchema,
-  HttpSourceRequestHeadersSchema,
-  HttpSourceRequestSchema,
-  HttpSourceResponseSchema,
-  IndexEndpointResponseSchema,
-  InitializeCronScheduleBodySchema,
-  InitializeTriggerBodySchema,
-  IntegrationConfigSchema,
-  IntegrationMetadataSchema,
-  IntervalMetadataSchema,
-  IntervalOptionsSchema,
-  JobMetadataSchema,
-  LogMessageSchema,
-  Logger,
-  MISSING_CONNECTION_NOTIFICATION,
-  MISSING_CONNECTION_RESOLVED_NOTIFICATION,
-  MissingConnectionNotificationPayloadSchema,
-  MissingConnectionResolvedNotificationPayloadSchema,
-  MissingDeveloperConnectionNotificationPayloadSchema,
-  MissingDeveloperConnectionResolvedNotificationPayloadSchema,
-  MissingExternalConnectionNotificationPayloadSchema,
-  MissingExternalConnectionResolvedNotificationPayloadSchema,
-  NormalizedRequestSchema,
-  NormalizedResponseSchema,
-  PongErrorResponseSchema,
-  PongResponseSchema,
-  PongSuccessResponseSchema,
-  PreprocessRunBodySchema,
-  PreprocessRunResponseSchema,
-  QueueOptionsSchema,
-  REGISTER_SOURCE_EVENT_V1,
-  REGISTER_SOURCE_EVENT_V2,
-  RawEventSchema,
-  RedactSchema,
-  RedactStringSchema,
-  RegisterDynamicSchedulePayloadSchema,
-  RegisterHTTPTriggerSourceBodySchema,
-  RegisterIntervalScheduleBodySchema,
-  RegisterSMTPTriggerSourceBodySchema,
-  RegisterSQSTriggerSourceBodySchema,
-  RegisterScheduleBodySchema,
-  RegisterScheduleResponseBodySchema,
-  RegisterSourceChannelBodySchema,
-  RegisterSourceEventSchemaV1,
-  RegisterSourceEventSchemaV2,
-  RegisterTriggerBodySchemaV1,
-  RegisterTriggerBodySchemaV2,
-  RegisterTriggerSourceSchema,
-  RetryOptionsSchema,
-  RunJobBodySchema,
-  RunJobCanceledWithTaskSchema,
-  RunJobErrorSchema,
-  RunJobResponseSchema,
-  RunJobResumeWithTaskSchema,
-  RunJobRetryWithTaskSchema,
-  RunJobSuccessSchema,
-  RunSourceContextSchema,
-  RunStatusSchema,
-  RunTaskBodyInputSchema,
-  RunTaskBodyOutputSchema,
-  RunTaskOptionsSchema,
-  RunTaskSchema,
-  RuntimeEnvironmentTypeSchema,
-  SCHEDULED_EVENT,
-  ScheduleMetadataSchema,
-  ScheduledPayloadSchema,
-  ScheduledTriggerMetadataSchema,
-  SendEventBodySchema,
-  SendEventOptionsSchema,
-  SerializableJsonSchema,
-  ServerTaskSchema,
-  SourceMetadataV2Schema,
-  StaticTriggerMetadataSchema,
-  StyleSchema,
-  TaskSchema,
-  TaskStatusSchema,
-  TriggerMetadataSchema,
-  TriggerSourceSchema,
-  UpdateTriggerSourceBodyV1Schema,
-  UpdateTriggerSourceBodyV2Schema,
-  ValidateErrorResponseSchema,
-  ValidateResponseSchema,
-  ValidateSuccessResponseSchema,
-  addMissingVersionField,
-  calculateRetryAt,
-  currentDate,
-  currentTimestampMilliseconds,
-  currentTimestampSeconds,
-  deepMergeFilters,
-  eventFilterMatches,
-  replacements,
-  urlWithSearchParams
-});
-//# sourceMappingURL=index.js.map