@trigger.dev/core 0.0.5

package/dist/index.js

@@ -0,0 +1,1260 @@
+"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,
+  CreateRunBodySchema: () => CreateRunBodySchema,
+  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,
+  HttpEventSourceSchema: () => HttpEventSourceSchema,
+  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: () => REGISTER_SOURCE_EVENT,
+  RawEventSchema: () => RawEventSchema,
+  RedactSchema: () => RedactSchema,
+  RedactStringSchema: () => RedactStringSchema,
+  RegisterDynamicSchedulePayloadSchema: () => RegisterDynamicSchedulePayloadSchema,
+  RegisterHTTPTriggerSourceBodySchema: () => RegisterHTTPTriggerSourceBodySchema,
+  RegisterIntervalScheduleBodySchema: () => RegisterIntervalScheduleBodySchema,
+  RegisterSMTPTriggerSourceBodySchema: () => RegisterSMTPTriggerSourceBodySchema,
+  RegisterSQSTriggerSourceBodySchema: () => RegisterSQSTriggerSourceBodySchema,
+  RegisterScheduleBodySchema: () => RegisterScheduleBodySchema,
+  RegisterScheduleResponseBodySchema: () => RegisterScheduleResponseBodySchema,
+  RegisterSourceChannelBodySchema: () => RegisterSourceChannelBodySchema,
+  RegisterSourceEventSchema: () => RegisterSourceEventSchema,
+  RegisterTriggerBodySchema: () => RegisterTriggerBodySchema,
+  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,
+  SourceMetadataSchema: () => SourceMetadataSchema,
+  StaticTriggerMetadataSchema: () => StaticTriggerMetadataSchema,
+  StyleSchema: () => StyleSchema,
+  TaskSchema: () => TaskSchema,
+  TaskStatusSchema: () => TaskStatusSchema,
+  TriggerMetadataSchema: () => TriggerMetadataSchema,
+  TriggerSourceSchema: () => TriggerSourceSchema,
+  UpdateTriggerSourceBodySchema: () => UpdateTriggerSourceBodySchema,
+  calculateRetryAt: () => calculateRetryAt,
+  currentDate: () => currentDate,
+  currentTimestampMilliseconds: () => currentTimestampMilliseconds,
+  currentTimestampSeconds: () => currentTimestampSeconds,
+  deepMergeFilters: () => deepMergeFilters,
+  replacements: () => replacements,
+  urlWithSearchParams: () => urlWithSearchParams
+});
+module.exports = __toCommonJS(src_exports);
+
+// 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)) {
+      continue;
+    }
+    filteredObj[key] = filterKeys(value, keys);
+  }
+  return filteredObj;
+}
+__name(filterKeys, "filterKeys");
+
+// src/schemas/api.ts
+var import_ulid = require("ulid");
+var import_zod9 = require("zod");
+
+// 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())
+]);
+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 UpdateTriggerSourceBodySchema = import_zod9.z.object({
+  registeredEvents: import_zod9.z.array(import_zod9.z.string()),
+  secret: import_zod9.z.string().optional(),
+  data: SerializableJsonSchema.optional()
+});
+var HttpEventSourceSchema = UpdateTriggerSourceBodySchema.extend({
+  id: import_zod9.z.string(),
+  active: import_zod9.z.boolean(),
+  url: import_zod9.z.string().url()
+});
+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 = "dev.trigger.source.register";
+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 RegisterSourceEventSchema = 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 TriggerSourceSchema = import_zod9.z.object({
+  id: import_zod9.z.string(),
+  key: import_zod9.z.string()
+});
+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()
+});
+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(Buffer).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)))
+});
+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 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),
+  queue: import_zod9.z.union([
+    QueueOptionsSchema,
+    import_zod9.z.string()
+  ]).optional(),
+  startPosition: import_zod9.z.enum([
+    "initial",
+    "latest"
+  ]),
+  enabled: import_zod9.z.boolean(),
+  preprocessRuns: import_zod9.z.boolean()
+});
+var SourceMetadataSchema = import_zod9.z.object({
+  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 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_ulid.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()
+});
+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 CreateRunBodySchema = import_zod9.z.object({
+  client: import_zod9.z.string(),
+  job: JobMetadataSchema,
+  event: ApiEventLogSchema,
+  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(),
+  /** 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)
+});
+var RegisterTriggerBodySchema = import_zod9.z.object({
+  rule: EventRuleSchema,
+  source: SourceMetadataSchema
+});
+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 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(RunTaskSchema),
+  /** 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");
+//# sourceMappingURL=index.js.map