@openinc/parse-server-opendash 4.1.8 → 4.2.1

package/dist/functions/openinc-openservice-alarm-create-ticket.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Raise an open.SERVICE ticket for a fired alarm.
+ *
+ * The receiving end of the `openservice-create-ticket` alarm action: an alarm
+ * watches a sensor, the rule breaks, and whatever executes alarm actions calls
+ * this with the alarm's data and the settings someone filled into the action's
+ * form.
+ *
+ * **Authentication** — one of:
+ *
+ * - the **master key** (server-to-server inside the stack), then `tenantId`
+ *   must be given;
+ * - a **shared secret** matching an `OPENSERVICE_ALARM_TICKET_SECRET` config
+ *   row, which also establishes the tenant. An external executor is not
+ *   trusted to name a tenant, so the secret does it.
+ *
+ * A logged-in user is deliberately *not* enough: this is a machine endpoint,
+ * and a browser session should not be able to fabricate alarm tickets.
+ *
+ * Params: `{ event, params?, secret?, tenantId? }`.
+ * Returns `{ ticketId, created, origin, equipmentId? }` — `created: false`
+ * means an open ticket for this alarm already existed (see
+ * `createAlarmTicket`).
+ */
+export declare function init(name: string): Promise<void>;

package/dist/functions/openinc-openservice-alarm-create-ticket.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+const node_1 = __importDefault(require("parse/node"));
+const index_js_1 = require("../features/openservice/serviceTickets/alarmActions/index.js");
+const index_js_2 = require("../types/index.js");
+/**
+ * Raise an open.SERVICE ticket for a fired alarm.
+ *
+ * The receiving end of the `openservice-create-ticket` alarm action: an alarm
+ * watches a sensor, the rule breaks, and whatever executes alarm actions calls
+ * this with the alarm's data and the settings someone filled into the action's
+ * form.
+ *
+ * **Authentication** — one of:
+ *
+ * - the **master key** (server-to-server inside the stack), then `tenantId`
+ *   must be given;
+ * - a **shared secret** matching an `OPENSERVICE_ALARM_TICKET_SECRET` config
+ *   row, which also establishes the tenant. An external executor is not
+ *   trusted to name a tenant, so the secret does it.
+ *
+ * A logged-in user is deliberately *not* enough: this is a machine endpoint,
+ * and a browser session should not be able to fabricate alarm tickets.
+ *
+ * Params: `{ event, params?, secret?, tenantId? }`.
+ * Returns `{ ticketId, created, origin, equipmentId? }` — `created: false`
+ * means an open ticket for this alarm already existed (see
+ * `createAlarmTicket`).
+ */
+async function init(name) {
+    node_1.default.Cloud.define(name, async (request) => {
+        const { event, params, secret, tenantId } = request.params;
+        if (!event || typeof event !== "object") {
+            throw new node_1.default.Error(node_1.default.Error.INVALID_QUERY, `${name} needs an "event" object describing the alarm`);
+        }
+        const tenant = request.master
+            ? await tenantById(tenantId)
+            : await (0, index_js_1.tenantForSecret)(typeof secret === "string" ? secret : "");
+        if (!tenant) {
+            // Same answer for "wrong secret" and "no such tenant": a caller
+            // guessing secrets learns nothing from the difference.
+            throw new node_1.default.Error(node_1.default.Error.OPERATION_FORBIDDEN, `${name}: unknown tenant or invalid secret`);
+        }
+        const result = await (0, index_js_1.createAlarmTicket)(tenant, event, params ?? {});
+        console.log(`[${name}] ${result.created ? "created" : "reused"} ticket ` +
+            `${result.ticketId} for ${result.origin}` +
+            (result.equipmentId ? ` (machine ${result.equipmentId})` : ""));
+        return result;
+    }, 
+    // No `requireUser`: the callers are machines, authenticated above.
+    {});
+}
+async function tenantById(tenantId) {
+    if (!tenantId)
+        return undefined;
+    return ((await new node_1.default.Query(index_js_2.Tenant)
+        .equalTo("objectId", tenantId)
+        .first({ useMasterKey: true })) ?? undefined);
+}

