@openinc/parse-server-opendash 4.1.8 → 4.2.0

package/dist/features/openservice/init.js

@@ -5,6 +5,8 @@ const initIssuecategory_js_1 = require("./issuecategory/initIssuecategory.js");
 const initKanbanStates_js_1 = require("./kanbanState/initKanbanStates.js");
 const initMessages_js_1 = require("./messages/initMessages.js");
 const initSchedulesFeature_js_1 = require("./schedules/initSchedulesFeature.js");
+const initServiceSchedulesFeature_js_1 = require("./serviceSchedules/initServiceSchedulesFeature.js");
+const index_js_1 = require("./serviceTickets/alarmActions/index.js");
 const checkStatus_js_1 = require("./schedules/mappings/checkStatus.js");
 const reassignScheduleExecutions_js_1 = require("./schedules/mappings/reassignScheduleExecutions.js");
 const initTicket_js_1 = require("./ticket/initTicket.js");
@@ -20,5 +22,7 @@ async function init() {
     await (0, reassignScheduleExecutions_js_1.reassignScheduleExecutions)();
     await (0, checkStatus_js_1.checkStatus)();
     await (0, initSchedulesFeature_js_1.initSchedulesFeature)();
+    await (0, initServiceSchedulesFeature_js_1.initServiceSchedulesFeature)();
+    await (0, index_js_1.ensureAlarmTicketAction)();
     console.log("open.SERVICE feature initialized.");
 }

package/dist/features/openservice/schedules/calendarSync/types/Event.d.ts

