@terreno/jobs 57.4.0

package/dist/routes/jobsAdmin.js

@@ -0,0 +1,596 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerJobsAdminRoutes = void 0;
+var api_1 = require("@terreno/api");
+var luxon_1 = require("luxon");
+var mongoose_1 = __importDefault(require("mongoose"));
+var job_1 = require("../models/job");
+var jobSchedule_1 = require("../models/jobSchedule");
+var DEFAULT_LIMIT = 50;
+var MAX_LIMIT = 200;
+var MAX_Q_LENGTH = 200;
+var VALID_JOB_STATUSES = new Set([
+    "cancelled",
+    "completed",
+    "dead",
+    "failed",
+    "pending",
+    "running",
+    "scheduled",
+]);
+var JOB_ADMIN_ITEM_SCHEMA = {
+    _id: { type: "string" },
+    attemptCount: { type: "number" },
+    id: { type: "string" },
+    name: { type: "string" },
+    status: { type: "string" },
+};
+var SCHEDULE_ADMIN_ITEM_SCHEMA = {
+    cron: { type: "string" },
+    enabled: { type: "boolean" },
+    handlerName: { type: "string" },
+    id: { type: "string" },
+    name: { type: "string" },
+    nextRunAt: { format: "date-time", type: "string" },
+    timezone: { type: "string" },
+};
+var pathParam = function (value) {
+    if (Array.isArray(value)) {
+        return value[0];
+    }
+    return value;
+};
+var readString = function (value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    var trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+};
+var readPositiveInt = function (value, fallback, max) {
+    var parsed = typeof value === "number"
+        ? value
+        : typeof value === "string" && value.trim().length > 0
+            ? Number(value)
+            : Number.NaN;
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        return fallback;
+    }
+    return Math.min(Math.floor(parsed), max);
+};
+var escapeRegexLiteral = function (value) { return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); };
+var parseIsoDate = function (value, label) {
+    var raw = readString(value);
+    if (!raw) {
+        return undefined;
+    }
+    var parsed = luxon_1.DateTime.fromISO(raw, { zone: "utc" });
+    if (!parsed.isValid) {
+        throw new api_1.APIError({ status: 400, title: "Invalid ".concat(label) });
+    }
+    return parsed.toJSDate();
+};
+var parseSearchQuery = function (value) {
+    var raw = readString(value);
+    if (!raw) {
+        return undefined;
+    }
+    if (raw.length > MAX_Q_LENGTH) {
+        throw new api_1.APIError({ status: 400, title: "Search query too long" });
+    }
+    return escapeRegexLiteral(raw);
+};
+var parseStatusFilter = function (value) {
+    var status = readString(value);
+    if (!status) {
+        return undefined;
+    }
+    if (!VALID_JOB_STATUSES.has(status)) {
+        throw new api_1.APIError({ status: 400, title: "Invalid status" });
+    }
+    return status;
+};
+var parseListFilters = function (query) { return ({
+    end: parseIsoDate(query.end, "end date"),
+    name: readString(query.name),
+    q: parseSearchQuery(query.q),
+    scheduleId: readString(query.scheduleId),
+    start: parseIsoDate(query.start, "start date"),
+    status: parseStatusFilter(query.status),
+}); };
+var EMPTY_STATUS_COUNTS = {
+    cancelled: 0,
+    completed: 0,
+    dead: 0,
+    failed: 0,
+    pending: 0,
+    running: 0,
+    scheduled: 0,
+};
+var buildStatusCounts = function (grouped) {
+    var e_1, _a;
+    var byStatus = __assign({}, EMPTY_STATUS_COUNTS);
+    var total = 0;
+    try {
+        for (var grouped_1 = __values(grouped), grouped_1_1 = grouped_1.next(); !grouped_1_1.done; grouped_1_1 = grouped_1.next()) {
+            var row = grouped_1_1.value;
+            if (!VALID_JOB_STATUSES.has(row._id)) {
+                continue;
+            }
+            byStatus[row._id] = row.count;
+            total += row.count;
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (grouped_1_1 && !grouped_1_1.done && (_a = grouped_1.return)) _a.call(grouped_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return { byStatus: byStatus, total: total };
+};
+var buildListMatch = function (filters) {
+    var match = {};
+    if (filters.name) {
+        match.name = filters.name;
+    }
+    if (filters.status) {
+        match.status = filters.status;
+    }
+    if (filters.scheduleId) {
+        if (!mongoose_1.default.isValidObjectId(filters.scheduleId)) {
+            throw new api_1.APIError({ status: 400, title: "Invalid scheduleId" });
+        }
+        match.scheduleId = new mongoose_1.default.Types.ObjectId(filters.scheduleId);
+    }
+    if (filters.start || filters.end) {
+        var created = {};
+        if (filters.start) {
+            created.$gte = filters.start;
+        }
+        if (filters.end) {
+            created.$lte = filters.end;
+        }
+        match.created = created;
+    }
+    if (filters.q) {
+        match.$or = [
+            { lastError: { $options: "i", $regex: filters.q } },
+            { name: { $options: "i", $regex: filters.q } },
+        ];
+    }
+    return match;
+};
+var projectAdminPayload = function (job, redactPayload) {
+    if (job.payloadRedacted) {
+        return undefined;
+    }
+    if (!redactPayload) {
+        return undefined;
+    }
+    return redactPayload({
+        name: job.name,
+        payload: job.payload,
+        payloadRedacted: job.payloadRedacted,
+    });
+};
+var serializeJob = function (job, redactPayload) {
+    var json = job.toJSON();
+    var _storedPayload = json.payload, rest = __rest(json, ["payload"]);
+    var projectedPayload = projectAdminPayload(job, redactPayload);
+    if (projectedPayload === undefined) {
+        return __assign(__assign({}, rest), { id: job._id.toString() });
+    }
+    return __assign(__assign({}, rest), { id: job._id.toString(), payload: projectedPayload });
+};
+var serializeSchedule = function (schedule) {
+    var json = schedule.toJSON();
+    return __assign(__assign({}, json), { id: schedule._id.toString() });
+};
+var createRequireJobsAdmin = function (accessControl) {
+    return function (req) { return __awaiter(void 0, void 0, void 0, function () {
+        var user, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    user = req.user;
+                    if (!user) {
+                        throw new api_1.UnauthorizedError("Authentication required");
+                    }
+                    if (!accessControl) return [3 /*break*/, 2];
+                    return [4 /*yield*/, accessControl.can({
+                            permissions: { admin: [api_1.ADMIN_PAGE_ACTION, "jobs"] },
+                            user: user,
+                        })];
+                case 1:
+                    result = _a.sent();
+                    if (!result.allowed) {
+                        throw new api_1.ForbiddenError({
+                            detail: result.reason,
+                            title: "Jobs admin access required",
+                        });
+                    }
+                    return [2 /*return*/];
+                case 2:
+                    if (!user.admin) {
+                        throw new api_1.ForbiddenError("Admin access required");
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    }); };
+};
+var listQueryParameters = function (builder) {
+    return builder
+        .withQueryParameter("page", { type: "number" }, { required: false })
+        .withQueryParameter("limit", { type: "number" }, { required: false })
+        .withQueryParameter("name", { type: "string" }, { required: false })
+        .withQueryParameter("status", { type: "string" }, { required: false })
+        .withQueryParameter("scheduleId", { type: "string" }, { required: false })
+        .withQueryParameter("start", { type: "string" }, { required: false })
+        .withQueryParameter("end", { type: "string" }, { required: false })
+        .withQueryParameter("q", { type: "string" }, { required: false });
+};
+var registerJobsAdminRoutes = function (_a) {
+    var app = _a.app, options = _a.options;
+    var routeOpenApi = options.openApi ? { openApi: options.openApi } : {};
+    var requireJobsAdmin = createRequireJobsAdmin(options.accessControl);
+    var basePath = options.basePath;
+    var jobsService = options.jobsService, redactPayload = options.redactPayload;
+    app.get("".concat(basePath, "/schedules"), [
+        (0, api_1.authenticateMiddleware)(),
+        (0, api_1.createOpenApiBuilder)(routeOpenApi)
+            .withTags(["admin", "jobs"])
+            .withSummary("List configured job schedules")
+            .withResponse(200, {
+            data: {
+                items: {
+                    properties: SCHEDULE_ADMIN_ITEM_SCHEMA,
+                    type: "object",
+                },
+                type: "array",
+            },
+        })
+            .build(),
+    ], (0, api_1.asyncHandler)(function (req, res) { return __awaiter(void 0, void 0, void 0, function () {
+        var schedules;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, requireJobsAdmin(req)];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, jobSchedule_1.JobSchedule.find({}).sort("name")];
+                case 2:
+                    schedules = _a.sent();
+                    return [2 /*return*/, res.json({ data: schedules.map(function (schedule) { return serializeSchedule(schedule); }) })];
+            }
+        });
+    }); }));
+    app.post("".concat(basePath, "/schedules/:name/pause"), [
+        (0, api_1.authenticateMiddleware)(),
+        (0, api_1.createOpenApiBuilder)(routeOpenApi)
+            .withTags(["admin", "jobs"])
+            .withSummary("Pause a job schedule")
+            .withPathParameter("name", { type: "string" })
+            .withResponse(200, { data: { type: "object" } })
+            .build(),
+    ], (0, api_1.asyncHandler)(function (req, res) { return __awaiter(void 0, void 0, void 0, function () {
+        var name, schedule;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, requireJobsAdmin(req)];
+                case 1:
+                    _a.sent();
+                    name = pathParam(req.params.name);
+                    if (!name) {
+                        throw new api_1.NotFoundError("Schedule not found");
+                    }
+                    return [4 /*yield*/, jobsService.pauseSchedule(name)];
+                case 2:
+                    schedule = _a.sent();
+                    return [2 /*return*/, res.json({ data: serializeSchedule(schedule) })];
+            }
+        });
+    }); }));
+    app.post("".concat(basePath, "/schedules/:name/resume"), [
+        (0, api_1.authenticateMiddleware)(),
+        (0, api_1.createOpenApiBuilder)(routeOpenApi)
+            .withTags(["admin", "jobs"])
+            .withSummary("Resume a job schedule")
+            .withPathParameter("name", { type: "string" })
+            .withResponse(200, { data: { type: "object" } })
+            .build(),
+    ], (0, api_1.asyncHandler)(function (req, res) { return __awaiter(void 0, void 0, void 0, function () {
+        var name, schedule;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, requireJobsAdmin(req)];
+                case 1:
+                    _a.sent();
+                    name = pathParam(req.params.name);
+                    if (!name) {
+                        throw new api_1.NotFoundError("Schedule not found");
+                    }
+                    return [4 /*yield*/, jobsService.resumeSchedule(name)];
+                case 2:
+                    schedule = _a.sent();
+                    return [2 /*return*/, res.json({ data: serializeSchedule(schedule) })];
+            }
+        });
+    }); }));
+    app.get(basePath, [
+        (0, api_1.authenticateMiddleware)(),
+        listQueryParameters((0, api_1.createOpenApiBuilder)(routeOpenApi)
+            .withTags(["admin", "jobs"])
+            .withSummary("List background jobs"))
+            .withResponse(200, {
+            data: {
+                items: {
+                    properties: JOB_ADMIN_ITEM_SCHEMA,
+                    type: "object",
+                },
+                type: "array",
+            },
+            limit: { type: "number" },
+            more: { type: "boolean" },
+            page: { type: "number" },
+            total: { type: "number" },
+        })
+            .build(),
+    ], (0, api_1.asyncHandler)(function (req, res) { return __awaiter(void 0, void 0, void 0, function () {
+        var filters, page, limit, skip, match, _a, jobs, total;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, requireJobsAdmin(req)];
+                case 1:
+                    _b.sent();
+                    filters = parseListFilters(req.query);
+                    page = readPositiveInt(req.query.page, 1, Number.MAX_SAFE_INTEGER);
+                    limit = readPositiveInt(req.query.limit, DEFAULT_LIMIT, MAX_LIMIT);
+                    skip = (page - 1) * limit;
+                    match = buildListMatch(filters);
+                    return [4 /*yield*/, Promise.all([
+                            job_1.Job.find(match).sort("-created").skip(skip).limit(limit),
+                            job_1.Job.countDocuments(match),
+                        ])];
+                case 2:
+                    _a = __read.apply(void 0, [_b.sent(), 2]), jobs = _a[0], total = _a[1];
+                    return [2 /*return*/, res.json({
+                            data: jobs.map(function (job) { return serializeJob(job, redactPayload); }),
+                            limit: limit,
+                            more: skip + limit < total,
+                            page: page,
+                            total: total,
+                        })];
+            }
+        });
+    }); }));
+    app.get("".concat(basePath, "/stats"), [
+        (0, api_1.authenticateMiddleware)(),
+        (0, api_1.createOpenApiBuilder)(routeOpenApi)
+            .withTags(["admin", "jobs"])
+            .withSummary("Aggregate background job counts by status")
+            .withResponse(200, {
+            data: {
+                properties: {
+                    byStatus: { type: "object" },
+                    total: { type: "number" },
+                },
+                type: "object",
+            },
+        })
+            .build(),
+    ], (0, api_1.asyncHandler)(function (req, res) { return __awaiter(void 0, void 0, void 0, function () {
+        var grouped;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, requireJobsAdmin(req)];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, job_1.Job.aggregate([
+                            { $group: { _id: "$status", count: { $sum: 1 } } },
+                        ])];
+                case 2:
+                    grouped = _a.sent();
+                    return [2 /*return*/, res.json({ data: buildStatusCounts(grouped) })];
+            }
+        });
+    }); }));
+    app.get("".concat(basePath, "/:id"), [
+        (0, api_1.authenticateMiddleware)(),
+        (0, api_1.createOpenApiBuilder)(routeOpenApi)
+            .withTags(["admin", "jobs"])
+            .withSummary("Read one background job")
+            .withPathParameter("id", { type: "string" })
+            .withResponse(200, { data: { type: "object" } })
+            .build(),
+    ], (0, api_1.asyncHandler)(function (req, res) { return __awaiter(void 0, void 0, void 0, function () {
+        var id, job;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, requireJobsAdmin(req)];
+                case 1:
+                    _a.sent();
+                    id = pathParam(req.params.id);
+                    if (!id || !mongoose_1.default.isValidObjectId(id)) {
+                        throw new api_1.NotFoundError("Job not found");
+                    }
+                    return [4 /*yield*/, job_1.Job.findOneOrNone({ _id: id })];
+                case 2:
+                    job = _a.sent();
+                    if (!job) {
+                        throw new api_1.NotFoundError("Job not found");
+                    }
+                    return [2 /*return*/, res.json({ data: serializeJob(job, redactPayload) })];
+            }
+        });
+    }); }));
+    app.post("".concat(basePath, "/:id/retry"), [
+        (0, api_1.authenticateMiddleware)(),
+        (0, api_1.createOpenApiBuilder)(routeOpenApi)
+            .withTags(["admin", "jobs"])
+            .withSummary("Retry a background job by creating a linked row")
+            .withPathParameter("id", { type: "string" })
+            .withResponse(200, { data: { type: "object" } })
+            .build(),
+    ], (0, api_1.asyncHandler)(function (req, res) { return __awaiter(void 0, void 0, void 0, function () {
+        var id, retry;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, requireJobsAdmin(req)];
+                case 1:
+                    _a.sent();
+                    id = pathParam(req.params.id);
+                    if (!id || !mongoose_1.default.isValidObjectId(id)) {
+                        throw new api_1.NotFoundError("Job not found");
+                    }
+                    return [4 /*yield*/, jobsService.adminRetryJob(id)];
+                case 2:
+                    retry = (_a.sent()).retry;
+                    return [2 /*return*/, res.json({ data: serializeJob(retry, redactPayload) })];
+            }
+        });
+    }); }));
+    app.post("".concat(basePath, "/:id/requeue"), [
+        (0, api_1.authenticateMiddleware)(),
+        (0, api_1.createOpenApiBuilder)(routeOpenApi)
+            .withTags(["admin", "jobs"])
+            .withSummary("Requeue a dead, failed, or cancelled job")
+            .withPathParameter("id", { type: "string" })
+            .withResponse(200, { data: { type: "object" } })
+            .build(),
+    ], (0, api_1.asyncHandler)(function (req, res) { return __awaiter(void 0, void 0, void 0, function () {
+        var id, job;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, requireJobsAdmin(req)];
+                case 1:
+                    _a.sent();
+                    id = pathParam(req.params.id);
+                    if (!id || !mongoose_1.default.isValidObjectId(id)) {
+                        throw new api_1.NotFoundError("Job not found");
+                    }
+                    return [4 /*yield*/, jobsService.adminRequeueJob(id)];
+                case 2:
+                    job = _a.sent();
+                    return [2 /*return*/, res.json({ data: serializeJob(job, redactPayload) })];
+            }
+        });
+    }); }));
+    app.post("".concat(basePath, "/:id/cancel"), [
+        (0, api_1.authenticateMiddleware)(),
+        (0, api_1.createOpenApiBuilder)(routeOpenApi)
+            .withTags(["admin", "jobs"])
+            .withSummary("Cancel a pending, scheduled, or running job")
+            .withPathParameter("id", { type: "string" })
+            .withResponse(200, { data: { type: "object" } })
+            .build(),
+    ], (0, api_1.asyncHandler)(function (req, res) { return __awaiter(void 0, void 0, void 0, function () {
+        var id, job;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, requireJobsAdmin(req)];
+                case 1:
+                    _a.sent();
+                    id = pathParam(req.params.id);
+                    if (!id || !mongoose_1.default.isValidObjectId(id)) {
+                        throw new api_1.NotFoundError("Job not found");
+                    }
+                    return [4 /*yield*/, jobsService.adminCancelJob(id)];
+                case 2:
+                    job = _a.sent();
+                    return [2 /*return*/, res.json({ data: serializeJob(job, redactPayload) })];
+            }
+        });
+    }); }));
+};
+exports.registerJobsAdminRoutes = registerJobsAdminRoutes;

package/dist/routes/jobsExecute.d.ts

@@ -0,0 +1,12 @@
+import type { Application, Request } from "express";
+import { type JobExecutionHost } from "../jobExecutor";
+export type ExecuteAuthVerifier = (req: Request) => boolean | Promise<boolean>;
+export interface RegisterJobsExecuteRouteOptions {
+    basePath: string;
+    executeAuth: ExecuteAuthVerifier;
+    host: JobExecutionHost;
+}
+export declare const registerJobsExecuteRoute: ({ app, options, }: {
+    app: Application;
+    options: RegisterJobsExecuteRouteOptions;
+}) => void;