Skip to content
Monque v1.18.0

createManagementRouter

function createManagementRouter<TContext>(options): object;

Defined in: orpc/router.ts:33

Create an oRPC router that implements the management contract.

Use this when integrating with oRPC directly. For a framework-neutral fetch handler, prefer createManagementSurface().

Type Parameters

Section titled “Type Parameters”
Type ParameterDefault type
TContextunknown

Parameters

Section titled “Parameters”
ParameterType
optionsManagementOptions<TContext>

Returns

Section titled “Returns”

object

cancelJob

Section titled “cancelJob”
cancelJob: Lazyable<Procedure<ManagementOpenApiContext<TContext>, any, ZodObject<{
  body: ZodOptional<ZodUnknown>;
  headers: ZodOptional<ZodObject<{
  }, $loose>>;
  params: ZodObject<{
     id: ZodString;
  }, $strict>;
  query: ZodOptional<ZodObject<{
  }, $strict>>;
}, $strict>, ZodObject<{
  claimedBy: ZodNullable<ZodString>;
  createdAt: ZodISODateTime;
  failCount: ZodNumber;
  failureReason: ZodNullable<ZodString>;
  heartbeatInterval: ZodOptional<ZodNumber>;
  id: ZodString;
  lastHeartbeat: ZodNullable<ZodISODateTime>;
  leaseExpiresAt: ZodOptional<ZodISODateTime>;
  lockedAt: ZodNullable<ZodISODateTime>;
  name: ZodString;
  nextRunAt: ZodISODateTime;
  payload: ZodNonOptional<ZodUnknown>;
  priority: ZodInt;
  repeatInterval: ZodOptional<ZodString>;
  status: ZodEnum<{
     cancelled: "cancelled";
     completed: "completed";
     failed: "failed";
     pending: "pending";
     processing: "processing";
  }>;
  timezone: ZodOptional<ZodString>;
  uniqueKey: ZodOptional<ZodString>;
  updatedAt: ZodISODateTime;
}, $strict>, MergedErrorMap<Record<never, never>, {
  BAD_REQUEST: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 400;
  };
  CONFLICT: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 409;
  };
  FORBIDDEN: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 403;
  };
  INTERNAL_SERVER_ERROR: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 500;
  };
  NOT_FOUND: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 404;
  };
}>, Record<never, never>>>;

cancelJobs

Section titled “cancelJobs”
cancelJobs: Lazyable<Procedure<ManagementOpenApiContext<TContext>, any, ZodObject<{
  name: ZodOptional<ZodString>;
  newerThan: ZodOptional<ZodISODateTime>;
  olderThan: ZodOptional<ZodISODateTime>;
  status: ZodOptional<ZodUnion<readonly [ZodEnum<{
     cancelled: "cancelled";
     completed: "completed";
     failed: "failed";
     pending: "pending";
     processing: "processing";
   }>, ZodArray<ZodEnum<{
     cancelled: ...;
     completed: ...;
     failed: ...;
     pending: ...;
     processing: ...;
  }>>]>>;
}, $strict>, ZodObject<{
  count: ZodNumber;
  errors: ZodArray<ZodObject<{
     error: ZodString;
     jobId: ZodString;
     status: ZodOptional<ZodNumber>;
  }, $strict>>;
}, $strict>, MergedErrorMap<Record<never, never>, {
  BAD_REQUEST: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 400;
  };
  CONFLICT: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 409;
  };
  FORBIDDEN: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 403;
  };
  INTERNAL_SERVER_ERROR: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 500;
  };
}>, Record<never, never>>>;

capabilities

Section titled “capabilities”
capabilities: Lazyable<Procedure<ManagementOpenApiContext<TContext>, any, ZodOptional<ZodObject<{
  name: ZodOptional<ZodString>;
}, $strict>>, ZodObject<{
  actions: ZodObject<{
     cancel: ZodBoolean;
     cancelBulk: ZodBoolean;
     delete: ZodBoolean;
     deleteBulk: ZodBoolean;
     pause: ZodOptional<ZodBoolean>;
     read: ZodBoolean;
     reschedule: ZodBoolean;
     resume: ZodOptional<ZodBoolean>;
     retry: ZodBoolean;
     retryBulk: ZodBoolean;
     setJobPriority: ZodOptional<ZodBoolean>;
  }, $strict>;
  readOnly: ZodBoolean;
}, $strict>, Record<never, never>, Record<never, never>>>;

deleteJob