@@ -35,6 +35,8 @@ export type RecurrencePattern = {
     daysOfWeek?: Array<"Sunday" | "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday">;
     firstDayOfWeek?: "Sunday" | "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday";
     month?: number;
+    /** Day of the month for `absoluteMonthly` / `absoluteYearly` patterns. */
+    dayOfMonth?: number;
     index?: "first" | "second" | "third" | "fourth" | "last";
 };
 export type RecurrenceRange = {

package/dist/features/openservice/serviceSchedules/calendarSync/functions/eventToPlan.d.ts

@@ -0,0 +1,50 @@
+import type { GraphEventResponse } from "../../../schedules/calendarSync/types/Event.js";
+import type { ServiceCadence, ServiceNotificationRule } from "../types/ServiceSyncTypes.js";
+/**
+ * The rule id the sync owns.
+ *
+ * An Outlook reminder becomes one notification rule on the plan, and it always
+ * gets **this** id: the sync may replace or remove its own rule on every
+ * inbound change, and must never touch the rules a user wrote in the plan
+ * editor. A stable id also keeps the scheduler's dedup key
+ * (`{scheduleId, ruleId, occurrence}`) stable, so re-syncing an unchanged event
+ * does not notify twice.
+ */
+export declare const OUTLOOK_REMINDER_RULE_ID = "outlook-reminder";
+/** What an Outlook event says about a maintenance plan. */
+export type PlanFieldsFromEvent = {
+    /** Plan title — the subject, minus the machine prefix if there was one. */
+    title: string;
+    /** Machine name from the subject convention, if the subject used it. */
+    equipmentName?: string;
+    cadence: ServiceCadence;
+    /** The event's note, kept as the description of the plan's first step. */
+    description?: string;
+    /** The event's reminder, as the sync's own notification rule. */
+    notification?: ServiceNotificationRule;
+};
+/**
+ * Read a calendar event as maintenance plan fields.
+ *
+ * Pure — resolving the machine and writing the plan is the poller's job.
+ * Returns `undefined` for an event without a usable start, which is the one
+ * thing a plan cannot do without.
+ */
+export declare function eventToPlanFields(event: GraphEventResponse): PlanFieldsFromEvent | undefined;
+/**
+ * Split `"Flex 1" - Ölwechsel` into machine and title.
+ *
+ * Same convention as v1 (separator `" - "`, quotes optional), where the prefix
+ * named a `Maintenance_Source`; in v2 it names the machine. Unlike v1 the
+ * prefix is *removed* from the title — the machine is a field of its own here,
+ * and repeating it in the title is what made v1's plan lists unreadable.
+ */
+export declare function parseSubject(subject: string | undefined): {
+    equipmentName?: string;
+    title: string;
+};
+/**
+ * Put the sync's rule into a plan's rule list, replacing an older one of its
+ * own and leaving every user-written rule untouched.
+ */
+export declare function mergeReminderRule(existing: ServiceNotificationRule[] | undefined, rule: ServiceNotificationRule | undefined): ServiceNotificationRule[];

package/dist/features/openservice/serviceSchedules/calendarSync/functions/eventToPlan.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OUTLOOK_REMINDER_RULE_ID = void 0;
+exports.eventToPlanFields = eventToPlanFields;
+exports.parseSubject = parseSubject;
+exports.mergeReminderRule = mergeReminderRule;
+const outlookRecurrence_js_1 = require("./outlookRecurrence.js");
+/**
+ * The rule id the sync owns.
+ *
+ * An Outlook reminder becomes one notification rule on the plan, and it always
+ * gets **this** id: the sync may replace or remove its own rule on every
+ * inbound change, and must never touch the rules a user wrote in the plan
+ * editor. A stable id also keeps the scheduler's dedup key
+ * (`{scheduleId, ruleId, occurrence}`) stable, so re-syncing an unchanged event
+ * does not notify twice.
+ */
+exports.OUTLOOK_REMINDER_RULE_ID = "outlook-reminder";
+/**
+ * Read a calendar event as maintenance plan fields.
+ *
+ * Pure — resolving the machine and writing the plan is the poller's job.
+ * Returns `undefined` for an event without a usable start, which is the one
+ * thing a plan cannot do without.
+ */
+function eventToPlanFields(event) {
+    const start = eventStart(event);
+    if (!start)
+        return undefined;
+    const { equipmentName, title } = parseSubject(event.subject);
+    return {
+        title: title || "Outlook",
+        equipmentName,
+        cadence: (0, outlookRecurrence_js_1.eventToCadence)(start, event.recurrence ?? undefined),
+        description: event.bodyPreview?.trim() || undefined,
+        notification: reminderToRule(event),
+    };
+}
+/**
+ * The start of the series as an absolute instant.
+ *
+ * Graph returns `dateTime` in the time zone named next to it, and this server
+ * asks for none — so in practice it is UTC and the time of day survives, which
+ * matters because the plan's `dtstart` is what the frontend shows. If the event
+ * ever arrives in another zone, the day is kept and the time falls back to
+ * midnight rather than being shifted by a guess.
+ */
+function eventStart(event) {
+    const raw = event.start?.dateTime;
+    if (!raw)
+        return undefined;
+    const zone = event.start?.timeZone;
+    if (!zone || /^utc$/i.test(zone)) {
+        // Graph omits the offset; the trailing fraction can be 7 digits long.
+        const normalized = raw.endsWith("Z") ? raw : `${raw.slice(0, 23)}Z`;
+        const parsed = new Date(normalized);
+        if (!Number.isNaN(parsed.getTime()))
+            return parsed;
+    }
+    const dateOnly = new Date(`${raw.slice(0, 10)}T00:00:00.000Z`);
+    return Number.isNaN(dateOnly.getTime()) ? undefined : dateOnly;
+}
+/**
+ * Split `"Flex 1" - Ölwechsel` into machine and title.
+ *
+ * Same convention as v1 (separator `" - "`, quotes optional), where the prefix
+ * named a `Maintenance_Source`; in v2 it names the machine. Unlike v1 the
+ * prefix is *removed* from the title — the machine is a field of its own here,
+ * and repeating it in the title is what made v1's plan lists unreadable.
+ */
+function parseSubject(subject) {
+    const value = (subject ?? "").trim();
+    const separator = value.indexOf(" - ");
+    if (separator === -1)
+        return { title: value };
+    const prefix = value
+        .slice(0, separator)
+        .trim()
+        .replace(/^"(.*)"$/, "$1")
+        .trim();
+    const rest = value.slice(separator + 3).trim();
+    if (!prefix || !rest)
+        return { title: value };
+    return { equipmentName: prefix, title: rest };
+}
+/**
+ * An Outlook reminder as a notification rule.
+ *
+ * Outlook counts minutes, a plan counts days — a maintenance date is a day, not
+ * a minute. Anything under a day therefore becomes "on the due date" instead of
+ * being rounded up to a day early.
+ */
+function reminderToRule(event) {
+    if (!event.isReminderOn)
+        return undefined;
+    const minutes = event.reminderMinutesBeforeStart;
+    if (typeof minutes !== "number" || minutes < 0)
+        return undefined;
+    const offsetDays = Math.floor(minutes / (60 * 24));
+    return {
+        id: exports.OUTLOOK_REMINDER_RULE_ID,
+        trigger: offsetDays > 0 ? "before" : "due",
+        ...(offsetDays > 0 ? { offsetDays } : {}),
+        assignedRoles: true,
+        serviceProviders: true,
+    };
+}
+/**
+ * Put the sync's rule into a plan's rule list, replacing an older one of its
+ * own and leaving every user-written rule untouched.
+ */
+function mergeReminderRule(existing, rule) {
+    const others = (existing ?? []).filter((entry) => entry.id !== exports.OUTLOOK_REMINDER_RULE_ID);
+    return rule ? [...others, rule] : others;
+}

package/dist/features/openservice/serviceSchedules/calendarSync/functions/outlookRecurrence.d.ts

@@ -0,0 +1,39 @@
+import type { Recurrence } from "../../../schedules/calendarSync/types/Event.js";
+import type { ServiceCadence } from "../types/ServiceSyncTypes.js";
+/** A recurrence rule taken apart into its parts. */
+export type RRuleParts = {
+    freq?: "DAILY" | "WEEKLY" | "MONTHLY" | "YEARLY";
+    interval?: number;
+    byday?: string[];
+    bymonthday?: number[];
+    bymonth?: number[];
+    count?: number;
+    wkst?: string;
+};
+/**
+ * Read an RRULE string into its parts.
+ *
+ * Tolerant on purpose: an unknown key is dropped rather than throwing, because
+ * a rule that came from Outlook, from the editor, or from a hand-written import
+ * all end up here, and a single unexpected part must not stop a sync.
+ */
+export declare function parseRRule(rrule: string | undefined): RRuleParts;
+/** Write the parts back into an RRULE string, in the canonical part order. */
+export declare function buildRRule(parts: RRuleParts): string;
+/**
+ * An Outlook event's timing, as a v2 cadence.
+ *
+ * A non-recurring event becomes a one-off — the same shape the frontend's
+ * `oneOffCadence()` produces (`FREQ=DAILY;INTERVAL=1;COUNT=1`), so a plan
+ * created from a single Outlook appointment is indistinguishable from one
+ * created by hand.
+ */
+export declare function eventToCadence(start: Date, recurrence?: Recurrence): ServiceCadence;
+/**
+ * A v2 cadence as an Outlook recurrence — `undefined` for a one-off, which
+ * Graph expects as an event without a `recurrence` at all.
+ *
+ * `startDate` of the range is always the series start: Graph rejects a
+ * recurrence whose range starts on a different day than the event.
+ */
+export declare function cadenceToRecurrence(cadence: ServiceCadence | undefined, start: Date): Recurrence | undefined;

package/dist/features/openservice/serviceSchedules/calendarSync/functions/outlookRecurrence.js

@@ -0,0 +1,310 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRRule = parseRRule;
+exports.buildRRule = buildRRule;
+exports.eventToCadence = eventToCadence;
+exports.cadenceToRecurrence = cadenceToRecurrence;
+/**
+ * Outlook recurrence ↔ RRULE, both directions.
+ *
+ * **Why this module exists.** v1 stored a recurrence as `{number, unit}` — every
+ * Outlook pattern had to be flattened into "every n days/weeks/months", and
+ * anything else ("last Friday of the month") silently became something else. v2
+ * stores an RFC 5545 rule, which is the same language Outlook's patterns are a
+ * subset of, so the mapping can be lossless in both directions.
+ *
+ * Everything here is **pure** — no Parse, no Graph client — because a wrong
+ * mapping is the one bug in a calendar sync you cannot see until someone misses
+ * a maintenance date. `pnpm tsx scripts/…` round-trips it (see the module test
+ * at the bottom of the file's docs in OPENSERVICE_V2_SCHEDULES.md).
+ *
+ * **Known asymmetry**: the plan editor's cadence UI understands
+ * FREQ/INTERVAL/BYDAY/BYMONTHDAY/COUNT, but not `BYMONTH` or a positional
+ * `BYDAY` (`+2TU`). Occurrence *maths* and the calendar are correct for those
+ * (`@opendash/schedule` uses a full RRULE iterator) — but a user who edits such
+ * a plan's recurrence in the browser will simplify it. Yearly and "nth weekday"
+ * series should therefore be maintained in Outlook.
+ */
+const WEEKDAY_TO_RRULE = {
+    Sunday: "SU",
+    Monday: "MO",
+    Tuesday: "TU",
+    Wednesday: "WE",
+    Thursday: "TH",
+    Friday: "FR",
+    Saturday: "SA",
+};
+const RRULE_TO_WEEKDAY = {
+    SU: "Sunday",
+    MO: "Monday",
+    TU: "Tuesday",
+    WE: "Wednesday",
+    TH: "Thursday",
+    FR: "Friday",
+    SA: "Saturday",
+};
+/** Outlook's `index` ↔ the RRULE ordinal prefix of a `BYDAY` entry. */
+const INDEX_TO_ORDINAL = {
+    first: 1,
+    second: 2,
+    third: 3,
+    fourth: 4,
+    last: -1,
+};
+const ORDINAL_TO_INDEX = {
+    1: "first",
+    2: "second",
+    3: "third",
+    4: "fourth",
+    [-1]: "last",
+};
+/**
+ * Read an RRULE string into its parts.
+ *
+ * Tolerant on purpose: an unknown key is dropped rather than throwing, because
+ * a rule that came from Outlook, from the editor, or from a hand-written import
+ * all end up here, and a single unexpected part must not stop a sync.
+ */
+function parseRRule(rrule) {
+    const parts = {};
+    if (!rrule)
+        return parts;
+    for (const chunk of rrule.replace(/^RRULE:/i, "").split(";")) {
+        const [rawKey, rawValue] = chunk.split("=");
+        if (!rawKey || !rawValue)
+            continue;
+        const key = rawKey.trim().toUpperCase();
+        const value = rawValue.trim().toUpperCase();
+        switch (key) {
+            case "FREQ":
+                if (value === "DAILY" ||
+                    value === "WEEKLY" ||
+                    value === "MONTHLY" ||
+                    value === "YEARLY") {
+                    parts.freq = value;
+                }
+                break;
+            case "INTERVAL":
+                parts.interval = toPositiveInt(value);
+                break;
+            case "COUNT":
+                parts.count = toPositiveInt(value);
+                break;
+            case "BYDAY":
+                parts.byday = value.split(",").filter(Boolean);
+                break;
+            case "BYMONTHDAY":
+                parts.bymonthday = value.split(",").map(Number).filter(Number.isFinite);
+                break;
+            case "BYMONTH":
+                parts.bymonth = value.split(",").map(Number).filter(Number.isFinite);
+                break;
+            case "WKST":
+                parts.wkst = value;
+                break;
+        }
+    }
+    return parts;
+}
+/** Write the parts back into an RRULE string, in the canonical part order. */
+function buildRRule(parts) {
+    const chunks = [`FREQ=${parts.freq ?? "DAILY"}`];
+    if (parts.interval && parts.interval > 1) {
+        chunks.push(`INTERVAL=${parts.interval}`);
+    }
+    if (parts.byday?.length)
+        chunks.push(`BYDAY=${parts.byday.join(",")}`);
+    if (parts.bymonthday?.length) {
+        chunks.push(`BYMONTHDAY=${parts.bymonthday.join(",")}`);
+    }
+    if (parts.bymonth?.length)
+        chunks.push(`BYMONTH=${parts.bymonth.join(",")}`);
+    if (parts.count)
+        chunks.push(`COUNT=${parts.count}`);
+    if (parts.wkst && parts.wkst !== "MO")
+        chunks.push(`WKST=${parts.wkst}`);
+    return chunks.join(";");
+}
+/**
+ * An Outlook event's timing, as a v2 cadence.
+ *
+ * A non-recurring event becomes a one-off — the same shape the frontend's
+ * `oneOffCadence()` produces (`FREQ=DAILY;INTERVAL=1;COUNT=1`), so a plan
+ * created from a single Outlook appointment is indistinguishable from one
+ * created by hand.
+ */
+function eventToCadence(start, recurrence) {
+    const dtstart = start.toISOString();
+    if (!recurrence?.pattern) {
+        return { kind: "rrule", rrule: "FREQ=DAILY;INTERVAL=1;COUNT=1", dtstart };
+    }
+    const { pattern, range } = recurrence;
+    const parts = { interval: pattern.interval };
+    switch (pattern.type) {
+        case "daily":
+            parts.freq = "DAILY";
+            break;
+        case "weekly":
+            parts.freq = "WEEKLY";
+            parts.byday = (pattern.daysOfWeek ?? [])
+                .map((day) => WEEKDAY_TO_RRULE[day])
+                .filter(Boolean);
+            if (pattern.firstDayOfWeek) {
+                parts.wkst = WEEKDAY_TO_RRULE[pattern.firstDayOfWeek];
+            }
+            break;
+        case "absoluteMonthly":
+            parts.freq = "MONTHLY";
+            parts.bymonthday = [pattern.dayOfMonth ?? start.getUTCDate()];
+            break;
+        case "relativeMonthly":
+            parts.freq = "MONTHLY";
+            parts.byday = positionalByDay(pattern);
+            break;
+        case "absoluteYearly":
+            parts.freq = "YEARLY";
+            parts.bymonth = [pattern.month ?? start.getUTCMonth() + 1];
+            parts.bymonthday = [pattern.dayOfMonth ?? start.getUTCDate()];
+            break;
+        case "relativeYearly":
+            parts.freq = "YEARLY";
+            parts.bymonth = [pattern.month ?? start.getUTCMonth() + 1];
+            parts.byday = positionalByDay(pattern);
+            break;
+    }
+    // A weekly series with no explicit days repeats on the start's weekday.
+    if (parts.freq === "WEEKLY" && !parts.byday?.length) {
+        parts.byday = [rruleWeekday(start)];
+    }
+    const cadence = {
+        kind: "rrule",
+        rrule: buildRRule(parts),
+        dtstart,
+    };
+    if (range?.type === "numbered") {
+        cadence.rrule = buildRRule({
+            ...parts,
+            count: range.numberOfOccurrences,
+        });
+    }
+    else if (range?.type === "endDate" && range.endDate) {
+        // Outlook's end date is a plain day and inclusive — the series may still
+        // occur on it, so the boundary is the end of that day.
+        cadence.until = endOfDay(range.endDate).toISOString();
+    }
+    return cadence;
+}
+/**
+ * A v2 cadence as an Outlook recurrence — `undefined` for a one-off, which
+ * Graph expects as an event without a `recurrence` at all.
+ *
+ * `startDate` of the range is always the series start: Graph rejects a
+ * recurrence whose range starts on a different day than the event.
+ */
+function cadenceToRecurrence(cadence, start) {
+    if (cadence?.kind !== "rrule" || !cadence.rrule)
+        return undefined;
+    const parts = parseRRule(cadence.rrule);
+    // One occurrence is not a series — and Outlook has no way to say "once".
+    if (parts.count === 1)
+        return undefined;
+    const pattern = recurrencePattern(parts, start);
+    if (!pattern)
+        return undefined;
+    return { pattern, range: recurrenceRange(parts, cadence, start) };
+}
+function recurrencePattern(parts, start) {
+    const interval = parts.interval && parts.interval > 0 ? parts.interval : 1;
+    const positional = parts.byday?.map(splitByDay).find((day) => !!day.ordinal);
+    switch (parts.freq ?? "DAILY") {
+        case "DAILY":
+            return { type: "daily", interval };
+        case "WEEKLY": {
+            const daysOfWeek = (parts.byday ?? [])
+                .map((entry) => RRULE_TO_WEEKDAY[splitByDay(entry).weekday])
+                .filter(Boolean);
+            return {
+                type: "weekly",
+                interval,
+                daysOfWeek: daysOfWeek.length
+                    ? daysOfWeek
+                    : [RRULE_TO_WEEKDAY[rruleWeekday(start)]],
+                firstDayOfWeek: RRULE_TO_WEEKDAY[parts.wkst ?? "MO"] ?? "Monday",
+            };
+        }
+        case "MONTHLY":
+            if (positional) {
+                return {
+                    type: "relativeMonthly",
+                    interval,
+                    daysOfWeek: [RRULE_TO_WEEKDAY[positional.weekday]],
+                    index: ORDINAL_TO_INDEX[positional.ordinal] ?? "first",
+                };
+            }
+            return {
+                type: "absoluteMonthly",
+                interval,
+                dayOfMonth: parts.bymonthday?.[0] ?? start.getUTCDate(),
+            };
+        case "YEARLY": {
+            const month = parts.bymonth?.[0] ?? start.getUTCMonth() + 1;
+            if (positional) {
+                return {
+                    type: "relativeYearly",
+                    interval,
+                    month,
+                    daysOfWeek: [RRULE_TO_WEEKDAY[positional.weekday]],
+                    index: ORDINAL_TO_INDEX[positional.ordinal] ?? "first",
+                };
+            }
+            return {
+                type: "absoluteYearly",
+                interval,
+                month,
+                dayOfMonth: parts.bymonthday?.[0] ?? start.getUTCDate(),
+            };
+        }
+    }
+    return undefined;
+}
+function recurrenceRange(parts, cadence, start) {
+    const startDate = graphDate(start);
+    if (parts.count && parts.count > 1) {
+        return { type: "numbered", startDate, numberOfOccurrences: parts.count };
+    }
+    if (cadence.until) {
+        return { type: "endDate", startDate, endDate: graphDate(cadence.until) };
+    }
+    return { type: "noEnd", startDate };
+}
+/** `["+2TU"]` for "second Tuesday" — the RRULE spelling of Outlook's `index`. */
+function positionalByDay(pattern) {
+    const weekday = WEEKDAY_TO_RRULE[pattern.daysOfWeek?.[0] ?? "Monday"];
+    const ordinal = INDEX_TO_ORDINAL[pattern.index ?? "first"] ?? 1;
+    return [`${ordinal > 0 ? "+" : ""}${ordinal}${weekday}`];
+}
+/** `"+2TU"` → `{ ordinal: 2, weekday: "TU" }`, `"TU"` → `{ weekday: "TU" }`. */
+function splitByDay(entry) {
+    const match = /^([+-]?\d+)?([A-Z]{2})$/.exec(entry.trim().toUpperCase());
+    if (!match)
+        return { weekday: "MO" };
+    return {
+        ordinal: match[1] ? Number(match[1]) : undefined,
+        weekday: match[2],
+    };
+}
+function rruleWeekday(date) {
+    return ["SU", "MO", "TU", "WE", "TH", "FR", "SA"][date.getUTCDay()];
+}
+/** Graph wants a plain `YYYY-MM-DD` in a recurrence range. */
+function graphDate(value) {
+    const date = value instanceof Date ? value : new Date(value);
+    return date.toISOString().slice(0, 10);
+}
+function endOfDay(day) {
+    return new Date(`${day.slice(0, 10)}T23:59:59.999Z`);
+}
+function toPositiveInt(value) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}