package/dist/functions/openinc-openservice-notify-contacts.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Mail the external contacts of a maintenance notification rule.
+ *
+ * **Why this lives here.** The scheduler evaluates the plans' notification
+ * rules (`OD3_Service_Schedule.notifications`), but it has no mail transport —
+ * that belongs to this server, which owns `Core_Email` and the SMTP config.
+ * Users are reached through `OD3_Notification` (the hook there sends mail and
+ * web push); contacts have no account, so they are reached directly.
+ *
+ * **Master key only.** A browser session must not be able to mail arbitrary
+ * contacts with arbitrary text.
+ *
+ * Params: `contactIds`, `subject`, `body`, plus `scheduleId` / `ruleId` /
+ * `occurrence` for the log line. Returns `{ sent, skipped, withoutEmail }`.
+ */
+export declare function init(name: string): Promise<void>;

package/dist/functions/openinc-openservice-notify-contacts.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+const node_1 = __importDefault(require("parse/node"));
+const index_js_1 = require("../features/notifications/index.js");
+const index_js_2 = require("../types/index.js");
+/** How far back a duplicate is looked for (see `alreadySent`). */
+const DEDUP_WINDOW_DAYS = 30;
+/**
+ * Mail the external contacts of a maintenance notification rule.
+ *
+ * **Why this lives here.** The scheduler evaluates the plans' notification
+ * rules (`OD3_Service_Schedule.notifications`), but it has no mail transport —
+ * that belongs to this server, which owns `Core_Email` and the SMTP config.
+ * Users are reached through `OD3_Notification` (the hook there sends mail and
+ * web push); contacts have no account, so they are reached directly.
+ *
+ * **Master key only.** A browser session must not be able to mail arbitrary
+ * contacts with arbitrary text.
+ *
+ * Params: `contactIds`, `subject`, `body`, plus `scheduleId` / `ruleId` /
+ * `occurrence` for the log line. Returns `{ sent, skipped, withoutEmail }`.
+ */
+async function init(name) {
+    node_1.default.Cloud.define(name, async (request) => {
+        if (!request.master) {
+            throw new node_1.default.Error(node_1.default.Error.OPERATION_FORBIDDEN, `${name} requires the master key`);
+        }
+        const { contactIds, subject, body, scheduleId, ruleId, occurrence } = request.params;
+        if (!contactIds?.length || !subject || !body) {
+            throw new node_1.default.Error(node_1.default.Error.INVALID_QUERY, `${name} needs contactIds, subject and body`);
+        }
+        const contacts = await new node_1.default.Query(index_js_2.Contact)
+            .containedIn("objectId", contactIds)
+            .find({ useMasterKey: true });
+        let sent = 0;
+        let skipped = 0;
+        let withoutEmail = 0;
+        for (const contact of contacts) {
+            const to = contact.get("email");
+            if (!to) {
+                withoutEmail++;
+                continue;
+            }
+            if (await alreadySent(to, body)) {
+                skipped++;
+                continue;
+            }
+            await (0, index_js_1.sendSimpleEmail)(to, subject, body);
+            sent++;
+        }
+        console.log(`[${name}] plan ${scheduleId} rule ${ruleId} occurrence ${occurrence}: ` +
+            `sent ${sent}, skipped ${skipped}, without email ${withoutEmail}`);
+        return { sent, skipped, withoutEmail };
+    }, 
+    // No `requireUser`: this is a machine-to-machine call from the scheduler.
+    {});
+}
+/**
+ * Whether this exact message already went to this address recently.
+ *
+ * The idempotency key is the **message body**, because it already identifies
+ * the occurrence (it carries plan, description and the due date) and because
+ * `Core_Email` has no free column to put a marker in. That makes a restart
+ * inside the same tick harmless, while a genuinely different occurrence — a
+ * different date in the text — still goes out.
+ */
+async function alreadySent(to, body) {
+    const since = new Date(Date.now() - DEDUP_WINDOW_DAYS * 24 * 3600 * 1000);
+    // Dot access into the `payload` Object column: Mongo resolves it, but the
+    // generated class type only knows top-level columns — hence the untyped
+    // query handle.
+    const query = new node_1.default.Query(index_js_2.Core_Email);
+    query.equalTo("payload.to", to);
+    query.equalTo("payload.text", body);
+    query.greaterThan("createdAt", since);
+    const existing = await query.first({ useMasterKey: true });
+    return !!existing;
+}