Section titled “deleteJob”
deleteJob: Lazyable<Procedure<ManagementOpenApiContext<TContext>, any, ZodObject<{
  body: ZodOptional<ZodUnknown>;
  headers: ZodOptional<ZodObject<{
  }, $loose>>;
  params: ZodObject<{
     id: ZodString;
  }, $strict>;
  query: ZodOptional<ZodObject<{
  }, $strict>>;
}, $strict>, ZodObject<{
  deleted: ZodLiteral<true>;
}, $strict>, MergedErrorMap<Record<never, never>, {
  BAD_REQUEST: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 400;
  };
  CONFLICT: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 409;
  };
  FORBIDDEN: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 403;
  };
  INTERNAL_SERVER_ERROR: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 500;
  };
  NOT_FOUND: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 404;
  };
}>, Record<never, never>>>;

deleteJobs

Section titled “deleteJobs”
deleteJobs: Lazyable<Procedure<ManagementOpenApiContext<TContext>, any, ZodObject<{
  name: ZodOptional<ZodString>;
  newerThan: ZodOptional<ZodISODateTime>;
  olderThan: ZodOptional<ZodISODateTime>;
  status: ZodOptional<ZodUnion<readonly [ZodEnum<{
     cancelled: "cancelled";
     completed: "completed";
     failed: "failed";
     pending: "pending";
     processing: "processing";
   }>, ZodArray<ZodEnum<{
     cancelled: ...;
     completed: ...;
     failed: ...;
     pending: ...;
     processing: ...;
  }>>]>>;
}, $strict>, ZodObject<{
  count: ZodNumber;
  errors: ZodArray<ZodObject<{
     error: ZodString;
     jobId: ZodString;
     status: ZodOptional<ZodNumber>;
  }, $strict>>;
}, $strict>, MergedErrorMap<Record<never, never>, {
  BAD_REQUEST: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 400;
  };
  CONFLICT: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 409;
  };
  FORBIDDEN: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 403;
  };
  INTERNAL_SERVER_ERROR: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 500;
  };
}>, Record<never, never>>>;

health

Section titled “health”
health: Lazyable<Procedure<ManagementOpenApiContext<TContext>, any, Schema<unknown, unknown>, ZodObject<{
  scheduler: ZodObject<{
     healthy: ZodBoolean;
  }, $strict>;
  status: ZodEnum<{
     ok: "ok";
     unavailable: "unavailable";
  }>;
}, $strict>, Record<never, never>, Record<never, never>>>;

job

Section titled “job”
job: Lazyable<Procedure<ManagementOpenApiContext<TContext>, any, ZodObject<{
  body: ZodOptional<ZodUnknown>;
  headers: ZodOptional<ZodObject<{
  }, $loose>>;
  params: ZodObject<{
     id: ZodString;
  }, $strict>;
  query: ZodOptional<ZodObject<{
  }, $strict>>;
}, $strict>, ZodObject<{
  claimedBy: ZodNullable<ZodString>;
  createdAt: ZodISODateTime;
  failCount: ZodNumber;
  failureReason: ZodNullable<ZodString>;
  heartbeatInterval: ZodOptional<ZodNumber>;
  id: ZodString;
  lastHeartbeat: ZodNullable<ZodISODateTime>;
  leaseExpiresAt: ZodOptional<ZodISODateTime>;
  lockedAt: ZodNullable<ZodISODateTime>;
  name: ZodString;
  nextRunAt: ZodISODateTime;
  payload: ZodNonOptional<ZodUnknown>;
  priority: ZodInt;
  repeatInterval: ZodOptional<ZodString>;
  status: ZodEnum<{
     cancelled: "cancelled";
     completed: "completed";
     failed: "failed";
     pending: "pending";
     processing: "processing";
  }>;
  timezone: ZodOptional<ZodString>;
  uniqueKey: ZodOptional<ZodString>;
  updatedAt: ZodISODateTime;
}, $strict>, Record<never, never>, Record<never, never>>>;

jobs