package/dist/features/openservice/serviceSchedules/calendarSync/functions/planToEvent.d.ts

@@ -0,0 +1,27 @@
+import type { GraphEvent } from "../../../schedules/calendarSync/types/Event.js";
+import type { ServiceCalendarEventSnapshot } from "../service/serviceCalendarMeta.js";
+import type { ServiceCadence, ServiceNotificationRule } from "../types/ServiceSyncTypes.js";
+/** A step of the plan, as far as the calendar entry shows it. */
+type PlanStep = {
+    order?: number;
+    title?: string;
+};
+export type PlanEventInput = {
+    title?: string;
+    cadence?: ServiceCadence;
+    steps?: PlanStep[];
+    notifications?: ServiceNotificationRule[];
+    /** Machine name — becomes the subject prefix. */
+    equipmentName?: string;
+    /** The event as it currently stands in Outlook, if it exists already. */
+    snapshot?: ServiceCalendarEventSnapshot;
+};
+/**
+ * A maintenance plan as a calendar event.
+ *
+ * Returns `undefined` for a plan that has no date to put in a calendar — a
+ * manual, sensor- or meter-driven plan has no due date until something happens,
+ * and inventing one would show maintenance that nobody scheduled.
+ */
+export declare function planToEvent(plan: PlanEventInput): GraphEvent | undefined;
+export {};