package/dist/functions/openinc-openservice-schedule-calendar-sync.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Push maintenance plans into the tenant's Outlook calendar, on request.
+ *
+ * Normally nobody needs this: saving a plan syncs it (the `Service_Schedule`
+ * afterSave hook). It exists for the plans that already existed when a tenant
+ * switched the calendar connection on — they have never been written to the
+ * calendar, and nothing about them is going to change just to trigger it.
+ *
+ * **Authorization is the plan's own ACL**: the plans are loaded with the
+ * caller's session token, so this can only sync what the caller may read. A
+ * plan they cannot see comes back as "not found", like everywhere else.
+ *
+ * Params: `scheduleIds`. Returns `{ synced, failed }`.
+ */
+export declare function init(name: string): Promise<void>;

package/dist/functions/openinc-openservice-schedule-calendar-sync.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+const node_1 = __importDefault(require("parse/node"));
+const index_js_1 = require("../features/openservice/serviceSchedules/calendarSync/index.js");
+const index_js_2 = require("../types/index.js");
+/** No more than this many plans per call — each one is a Graph round trip. */
+const MAX_PLANS = 50;
+/**
+ * Push maintenance plans into the tenant's Outlook calendar, on request.
+ *
+ * Normally nobody needs this: saving a plan syncs it (the `Service_Schedule`
+ * afterSave hook). It exists for the plans that already existed when a tenant
+ * switched the calendar connection on — they have never been written to the
+ * calendar, and nothing about them is going to change just to trigger it.
+ *
+ * **Authorization is the plan's own ACL**: the plans are loaded with the
+ * caller's session token, so this can only sync what the caller may read. A
+ * plan they cannot see comes back as "not found", like everywhere else.
+ *
+ * Params: `scheduleIds`. Returns `{ synced, failed }`.
+ */
+async function init(name) {
+    node_1.default.Cloud.define(name, async (request) => {
+        const { scheduleIds } = request.params;
+        if (!Array.isArray(scheduleIds) || scheduleIds.length === 0) {
+            throw new node_1.default.Error(node_1.default.Error.INVALID_QUERY, `${name} needs scheduleIds`);
+        }
+        if (scheduleIds.length > MAX_PLANS) {
+            throw new node_1.default.Error(node_1.default.Error.INVALID_QUERY, `${name} accepts at most ${MAX_PLANS} plans per call`);
+        }
+        const plans = await new node_1.default.Query(index_js_2.Service_Schedule)
+            .containedIn("objectId", scheduleIds)
+            .include("equipment")
+            .limit(MAX_PLANS)
+            .find({ sessionToken: request.user?.getSessionToken() ?? undefined });
+        let synced = 0;
+        const failed = [];
+        for (const plan of plans) {
+            try {
+                // Master key from here on: writing the calendar and the meta entry is
+                // the server's business, not something the caller needs rights for.
+                await (0, index_js_1.syncPlanToCalendar)(plan);
+                synced++;
+            }
+            catch (error) {
+                console.error(`[${name}] Plan ${plan.id} failed:`, error);
+                failed.push(plan.id);
+            }
+        }
+        return {
+            synced,
+            failed,
+            notFound: scheduleIds.filter((id) => !plans.some((plan) => plan.id === id)),
+        };
+    }, { requireUser: true });
+}

package/dist/hooks/Service_Schedule.js

@@ -6,27 +6,71 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.init = init;
 const node_1 = __importDefault(require("parse/node"));
 const index_js_1 = require("../features/schema/index.js");