Section titled “jobs”
jobs: Lazyable<Procedure<ManagementOpenApiContext<TContext>, any, ZodObject<{
  createdAtFrom: ZodOptional<ZodISODateTime>;
  createdAtTo: ZodOptional<ZodISODateTime>;
  cursor: ZodOptional<ZodString>;
  limit: ZodOptional<ZodString>;
  name: ZodOptional<ZodString>;
  nextRunAtFrom: ZodOptional<ZodISODateTime>;
  nextRunAtTo: ZodOptional<ZodISODateTime>;
  sortBy: ZodOptional<ZodEnum<{
     createdAt: "createdAt";
     identifier: "identifier";
     nextRunAt: "nextRunAt";
     updatedAt: "updatedAt";
  }>>;
  sortDirection: ZodOptional<ZodEnum<{
     asc: "asc";
     desc: "desc";
  }>>;
  status: ZodOptional<ZodUnion<readonly [ZodEnum<{
     cancelled: "cancelled";
     completed: "completed";
     failed: "failed";
     pending: "pending";
     processing: "processing";
   }>, ZodArray<ZodEnum<{
     cancelled: ...;
     completed: ...;
     failed: ...;
     pending: ...;
     processing: ...;
  }>>]>>;
  updatedAtFrom: ZodOptional<ZodISODateTime>;
  updatedAtTo: ZodOptional<ZodISODateTime>;
  view: ZodOptional<ZodEnum<{
     full: "full";
     summary: "summary";
  }>>;
}, $strict>, ZodObject<{
  cursor: ZodNullable<ZodString>;
  hasNextPage: ZodBoolean;
  hasPreviousPage: ZodBoolean;
  jobs: ZodArray<ZodObject<{
     claimedBy: ZodNullable<ZodString>;
     createdAt: ZodISODateTime;
     failCount: ZodNumber;
     failureReason: ZodNullable<ZodString>;
     heartbeatInterval: ZodOptional<ZodNumber>;
     id: ZodString;
     lastHeartbeat: ZodNullable<ZodISODateTime>;
     leaseExpiresAt: ZodOptional<ZodISODateTime>;
     lockedAt: ZodNullable<ZodISODateTime>;
     name: ZodString;
     nextRunAt: ZodISODateTime;
     payload: ZodNonOptional<ZodUnknown>;
     priority: ZodInt;
     repeatInterval: ZodOptional<ZodString>;
     status: ZodEnum<{
        cancelled: "cancelled";
        completed: "completed";
        failed: "failed";
        pending: "pending";
        processing: "processing";
     }>;
     timezone: ZodOptional<ZodString>;
     uniqueKey: ZodOptional<ZodString>;
     updatedAt: ZodISODateTime;
  }, $strict>>;
}, $strict>, Record<never, never>, Record<never, never>>>;

jobStats

Section titled “jobStats”
jobStats: Lazyable<Procedure<ManagementOpenApiContext<TContext>, any, ZodObject<{
  name: ZodOptional<ZodString>;
}, $strict>, ZodObject<{
  avgProcessingDurationMs: ZodOptional<ZodNumber>;
  cancelled: ZodNumber;
  completed: ZodNumber;
  failed: ZodNumber;
  pending: ZodNumber;
  processing: ZodNumber;
  total: ZodNumber;
}, $strict>, Record<never, never>, Record<never, never>>>;

pauseProcessing

Section titled “pauseProcessing”
pauseProcessing: Lazyable<Procedure<ManagementOpenApiContext<TContext>, any, ZodObject<{
  instanceId: ZodString;
  name: ZodOptional<ZodString>;
}, $strict>, ZodObject<{
  globallyPaused: ZodBoolean;
  instanceId: ZodString;
  name: ZodOptional<ZodString>;
  paused: ZodBoolean;
}, $strict>, MergedErrorMap<Record<never, never>, {
  BAD_REQUEST: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 400;
  };
  CONFLICT: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 409;
  };
  FORBIDDEN: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 403;
  };
  INTERNAL_SERVER_ERROR: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 500;
  };
}>, Record<never, never>>>;

processingState

Section titled “processingState”
processingState: Lazyable<Procedure<ManagementOpenApiContext<TContext>, any, ZodOptional<ZodObject<{
  name: ZodOptional<ZodString>;
}, $strict>>, ZodObject<{
  globallyPaused: ZodBoolean;
  instanceId: ZodString;
  name: ZodOptional<ZodString>;
  paused: ZodBoolean;
}, $strict>, MergedErrorMap<Record<never, never>, {
  BAD_REQUEST: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 400;
  };
  CONFLICT: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 409;
  };
  FORBIDDEN: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 403;
  };
  INTERNAL_SERVER_ERROR: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 500;
  };
}>, Record<never, never>>>;

queueViews

Section titled “queueViews”
queueViews: Lazyable<Procedure<ManagementOpenApiContext<TContext>, any, ZodOptional<ZodObject<{
  name: ZodOptional<ZodString>;
}, $strict>>, ZodObject<{
  queueViews: ZodArray<ZodObject<{
     hasPersistedJobs: ZodBoolean;
     hasRegisteredWorker: ZodBoolean;
     name: ZodString;
     stats: ZodObject<{
        avgProcessingDurationMs: ZodOptional<...>;
        cancelled: ZodNumber;
        completed: ZodNumber;
        failed: ZodNumber;
        pending: ZodNumber;
        processing: ZodNumber;
        total: ZodNumber;
     }, $strict>;
     worker: ZodNullable<ZodObject<{
        activeCount: ...;
        baseRetryInterval: ...;
        concurrency: ...;
        hasSchema: ...;
        maxBackoffDelay: ...;
        maxRetries: ...;
        paused: ...;
     }, $strict>>;
  }, $strict>>;
}, $strict>, Record<never, never>, Record<never, never>>>;

rescheduleJob

Section titled “rescheduleJob”
rescheduleJob: Lazyable<Procedure<ManagementOpenApiContext<TContext>, any, ZodObject<{
  body: ZodObject<{
     nextRunAt: ZodISODateTime;
  }, $strict>;
  headers: ZodOptional<ZodObject<{
  }, $loose>>;
  params: ZodObject<{
     id: ZodString;
  }, $strict>;
  query: ZodOptional<ZodObject<{
  }, $strict>>;
}, $strict>, ZodObject<{
  claimedBy: ZodNullable<ZodString>;
  createdAt: ZodISODateTime;
  failCount: ZodNumber;
  failureReason: ZodNullable<ZodString>;
  heartbeatInterval: ZodOptional<ZodNumber>;
  id: ZodString;
  lastHeartbeat: ZodNullable<ZodISODateTime>;
  leaseExpiresAt: ZodOptional<ZodISODateTime>;
  lockedAt: ZodNullable<ZodISODateTime>;
  name: ZodString;
  nextRunAt: ZodISODateTime;
  payload: ZodNonOptional<ZodUnknown>;
  priority: ZodInt;
  repeatInterval: ZodOptional<ZodString>;
  status: ZodEnum<{
     cancelled: "cancelled";
     completed: "completed";
     failed: "failed";
     pending: "pending";
     processing: "processing";
  }>;
  timezone: ZodOptional<ZodString>;
  uniqueKey: ZodOptional<ZodString>;
  updatedAt: ZodISODateTime;
}, $strict>, MergedErrorMap<Record<never, never>, {
  BAD_REQUEST: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 400;
  };
  CONFLICT: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 409;
  };
  FORBIDDEN: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 403;
  };
  INTERNAL_SERVER_ERROR: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 500;
  };
  NOT_FOUND: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 404;
  };
}>, Record<never, never>>>;

resumeProcessing

Section titled “resumeProcessing”
resumeProcessing: Lazyable<Procedure<ManagementOpenApiContext<TContext>, any, ZodObject<{
  instanceId: ZodString;
  name: ZodOptional<ZodString>;
}, $strict>, ZodObject<{
  globallyPaused: ZodBoolean;
  instanceId: ZodString;
  name: ZodOptional<ZodString>;
  paused: ZodBoolean;
}, $strict>, MergedErrorMap<Record<never, never>, {
  BAD_REQUEST: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 400;
  };
  CONFLICT: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 409;
  };
  FORBIDDEN: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 403;
  };
  INTERNAL_SERVER_ERROR: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 500;
  };
}>, Record<never, never>>>;

retryJob

Section titled “retryJob”
retryJob: Lazyable<Procedure<ManagementOpenApiContext<TContext>, any, ZodObject<{
  body: ZodOptional<ZodUnknown>;
  headers: ZodOptional<ZodObject<{
  }, $loose>>;
  params: ZodObject<{
     id: ZodString;
  }, $strict>;
  query: ZodOptional<ZodObject<{
  }, $strict>>;
}, $strict>, ZodObject<{
  claimedBy: ZodNullable<ZodString>;
  createdAt: ZodISODateTime;
  failCount: ZodNumber;
  failureReason: ZodNullable<ZodString>;
  heartbeatInterval: ZodOptional<ZodNumber>;
  id: ZodString;
  lastHeartbeat: ZodNullable<ZodISODateTime>;
  leaseExpiresAt: ZodOptional<ZodISODateTime>;
  lockedAt: ZodNullable<ZodISODateTime>;
  name: ZodString;
  nextRunAt: ZodISODateTime;
  payload: ZodNonOptional<ZodUnknown>;
  priority: ZodInt;
  repeatInterval: ZodOptional<ZodString>;
  status: ZodEnum<{
     cancelled: "cancelled";
     completed: "completed";
     failed: "failed";
     pending: "pending";
     processing: "processing";
  }>;
  timezone: ZodOptional<ZodString>;
  uniqueKey: ZodOptional<ZodString>;
  updatedAt: ZodISODateTime;
}, $strict>, MergedErrorMap<Record<never, never>, {
  BAD_REQUEST: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 400;
  };
  CONFLICT: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 409;
  };
  FORBIDDEN: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 403;
  };
  INTERNAL_SERVER_ERROR: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 500;
  };
  NOT_FOUND: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 404;
  };
}>, Record<never, never>>>;