-const index_js_2 = require("../types/index.js");
+const Permissions_js_1 = require("../features/permissions/types/Permissions.js");
+const index_js_2 = require("../features/permissions/index.js");
+const index_js_3 = require("../features/openservice/serviceSchedules/acl/index.js");
+const index_js_4 = require("../features/openservice/serviceSchedules/calendarSync/index.js");
+const index_js_5 = require("../types/index.js");
 async function init() {
-    (0, index_js_1.beforeSaveHook)(index_js_2.Service_Schedule, async (request) => {
+    (0, index_js_1.beforeSaveHook)(index_js_5.Service_Schedule, async (request) => {
         const { object, original, user } = request;
         await (0, index_js_1.defaultHandler)(request);
-        // `allowCustomACL` keeps an ACL set by the client instead of resetting it on
-        // every save. The frontend uses it for the per-record write lock ("Rechte
-        // nur für Ersteller", `openservice-schedule/utils/acl.ts`): the creator gets
-        // an explicit user grant, everyone else keeps read only. The handler still
-        // re-adds `od-admin` / `od-tenant-admin-<tenant>` write and
-        // `od-tenant-user-<tenant>` read afterwards, so a lock can never lock
-        // administrators out.
-        await (0, index_js_1.defaultAclHandler)(request, { allowCustomACL: true });
-        // TODO
+        // The creator, recorded once and never rewritten: it is who the plan
+        // belongs to, and `defaultAclHandler` turns it into a read+write grant.
+        if (!original && user && !object.get("user")) {
+            object.set("user", user);
+        }
+        // `denyTenantUserRead` is what makes a plan private. Without it every user
+        // of the tenant reads every plan, which is the opposite of what assigning
+        // roles and users to a plan is supposed to mean.
+        //
+        // `allowCustomACL` keeps an ACL the client set instead of resetting it on
+        // every save — the assignment sync in `afterSave` depends on its ACL
+        // surviving the next save. The handler still re-adds `od-admin` /
+        // `od-tenant-admin-<tenant>`, so a plan can never lock administrators out.
+        await (0, index_js_1.defaultAclHandler)(request, {
+            allowCustomACL: true,
+            denyTenantUserRead: true,
+        });
     });
-    (0, index_js_1.afterSaveHook)(index_js_2.Service_Schedule, async (request) => {
-        const { object, original, user } = request;
-        // TODO
+    (0, index_js_1.afterSaveHook)(index_js_5.Service_Schedule, async (request) => {
+        const { object, original, context } = request;
+        // Our own ACL write — the assignments already match, nothing to redo.
+        if (context?.[index_js_3.ASSIGNMENT_ACL_CONTEXT_FLAG])
+            return;
+        // Assignments are relations: only readable now that the save applied them.
+        await (0, index_js_3.syncAssignmentAcl)(object, {
+            roleRelations: ["assignedRoles", "escalationRoles"],
+            userRelations: ["assignedUsers"],
+        }).catch((error) => {
+            console.error(`[ServiceScheduleAcl] Plan ${object.id}: could not sync ACL from assignments:`, error);
+        });
+        // A change that came *from* the calendar must not be written back to it:
+        // that would create a new version there, which the delta feed reports as a
+        // foreign change, which we would import again — an endless echo. The
+        // poller marks its own writes with this flag.
+        if (context?.[index_js_4.CALENDAR_SYNC_CONTEXT_FLAG])
+            return;
+        // Seed data belongs to a demo tenant, not in anybody's calendar.
+        if (object.get("seed"))
+            return;
+        if (!original || calendarRelevantChange(object, original)) {
+            // Deliberately not awaited: the calendar is a downstream system, and a
+            // Graph round trip (token + write) would otherwise be part of every save
+            // the user waits for. Failures are logged, and the next relevant save
+            // retries — as does the delta poller from the other side.
+            (0, index_js_4.syncPlanToCalendar)(object).catch((error) => {
+                console.error(`[ServiceCalendarSync] Plan ${object.id} could not be synced:`, error);
+            });
+        }
     });
-    (0, index_js_1.beforeDeleteHook)(index_js_2.Service_Schedule, async (request) => {
+    (0, index_js_1.beforeDeleteHook)(index_js_5.Service_Schedule, async (request) => {
         const { object } = request;
+        // Parse has no delete right of its own — an ACL `write` grant covers update
+        // *and* delete, so anyone allowed to edit a plan could otherwise remove it.
+        // Hiding the button in the UI does not change that; this is what makes the
+        // capability real.
+        await (0, index_js_2.requirePermission)(request, Permissions_js_1.Permissions.SERVICE.schedule_delete, "delete maintenance schedule");
         // A protocol points at the plan it documents. Destroying the plan leaves
         // that pointer dangling and the protocol — the record that the work
         // happened — unreachable. Retiring a plan is done by setting `deletedAt`
@@ -35,7 +79,7 @@ async function init() {
         //
         // A plan without any execution carries no history, so removing it stays
         // allowed — that keeps mistakenly created plans cleanable.
-        const executions = await new node_1.default.Query(index_js_2.Service_Schedule_Execution)
+        const executions = await new node_1.default.Query(index_js_5.Service_Schedule_Execution)
             .equalTo("schedule", object)
             .count({ useMasterKey: true });
         if (executions > 0) {
@@ -43,3 +87,32 @@ async function init() {
         }
     });
 }
+/**
+ * Whether a saved plan changed anything the calendar shows.
+ *
+ * Plans are saved for many reasons that mean nothing to Outlook (an execution
+ * counter, an ACL, a tag). Only these fields reach the appointment — and
+ * `active` / `deletedAt` because retiring a plan removes it from the calendar.
+ */
+function calendarRelevantChange(object, original) {
+    if (object.get("title") !== original.get("title") ||
+        object.get("active") !== original.get("active") ||
+        dateValue(object.get("deletedAt")) !== dateValue(original.get("deletedAt"))) {
+        return true;
+    }
+    const equipmentChanged = object.get("equipment")?.id !==
+        original.get("equipment")?.id;
+    if (equipmentChanged)
+        return true;
+    // JSON columns: compared by value, because a save always hands us new object
+    // identities even when nothing inside them moved.
+    return (!sameJson(object.get("cadence"), original.get("cadence")) ||
+        !sameJson(object.get("notifications"), original.get("notifications")) ||
+        !sameJson(object.get("steps"), original.get("steps")));
+}
+function dateValue(value) {
+    return value ? value.getTime() : undefined;
+}
+function sameJson(a, b) {
+    return JSON.stringify(a ?? null) === JSON.stringify(b ?? null);
+}

package/dist/hooks/Service_Schedule_Template.js

@@ -2,16 +2,37 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.init = init;
 const index_js_1 = require("../features/schema/index.js");
-const index_js_2 = require("../types/index.js");
+const index_js_2 = require("../features/openservice/serviceSchedules/acl/index.js");
+const index_js_3 = require("../types/index.js");
 async function init() {
-    (0, index_js_1.beforeSaveHook)(index_js_2.Service_Schedule_Template, async (request) => {
+    (0, index_js_1.beforeSaveHook)(index_js_3.Service_Schedule_Template, async (request) => {
         const { object, original, user } = request;
         await (0, index_js_1.defaultHandler)(request);
-        await (0, index_js_1.defaultAclHandler)(request);
-        // TODO
+        // The creator, recorded once and never rewritten — a template stays visible
+        // to whoever built it, whatever happens to its assigned roles later.
+        if (!original && user && !object.get("user")) {
+            object.set("user", user);
+        }
+        // A template is private like a plan: its creator, the roles it is assigned
+        // to, and administrators. Without `denyTenantUserRead` the whole tenant
+        // reads every template and assigning roles would mean nothing.
+        await (0, index_js_1.defaultAclHandler)(request, {
+            allowCustomACL: true,
+            denyTenantUserRead: true,
+        });
     });
-    (0, index_js_1.afterSaveHook)(index_js_2.Service_Schedule_Template, async (request) => {
-        const { object, original, user } = request;
-        // TODO
+    (0, index_js_1.afterSaveHook)(index_js_3.Service_Schedule_Template, async (request) => {
+        const { object, context } = request;
+        // Our own ACL write — the assignments already match.
+        if (context?.[index_js_2.ASSIGNMENT_ACL_CONTEXT_FLAG])
+            return;
+        // `assignedRoles` is a relation, readable only after the save applied it.
+        // Templates carry no `assignedUsers`: they are shared by role, and the
+        // creator keeps their own grant.
+        await (0, index_js_2.syncAssignmentAcl)(object, {
+            roleRelations: ["assignedRoles"],
+        }).catch((error) => {
+            console.error(`[ServiceScheduleAcl] Template ${object.id}: could not sync ACL from assignments:`, error);
+        });
     });
 }

package/dist/hooks/Service_Ticket.js

@@ -43,7 +43,7 @@ const index_js_1 = require("../features/schema/index.js");
 const appLinks_js_1 = require("../helper/appLinks.js");
 const getUserLanguage_js_1 = require("../helper/getUserLanguage.js");
 const index_js_2 = require("../types/index.js");
-const applyRuleSet_js_1 = require("../features/ruleset/applyRuleSet.js");
+const ruleset_core_1 = require("@opendash/ruleset-core");
 async function init() {
     // Soft delete: a ticket is referenced by chat messages, meta entries,
     // notifications and child tickets, so the frontend archives instead of
@@ -266,7 +266,7 @@ async function notifyWatchers(ticket, notified, assignerName) {
     for (const rule of rules) {
         if (rule.function !== "notify" || !rule.ruleset)
             continue;
-        if (!(0, applyRuleSet_js_1.applyRuleSet)(rule.ruleset, getValue))
+        if (!(0, ruleset_core_1.applyRuleSet)(rule.ruleset, getValue))
             continue;
         const assignees = Array.isArray(rule.params?.assignees)
             ? rule.params.assignees

package/dist/types/Service_Schedule.d.ts

@@ -1,5 +1,6 @@
 import Parse from "parse/node";
 import type { _Role } from "./_Role";
+import type { _User } from "./_User";
 import type { Service_Equipment } from "./Service_Equipment";
 import type { Tenant } from "./Tenant";
 export interface Service_ScheduleAttributes {
@@ -10,8 +11,10 @@ export interface Service_ScheduleAttributes {
     active: boolean;
     asset?: any | undefined;
     assignedRoles: Parse.Relation<Service_Schedule, _Role>;
+    assignedUsers: Parse.Relation<Service_Schedule, _User>;
     cadence: any;
     cadenceExceptions?: any[] | undefined;
+    color?: string | undefined;
     coversTasks: any[];
     deletedAt?: Date | undefined;
     equipment?: Service_Equipment | undefined;
@@ -19,12 +22,14 @@ export interface Service_ScheduleAttributes {
     escalationRoles: Parse.Relation<Service_Schedule, _Role>;
     graceDays?: number | undefined;
     leadDays?: number | undefined;
+    notifications: any[];
     pausedUntil?: Date | undefined;
     seed?: boolean | undefined;
     serviceProviders?: any[] | undefined;
     steps: any[];
     tenant: Tenant;
     title: string;
+    user?: _User | undefined;
 }
 export declare class Service_Schedule extends Parse.Object<Service_ScheduleAttributes> {
     static className: string;
@@ -34,10 +39,13 @@ export declare class Service_Schedule extends Parse.Object<Service_ScheduleAttri
     get asset(): any | undefined;
     set asset(value: any | undefined);
     get assignedRoles(): Parse.Relation<Service_Schedule, _Role>;
+    get assignedUsers(): Parse.Relation<Service_Schedule, _User>;
     get cadence(): any;
     set cadence(value: any);
     get cadenceExceptions(): any[] | undefined;
     set cadenceExceptions(value: any[] | undefined);
+    get color(): string | undefined;
+    set color(value: string | undefined);
     get coversTasks(): any[];
     set coversTasks(value: any[]);
     get deletedAt(): Date | undefined;
@@ -51,6 +59,8 @@ export declare class Service_Schedule extends Parse.Object<Service_ScheduleAttri
     set graceDays(value: number | undefined);
     get leadDays(): number | undefined;
     set leadDays(value: number | undefined);
+    get notifications(): any[];
+    set notifications(value: any[]);
     get pausedUntil(): Date | undefined;
     set pausedUntil(value: Date | undefined);
     get seed(): boolean | undefined;
@@ -63,4 +73,6 @@ export declare class Service_Schedule extends Parse.Object<Service_ScheduleAttri
     set tenant(value: Tenant);
     get title(): string;
     set title(value: string);
+    get user(): _User | undefined;
+    set user(value: _User | undefined);
 }

package/dist/types/Service_Schedule.js

@@ -25,6 +25,9 @@ class Service_Schedule extends node_1.default.Object {
     get assignedRoles() {
         return super.relation("assignedRoles");
     }
+    get assignedUsers() {
+        return super.relation("assignedUsers");
+    }
     get cadence() {
         return super.get("cadence");
     }
@@ -37,6 +40,12 @@ class Service_Schedule extends node_1.default.Object {
     set cadenceExceptions(value) {
         super.set("cadenceExceptions", value);
     }
+    get color() {
+        return super.get("color");
+    }
+    set color(value) {
+        super.set("color", value);
+    }
     get coversTasks() {
         return super.get("coversTasks");
     }
@@ -76,6 +85,12 @@ class Service_Schedule extends node_1.default.Object {
     set leadDays(value) {
         super.set("leadDays", value);
     }
+    get notifications() {
+        return super.get("notifications");
+    }
+    set notifications(value) {
+        super.set("notifications", value);
+    }
     get pausedUntil() {
         return super.get("pausedUntil");
     }
@@ -112,6 +127,12 @@ class Service_Schedule extends node_1.default.Object {
     set title(value) {
         super.set("title", value);
     }
+    get user() {
+        return super.get("user");
+    }
+    set user(value) {
+        super.set("user", value);
+    }
 }
 exports.Service_Schedule = Service_Schedule;
 node_1.default.Object.registerSubclass("OD3_Service_Schedule", Service_Schedule);

package/dist/types/Service_Schedule_Execution.d.ts

@@ -12,9 +12,10 @@ export interface Service_Schedule_ExecutionAttributes {
     coverageOrigin?: any | undefined;
     performedBy?: _User | undefined;
     schedule: Service_Schedule;
-    signature?: any | undefined;
+    signature?: string | undefined;
     stepResults?: any[] | undefined;
     tenant: Tenant;
+    user?: _User | undefined;
 }
 export declare class Service_Schedule_Execution extends Parse.Object<Service_Schedule_ExecutionAttributes> {
     static className: string;
@@ -29,10 +30,12 @@ export declare class Service_Schedule_Execution extends Parse.Object<Service_Sch
     set performedBy(value: _User | undefined);
     get schedule(): Service_Schedule;
     set schedule(value: Service_Schedule);
-    get signature(): any | undefined;
-    set signature(value: any | undefined);
+    get signature(): string | undefined;
+    set signature(value: string | undefined);
     get stepResults(): any[] | undefined;
     set stepResults(value: any[] | undefined);
     get tenant(): Tenant;
     set tenant(value: Tenant);
+    get user(): _User | undefined;
+    set user(value: _User | undefined);
 }

package/dist/types/Service_Schedule_Execution.js

@@ -58,6 +58,12 @@ class Service_Schedule_Execution extends node_1.default.Object {
     set tenant(value) {
         super.set("tenant", value);
     }
+    get user() {
+        return super.get("user");
+    }
+    set user(value) {
+        super.set("user", value);
+    }
 }
 exports.Service_Schedule_Execution = Service_Schedule_Execution;
 node_1.default.Object.registerSubclass("OD3_Service_Schedule_Execution", Service_Schedule_Execution);

package/dist/types/Service_Schedule_Template.d.ts

@@ -1,6 +1,7 @@
 import Parse from "parse/node";
 import type { _Role } from "./_Role";
 import type { Tenant } from "./Tenant";
+import type { _User } from "./_User";
 export interface Service_Schedule_TemplateAttributes {
     id: string;
     objectId: string;
@@ -10,10 +11,12 @@ export interface Service_Schedule_TemplateAttributes {
     cadence: any;
     deletedAt?: Date | undefined;
     description?: string | undefined;
+    notifications: any[];
     serviceProviders: any[];
     steps: any[];
     tenant: Tenant;
     title: string;
+    user?: _User | undefined;
 }
 export declare class Service_Schedule_Template extends Parse.Object<Service_Schedule_TemplateAttributes> {
     static className: string;
@@ -25,6 +28,8 @@ export declare class Service_Schedule_Template extends Parse.Object<Service_Sche
     set deletedAt(value: Date | undefined);
     get description(): string | undefined;
     set description(value: string | undefined);
+    get notifications(): any[];
+    set notifications(value: any[]);
     get serviceProviders(): any[];
     set serviceProviders(value: any[]);
     get steps(): any[];
@@ -33,4 +38,6 @@ export declare class Service_Schedule_Template extends Parse.Object<Service_Sche
     set tenant(value: Tenant);
     get title(): string;
     set title(value: string);
+    get user(): _User | undefined;
+    set user(value: _User | undefined);
 }