retryJobs

Section titled “retryJobs”
retryJobs: Lazyable<Procedure<ManagementOpenApiContext<TContext>, any, ZodObject<{
  name: ZodOptional<ZodString>;
  newerThan: ZodOptional<ZodISODateTime>;
  olderThan: ZodOptional<ZodISODateTime>;
  status: ZodOptional<ZodUnion<readonly [ZodEnum<{
     cancelled: "cancelled";
     completed: "completed";
     failed: "failed";
     pending: "pending";
     processing: "processing";
   }>, ZodArray<ZodEnum<{
     cancelled: ...;
     completed: ...;
     failed: ...;
     pending: ...;
     processing: ...;
  }>>]>>;
}, $strict>, ZodObject<{
  count: ZodNumber;
  errors: ZodArray<ZodObject<{
     error: ZodString;
     jobId: ZodString;
     status: ZodOptional<ZodNumber>;
  }, $strict>>;
}, $strict>, MergedErrorMap<Record<never, never>, {
  BAD_REQUEST: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 400;
  };
  CONFLICT: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 409;
  };
  FORBIDDEN: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 403;
  };
  INTERNAL_SERVER_ERROR: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 500;
  };
}>, Record<never, never>>>;

selectedJobActions

Section titled “selectedJobActions”
selectedJobActions: Lazyable<Procedure<ManagementOpenApiContext<TContext>, any, ZodDiscriminatedUnion<[ZodObject<{
  action: ZodEnum<{
     cancel: "cancel";
     delete: "delete";
     retry: "retry";
  }>;
  ids: ZodArray<ZodString>;
}, $strict>, ZodObject<{
  action: ZodLiteral<"reschedule">;
  ids: ZodArray<ZodString>;
  nextRunAt: ZodISODateTime;
}, $strict>, ZodObject<{
  action: ZodLiteral<"priority">;
  ids: ZodArray<ZodString>;
  priority: ZodInt;
}, $strict>], "action">, ZodObject<{
  count: ZodNumber;
  errors: ZodArray<ZodObject<{
     error: ZodString;
     jobId: ZodString;
     status: ZodOptional<ZodNumber>;
  }, $strict>>;
}, $strict>, MergedErrorMap<Record<never, never>, {
  BAD_REQUEST: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 400;
  };
  CONFLICT: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 409;
  };
  FORBIDDEN: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 403;
  };
  INTERNAL_SERVER_ERROR: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 500;
  };
}>, Record<never, never>>>;

setJobPriority

Section titled “setJobPriority”
setJobPriority: Lazyable<Procedure<ManagementOpenApiContext<TContext>, any, ZodObject<{
  body: ZodObject<{
     priority: ZodInt;
  }, $strict>;
  headers: ZodOptional<ZodObject<{
  }, $loose>>;
  params: ZodObject<{
     id: ZodString;
  }, $strict>;
  query: ZodOptional<ZodObject<{
  }, $strict>>;
}, $strict>, ZodObject<{
  claimedBy: ZodNullable<ZodString>;
  createdAt: ZodISODateTime;
  failCount: ZodNumber;
  failureReason: ZodNullable<ZodString>;
  heartbeatInterval: ZodOptional<ZodNumber>;
  id: ZodString;
  lastHeartbeat: ZodNullable<ZodISODateTime>;
  leaseExpiresAt: ZodOptional<ZodISODateTime>;
  lockedAt: ZodNullable<ZodISODateTime>;
  name: ZodString;
  nextRunAt: ZodISODateTime;
  payload: ZodNonOptional<ZodUnknown>;
  priority: ZodInt;
  repeatInterval: ZodOptional<ZodString>;
  status: ZodEnum<{
     cancelled: "cancelled";
     completed: "completed";
     failed: "failed";
     pending: "pending";
     processing: "processing";
  }>;
  timezone: ZodOptional<ZodString>;
  uniqueKey: ZodOptional<ZodString>;
  updatedAt: ZodISODateTime;
}, $strict>, MergedErrorMap<Record<never, never>, {
  BAD_REQUEST: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 400;
  };
  CONFLICT: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 409;
  };
  FORBIDDEN: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 403;
  };
  INTERNAL_SERVER_ERROR: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 500;
  };
  NOT_FOUND: {
     data: ZodObject<{
        error: ZodString;
     }, $strict>;
     status: 404;
  };
}>, Record<never, never>>>;