@dv4resi/dvss-backend-module-calendar-im 0.0.4 → 0.0.7

package/dist/index.js

@@ -976,8 +976,16 @@ var GET_PAYMENTS_SORTING_ENUM = /* @__PURE__ */ (function(GET_PAYMENTS_SORTING_E
   GET_PAYMENTS_SORTING_ENUM2["AMOUNT"] = "AMOUNT";
   GET_PAYMENTS_SORTING_ENUM2["NOTES"] = "NOTES";
   GET_PAYMENTS_SORTING_ENUM2["PAYMENT_MODE"] = "PAYMENT_MODE";
+  GET_PAYMENTS_SORTING_ENUM2["CREATED_TIME"] = "CREATED_TIME";
   return GET_PAYMENTS_SORTING_ENUM2;
 })({});
+var EVENT_INSTANCE_KIND = /* @__PURE__ */ (function(EVENT_INSTANCE_KIND2) {
+  EVENT_INSTANCE_KIND2["SINGLE"] = "SINGLE";
+  EVENT_INSTANCE_KIND2["SERIES_MASTER"] = "SERIES_MASTER";
+  EVENT_INSTANCE_KIND2["OCCURRENCE"] = "OCCURRENCE";
+  EVENT_INSTANCE_KIND2["EXCEPTION"] = "EXCEPTION";
+  return EVENT_INSTANCE_KIND2;
+})({});
 
 // ../../packages/dvss-integration-libs/src/integration-operation-skeletons/capabilities/wellness/wellness-management.base.ts
 var BaseWellnessManagement = class {
@@ -3834,184 +3842,215 @@ exports.MicrosoftApiClientService = _ts_decorate27([
     typeof exports.TrafficGatewayService === "undefined" ? Object : exports.TrafficGatewayService
   ])
 ], exports.MicrosoftApiClientService);
-
-// ../../packages/dvss-integration-microsoft/src/capabilities/booking-management/booking-management.mapper.ts
-var GRAPH_EVENT_KNOWN_KEYS = /* @__PURE__ */ new Set([
-  "id",
-  "subject",
-  "body",
-  "start",
-  "end",
-  "location",
-  "showAs",
-  "isCancelled",
-  "recurrence",
-  "attendees",
-  "organizer"
-]);
 var GRAPH_RESOURCE_ATTENDEE_TYPE = "resource";
+var GRAPH_WEEKDAY = {
+  [models.DAY_OF_WEEK.SUN]: "sunday",
+  [models.DAY_OF_WEEK.MON]: "monday",
+  [models.DAY_OF_WEEK.TUE]: "tuesday",
+  [models.DAY_OF_WEEK.WED]: "wednesday",
+  [models.DAY_OF_WEEK.THU]: "thursday",
+  [models.DAY_OF_WEEK.FRI]: "friday",
+  [models.DAY_OF_WEEK.SAT]: "saturday"
+};
+var GRAPH_MONTHLY_INDEX = {
+  [models.SCHEDULE_MONTHLY_UNIT.FIRST]: "first",
+  [models.SCHEDULE_MONTHLY_UNIT.SECOND]: "second",
+  [models.SCHEDULE_MONTHLY_UNIT.THIRD]: "third",
+  [models.SCHEDULE_MONTHLY_UNIT.FOURTH]: "fourth",
+  [models.SCHEDULE_MONTHLY_UNIT.LAST]: "last"
+};
+var GRAPH_TYPE_TO_INSTANCE_KIND = {
+  singleInstance: EVENT_INSTANCE_KIND.SINGLE,
+  seriesMaster: EVENT_INSTANCE_KIND.SERIES_MASTER,
+  occurrence: EVENT_INSTANCE_KIND.OCCURRENCE,
+  exception: EVENT_INSTANCE_KIND.EXCEPTION
+};
 function toGraphEvent(event, options) {
   const graph = {};
-  if (event.subject !== void 0) {
-    graph.subject = event.subject;
+  if (event.name !== void 0) {
+    graph.subject = event.name;
   }
-  if (event.body !== void 0) {
+  const body = event.description ?? event.notes ?? void 0;
+  if (body !== void 0) {
     graph.body = {
       contentType: "text",
-      content: event.body
+      content: body
     };
   }
-  if (event.start !== void 0) {
+  if (event.bookingStartDateLabel !== void 0) {
     graph.start = {
-      dateTime: event.start.dateTime,
-      timeZone: event.start.timeZone
+      dateTime: toGraphDateTime(event.bookingStartDateLabel, event.bookingStartTimeLabel, event.isFullDay),
+      timeZone: event.timeZone ?? ""
     };
   }
-  if (event.end !== void 0) {
+  if (event.bookingEndDateLabel !== void 0) {
     graph.end = {
-      dateTime: event.end.dateTime,
-      timeZone: event.end.timeZone
+      dateTime: toGraphDateTime(event.bookingEndDateLabel, event.bookingEndTimeLabel, event.isFullDay),
+      timeZone: event.timeZone ?? ""
     };
   }
-  if (event.location !== void 0) {
-    graph.location = {
-      displayName: event.location
-    };
+  if (event.isFullDay !== void 0) {
+    graph.isAllDay = event.isFullDay;
   }
-  if (event.showAs !== void 0) {
-    graph.showAs = event.showAs;
+  if (event.isRecurring && event.schedule) {
+    const recurrence = scheduleToGraphRecurrence(event.schedule, {
+      startDate: event.bookingStartDateLabel,
+      endDate: event.seriesEndDateLabel ?? event.bookingEndDateLabel
+    });
+    if (recurrence) {
+      graph.recurrence = recurrence;
+    }
   }
-  if (event.isCancelled !== void 0) {
-    graph.isCancelled = event.isCancelled;
+  const attendees = buildGraphAttendees(event, options?.targetMailbox);
+  if (attendees.length > 0) {
+    graph.attendees = attendees;
   }
-  if (event.recurrence !== void 0) {
-    graph.recurrence = toGraphRecurrence(event.recurrence);
+  return graph;
+}
+__name(toGraphEvent, "toGraphEvent");
+function spaceMailboxesFromItems(items) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of items ?? []) {
+    const isSpace = item.resources?.some((resource) => resource.resourceType === models.OFFERING_RESOURCE_TYPE.SPACE);
+    const email = item.externalId?.trim();
+    const key = email?.toLowerCase();
+    if (isSpace && email && key && !seen.has(key)) {
+      seen.add(key);
+      out.push(email);
+    }
   }
-  if (event.attendees !== void 0) {
-    graph.attendees = event.attendees.map((attendee) => {
-      const mapped = {
-        emailAddress: omitUndefined({
-          address: attendee.email,
-          name: attendee.name
-        })
-      };
-      if (attendee.type !== void 0) {
-        mapped.type = attendee.type;
-      }
-      return mapped;
+  return out;
+}
+__name(spaceMailboxesFromItems, "spaceMailboxesFromItems");
+function buildGraphAttendees(event, targetMailbox) {
+  const target = targetMailbox?.trim().toLowerCase();
+  const seen = new Set(target ? [
+    target
+  ] : []);
+  const attendees = [];
+  const add = /* @__PURE__ */ __name((email, type) => {
+    const key = email?.trim().toLowerCase();
+    if (!key || seen.has(key)) {
+      return;
+    }
+    seen.add(key);
+    attendees.push({
+      emailAddress: {
+        address: email.trim()
+      },
+      type
     });
+  }, "add");
+  for (const email of [
+    ...event.requestedForIds ?? [],
+    ...event.recipientIds ?? []
+  ]) {
+    add(email, "required");
   }
-  const resourceId = options?.resourceId?.trim();
-  if (resourceId) {
-    const isAlreadyInvited = graph.attendees?.some((attendee) => attendee.emailAddress?.address?.toLowerCase() === resourceId.toLowerCase());
-    if (isAlreadyInvited !== true) {
-      graph.attendees = [
-        ...graph.attendees ?? [],
-        {
-          emailAddress: {
-            address: resourceId
-          },
-          type: GRAPH_RESOURCE_ATTENDEE_TYPE
-        }
-      ];
-    }
+  for (const email of spaceMailboxesFromItems(event.items)) {
+    add(email, GRAPH_RESOURCE_ATTENDEE_TYPE);
   }
-  return graph;
+  return attendees;
 }
-__name(toGraphEvent, "toGraphEvent");
-function toGraphRecurrence(recurrence) {
-  return {
-    pattern: omitUndefined({
-      type: recurrence.pattern.type,
-      interval: recurrence.pattern.interval,
-      daysOfWeek: recurrence.pattern.daysOfWeek,
-      firstDayOfWeek: recurrence.pattern.firstDayOfWeek,
-      dayOfMonth: recurrence.pattern.dayOfMonth,
-      month: recurrence.pattern.month,
-      index: recurrence.pattern.index
-    }),
-    range: omitUndefined({
-      type: recurrence.range.type,
-      startDate: recurrence.range.startDate,
-      endDate: recurrence.range.endDate,
-      numberOfOccurrences: recurrence.range.numberOfOccurrences,
-      recurrenceTimeZone: recurrence.range.recurrenceTimeZone
-    })
+__name(buildGraphAttendees, "buildGraphAttendees");
+function scheduleToGraphRecurrence(schedule, window) {
+  if (!window.startDate || !window.endDate) {
+    return void 0;
+  }
+  const range = {
+    type: "endDate",
+    startDate: window.startDate,
+    endDate: window.endDate
   };
+  switch (schedule.repeat) {
+    case models.SCHEDULE_REPEAT_TYPE.EVERY_DAY:
+      return {
+        pattern: {
+          type: "daily",
+          interval: 1
+        },
+        range
+      };
+    case models.SCHEDULE_REPEAT_TYPE.EVERY_WEEK:
+      if (!schedule.daysOfWeek?.length) {
+        return void 0;
+      }
+      return {
+        pattern: {
+          type: "weekly",
+          interval: 1,
+          daysOfWeek: schedule.daysOfWeek.map((day) => GRAPH_WEEKDAY[day])
+        },
+        range
+      };
+    case models.SCHEDULE_REPEAT_TYPE.EVERY_MONTH:
+      if (schedule.datesOfMonth?.length === 1) {
+        return {
+          pattern: {
+            type: "absoluteMonthly",
+            interval: 1,
+            dayOfMonth: schedule.datesOfMonth[0]
+          },
+          range
+        };
+      }
+      if (schedule.monthlyUnit && schedule.daysOfWeek?.length) {
+        return {
+          pattern: {
+            type: "relativeMonthly",
+            interval: 1,
+            daysOfWeek: schedule.daysOfWeek.map((day) => GRAPH_WEEKDAY[day]),
+            index: GRAPH_MONTHLY_INDEX[schedule.monthlyUnit]
+          },
+          range
+        };
+      }
+      return void 0;
+    case models.SCHEDULE_REPEAT_TYPE.CUSTOM:
+    default:
+      return void 0;
+  }
 }
-__name(toGraphRecurrence, "toGraphRecurrence");
-function fromGraphEvent(graph, options) {
-  const providerPayload = collectUnknownGraphFields(graph);
+__name(scheduleToGraphRecurrence, "scheduleToGraphRecurrence");
+function graphEventToRef(graph, options) {
   return {
     id: graph.id,
-    subject: graph.subject ?? "",
-    body: graph.body?.content,
-    start: graph.start ?? {
-      dateTime: "",
-      timeZone: ""
-    },
-    end: graph.end ?? {
-      dateTime: "",
-      timeZone: ""
-    },
-    location: graph.location?.displayName,
-    resourceId: options?.resourceId,
-    recurrence: graph.recurrence ? fromGraphRecurrence(graph.recurrence) : void 0,
-    attendees: graph.attendees?.filter((attendee) => Boolean(attendee.emailAddress?.address)).map((attendee) => ({
-      email: attendee.emailAddress?.address ?? "",
-      name: attendee.emailAddress?.name,
-      type: attendee.type
-    })),
-    organizerEmail: graph.organizer?.emailAddress?.address,
-    showAs: graph.showAs,
-    isCancelled: graph.isCancelled,
+    seriesId: graph.seriesMasterId,
+    instanceKind: graph.type ? GRAPH_TYPE_TO_INSTANCE_KIND[graph.type] : void 0,
     syncMetadata: omitUndefined({
       ...options?.syncMetadata,
       externalEventId: graph.id ?? options?.syncMetadata?.externalEventId,
-      // Event ids are mailbox-scoped — remember which mailbox can address this id.
-      // Left undefined when the room organizes; `resourceId` addresses the event then.
       organizerUserEmail: options?.organizerUserEmail ?? options?.syncMetadata?.organizerUserEmail,
-      resourceId: options?.resourceId ?? options?.syncMetadata?.resourceId
-    }),
-    providerPayload
-  };
-}
-__name(fromGraphEvent, "fromGraphEvent");
-function fromGraphRecurrence(recurrence) {
-  return {
-    pattern: omitUndefined({
-      type: recurrence.pattern?.type ?? "",
-      interval: recurrence.pattern?.interval ?? 1,
-      daysOfWeek: recurrence.pattern?.daysOfWeek,
-      firstDayOfWeek: recurrence.pattern?.firstDayOfWeek,
-      dayOfMonth: recurrence.pattern?.dayOfMonth,
-      month: recurrence.pattern?.month,
-      index: recurrence.pattern?.index
-    }),
-    range: omitUndefined({
-      type: recurrence.range?.type ?? "",
-      startDate: recurrence.range?.startDate ?? "",
-      endDate: recurrence.range?.endDate,
-      numberOfOccurrences: recurrence.range?.numberOfOccurrences,
-      recurrenceTimeZone: recurrence.range?.recurrenceTimeZone
+      resourceId: options?.resourceId ?? options?.syncMetadata?.resourceId,
+      excludedDateResults: options?.excludedDateResults ?? options?.syncMetadata?.excludedDateResults
     })
   };
 }
-__name(fromGraphRecurrence, "fromGraphRecurrence");
+__name(graphEventToRef, "graphEventToRef");
+function graphEventsToInstances(response) {
+  return (response.value ?? []).filter((graph) => Boolean(graph.id && graph.start?.dateTime)).map((graph) => omitUndefined({
+    id: graph.id,
+    startDateLabel: graph.start.dateTime.slice(0, 10),
+    seriesId: graph.seriesMasterId
+  }));
+}
+__name(graphEventsToInstances, "graphEventsToInstances");
+function toGraphDateTime(dateLabel, timeLabel, isFullDay) {
+  if (isFullDay || !timeLabel) {
+    return `${dateLabel}T00:00:00`;
+  }
+  const parts = timeLabel.split(":");
+  const hh = parts[0] ?? "00";
+  const mm = parts[1] ?? "00";
+  const ss = parts[2] ?? "00";
+  return `${dateLabel}T${hh}:${mm}:${ss}`;
+}
+__name(toGraphDateTime, "toGraphDateTime");
 function omitUndefined(value) {
   return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
 }
 __name(omitUndefined, "omitUndefined");
-function collectUnknownGraphFields(graph) {
-  const extras = {};
-  for (const [key, value] of Object.entries(graph)) {
-    if (!GRAPH_EVENT_KNOWN_KEYS.has(key) && value !== void 0) {
-      extras[key] = value;
-    }
-  }
-  return Object.keys(extras).length > 0 ? extras : void 0;
-}
-__name(collectUnknownGraphFields, "collectUnknownGraphFields");
 
 // ../../packages/dvss-integration-microsoft/src/capabilities/booking-management/booking-management.service.ts
 function _ts_decorate28(decorators, target, key, desc2) {
@@ -4037,32 +4076,34 @@ exports.MicrosoftCalendarBookingService = class MicrosoftCalendarBookingService
   }
   async createEvent(request, integration, loggedInUserId) {
     try {
-      const mailboxEmail = this.resolveMailboxEmail(request);
+      const organizerEmail = request.event.requestedForIds?.[0];
+      const roomEmail = spaceMailboxesFromItems(request.event.items)[0];
+      const mailboxEmail = this.pickMailbox(organizerEmail, roomEmail);
+      this.assertMailbox(mailboxEmail);
       this.logger.info(loggedInUserId, this.createEvent.name, this.fileName, "Create Microsoft Graph calendar event", {
         mailboxEmail,
-        resourceId: request.resourceId,
-        subject: request.event.subject,
+        subject: request.event.name,
         path: MICROSOFT_GRAPH_PATHS.userCalendarEvents(mailboxEmail)
       });
-      this.assertResourceId(request.resourceId);
       const graphEvent = await this.microsoftApiClient.apiCall({
         apiMethod: HTTP_METHOD.POST,
         url: MICROSOFT_GRAPH_PATHS.userCalendarEvents(mailboxEmail),
         body: toGraphEvent(request.event, {
-          resourceId: this.resourceAsAttendee(mailboxEmail, request.resourceId)
+          targetMailbox: mailboxEmail
         })
       }, integration, loggedInUserId);
-      const mapped = fromGraphEvent(graphEvent, {
-        resourceId: request.resourceId,
-        organizerUserEmail: this.organizerUserMailbox(request),
-        syncMetadata: request.event.syncMetadata
+      const excludedDateResults = await this.resolveSkipDatesIfAny(graphEvent.id, request.event.schedule?.skipDates, mailboxEmail, this.organizerUserMailbox(organizerEmail), integration, loggedInUserId);
+      const ref = graphEventToRef(graphEvent, {
+        organizerUserEmail: this.organizerUserMailbox(organizerEmail),
+        resourceId: roomEmail,
+        syncMetadata: request.event.syncMetadata,
+        excludedDateResults
       });
       this.logger.info(loggedInUserId, this.createEvent.name, this.fileName, "Created Microsoft Graph calendar event", {
-        eventId: mapped.id,
-        mailboxEmail,
-        resourceId: request.resourceId
+        eventId: ref.id,
+        mailboxEmail
       });
-      return mapped;
+      return ref;
     } catch (error) {
       this.logger.error(loggedInUserId, this.createEvent.name, this.fileName, "Error creating Microsoft Graph calendar event", error);
       throw error;
@@ -4070,31 +4111,33 @@ exports.MicrosoftCalendarBookingService = class MicrosoftCalendarBookingService
   }
   async updateEvent(request, integration, loggedInUserId) {
     try {
-      const mailboxEmail = this.resolveMailboxEmail(request);
+      const mailboxEmail = this.pickMailbox(request.organizerUserEmail, request.resourceEmail);
+      this.assertMailbox(mailboxEmail);
+      this.assertEventId(request.eventId);
       this.logger.info(loggedInUserId, this.updateEvent.name, this.fileName, "Update Microsoft Graph calendar event", {
         mailboxEmail,
-        resourceId: request.resourceId,
         eventId: request.eventId,
         path: MICROSOFT_GRAPH_PATHS.userCalendarEvent(mailboxEmail, request.eventId)
       });
-      this.assertResourceId(request.resourceId);
-      this.assertEventId(request.eventId);
       const graphEvent = await this.microsoftApiClient.apiCall({
         apiMethod: HTTP_METHOD.PATCH,
         url: MICROSOFT_GRAPH_PATHS.userCalendarEvent(mailboxEmail, request.eventId),
-        body: toGraphEvent(request.event)
+        body: toGraphEvent(request.event, {
+          targetMailbox: mailboxEmail
+        })
       }, integration, loggedInUserId);
-      const mapped = fromGraphEvent(graphEvent, {
-        resourceId: request.resourceId,
-        organizerUserEmail: this.organizerUserMailbox(request),
-        syncMetadata: request.event.syncMetadata
+      const excludedDateResults = await this.resolveSkipDatesIfAny(graphEvent.id ?? request.eventId, request.event.schedule?.skipDates, mailboxEmail, this.organizerUserMailbox(request.organizerUserEmail), integration, loggedInUserId);
+      const ref = graphEventToRef(graphEvent, {
+        organizerUserEmail: this.organizerUserMailbox(request.organizerUserEmail),
+        resourceId: request.resourceEmail,
+        syncMetadata: request.event.syncMetadata,
+        excludedDateResults
       });
       this.logger.info(loggedInUserId, this.updateEvent.name, this.fileName, "Updated Microsoft Graph calendar event", {
-        eventId: mapped.id,
-        mailboxEmail,
-        resourceId: request.resourceId
+        eventId: ref.id,
+        mailboxEmail
       });
-      return mapped;
+      return ref;
     } catch (error) {
       this.logger.error(loggedInUserId, this.updateEvent.name, this.fileName, "Error updating Microsoft Graph calendar event", error);
       throw error;
@@ -4102,19 +4145,12 @@ exports.MicrosoftCalendarBookingService = class MicrosoftCalendarBookingService
   }
   async cancelEvent(request, integration, loggedInUserId) {
     try {
-      const mailboxEmail = this.resolveMailboxEmail(request);
+      const mailboxEmail = this.pickMailbox(request.organizerUserEmail, request.resourceEmail);
       this.logger.info(loggedInUserId, this.cancelEvent.name, this.fileName, "Cancel Microsoft Graph calendar event", {
         mailboxEmail,
-        resourceId: request.resourceId,
-        eventId: request.eventId,
-        path: MICROSOFT_GRAPH_PATHS.userCalendarEvent(mailboxEmail, request.eventId)
-      });
-      await this.deleteGraphEvent(mailboxEmail, request.resourceId, request.eventId, integration, loggedInUserId);
-      this.logger.info(loggedInUserId, this.cancelEvent.name, this.fileName, "Cancelled Microsoft Graph calendar event", {
-        eventId: request.eventId,
-        mailboxEmail,
-        resourceId: request.resourceId
+        eventId: request.eventId
       });
+      await this.deleteGraphEvent(mailboxEmail, request.eventId, integration, loggedInUserId);
     } catch (error) {
       this.logger.error(loggedInUserId, this.cancelEvent.name, this.fileName, "Error cancelling Microsoft Graph calendar event", error);
       throw error;
@@ -4122,76 +4158,35 @@ exports.MicrosoftCalendarBookingService = class MicrosoftCalendarBookingService
   }
   async deleteEvent(request, integration, loggedInUserId) {
     try {
-      const mailboxEmail = this.resolveMailboxEmail(request);
+      const mailboxEmail = this.pickMailbox(request.organizerUserEmail, request.resourceEmail);
       this.logger.info(loggedInUserId, this.deleteEvent.name, this.fileName, "Delete Microsoft Graph calendar event", {
         mailboxEmail,
-        resourceId: request.resourceId,
-        eventId: request.eventId,
-        path: MICROSOFT_GRAPH_PATHS.userCalendarEvent(mailboxEmail, request.eventId)
-      });
-      await this.deleteGraphEvent(mailboxEmail, request.resourceId, request.eventId, integration, loggedInUserId);
-      this.logger.info(loggedInUserId, this.deleteEvent.name, this.fileName, "Deleted Microsoft Graph calendar event", {
-        eventId: request.eventId,
-        mailboxEmail,
-        resourceId: request.resourceId
+        eventId: request.eventId
       });
+      await this.deleteGraphEvent(mailboxEmail, request.eventId, integration, loggedInUserId);
     } catch (error) {
       this.logger.error(loggedInUserId, this.deleteEvent.name, this.fileName, "Error deleting Microsoft Graph calendar event", error);
       throw error;
     }
   }
-  async getEvent(request, integration, loggedInUserId) {
-    try {
-      const mailboxEmail = this.resolveMailboxEmail(request);
-      this.logger.info(loggedInUserId, this.getEvent.name, this.fileName, "Get Microsoft Graph calendar event", {
-        mailboxEmail,
-        resourceId: request.resourceId,
-        eventId: request.eventId,
-        path: MICROSOFT_GRAPH_PATHS.userCalendarEvent(mailboxEmail, request.eventId)
-      });
-      this.assertResourceId(request.resourceId);
-      this.assertEventId(request.eventId);
-      const graphEvent = await this.microsoftApiClient.apiCall({
-        apiMethod: HTTP_METHOD.GET,
-        url: MICROSOFT_GRAPH_PATHS.userCalendarEvent(mailboxEmail, request.eventId)
-      }, integration, loggedInUserId);
-      const mapped = fromGraphEvent(graphEvent, {
-        resourceId: request.resourceId,
-        organizerUserEmail: this.organizerUserMailbox(request)
-      });
-      this.logger.info(loggedInUserId, this.getEvent.name, this.fileName, "Fetched Microsoft Graph calendar event", {
-        eventId: mapped.id,
-        mailboxEmail,
-        resourceId: request.resourceId
-      });
-      return mapped;
-    } catch (error) {
-      this.logger.error(loggedInUserId, this.getEvent.name, this.fileName, "Error fetching Microsoft Graph calendar event", error);
-      throw error;
-    }
-  }
   async getEvents(request, integration, loggedInUserId) {
     try {
-      this.assertResourceId(request.resourceId);
-      const mailboxEmail = this.resolveMailboxEmail(request);
-      const url = request.start && request.end ? MICROSOFT_GRAPH_PATHS.userCalendarView(mailboxEmail, request.start.dateTime, request.end.dateTime) : MICROSOFT_GRAPH_PATHS.userCalendarEvents(mailboxEmail);
+      const mailboxEmail = this.pickMailbox(request.organizerUserEmail, request.resourceEmail);
+      this.assertMailbox(mailboxEmail);
+      const hasWindow = Boolean(request.startDateLabel && request.endDateLabel);
+      const url = hasWindow ? MICROSOFT_GRAPH_PATHS.userCalendarView(mailboxEmail, `${request.startDateLabel}T00:00:00`, `${request.endDateLabel}T23:59:59`) : MICROSOFT_GRAPH_PATHS.userCalendarEvents(mailboxEmail);
       this.logger.info(loggedInUserId, this.getEvents.name, this.fileName, "List Microsoft Graph calendar events", {
         mailboxEmail,
-        resourceId: request.resourceId,
         path: url,
-        hasTimeWindow: Boolean(request.start && request.end)
+        hasTimeWindow: hasWindow
       });
       const response = await this.microsoftApiClient.apiCall({
         apiMethod: HTTP_METHOD.GET,
         url
       }, integration, loggedInUserId);
-      const events = (response.value ?? []).map((graphEvent) => fromGraphEvent(graphEvent, {
-        resourceId: request.resourceId,
-        organizerUserEmail: this.organizerUserMailbox(request)
-      }));
+      const events = graphEventsToInstances(response);
       this.logger.info(loggedInUserId, this.getEvents.name, this.fileName, "Listed Microsoft Graph calendar events", {
         mailboxEmail,
-        resourceId: request.resourceId,
         count: events.length
       });
       return {
@@ -4202,16 +4197,8 @@ exports.MicrosoftCalendarBookingService = class MicrosoftCalendarBookingService
       throw error;
     }
   }
-  syncEvents(request, integration, loggedInUserId) {
-    this.logger.info(loggedInUserId, this.syncEvents.name, this.fileName, "Sync Microsoft Graph calendar events (delta)", {
-      resourceId: request.resourceId,
-      hasSyncToken: Boolean(request.syncToken)
-    });
-    void this.microsoftApiClient;
-    return Promise.reject(new common.NotImplementedException("MicrosoftCalendarBookingService.syncEvents is not implemented yet"));
-  }
-  async deleteGraphEvent(mailboxEmail, resourceId, eventId, integration, loggedInUserId) {
-    this.assertResourceId(resourceId);
+  async deleteGraphEvent(mailboxEmail, eventId, integration, loggedInUserId) {
+    this.assertMailbox(mailboxEmail);
     this.assertEventId(eventId);
     await this.microsoftApiClient.apiCall({
       apiMethod: HTTP_METHOD.DELETE,
@@ -4219,30 +4206,74 @@ exports.MicrosoftCalendarBookingService = class MicrosoftCalendarBookingService
     }, integration, loggedInUserId);
   }
   /**
-   * Mailbox the Graph call targets: the organizing user when one is known, otherwise the
-   * resource mailbox, which keeps the room-organizes behaviour for callers that cannot
-   * resolve a user. The return value is therefore a user *or* a resource mailbox — never
-   * store it as `organizerUserEmail`; use `organizerUserMailbox` for that.
+   * Graph always creates/updates a recurring series whole. For each date in
+   * `schedule.skipDates` this finds the occurrence instance in the series just
+   * created/updated and cancels it via the existing DELETE path. Best-effort per date — a
+   * date that can't be resolved is reported `excluded: false`, not thrown.
    */
-  resolveMailboxEmail(request) {
-    return this.organizerUserMailbox(request) ?? request.resourceId;
+  async resolveSkipDatesIfAny(seriesId, dates, mailboxEmail, organizerUserEmail, integration, loggedInUserId) {
+    if (!dates?.length) {
+      return void 0;
+    }
+    const results = [];
+    for (const date of dates) {
+      try {
+        const instanceId = await this.findOccurrenceInstanceId(seriesId, date, mailboxEmail, integration, loggedInUserId);
+        if (!instanceId) {
+          this.logger.warn(loggedInUserId, this.resolveSkipDatesIfAny.name, this.fileName, "Could not resolve skip-date occurrence", {
+            seriesId,
+            date,
+            mailboxEmail
+          });
+          results.push({
+            date,
+            excluded: false
+          });
+          continue;
+        }
+        await this.cancelEvent({
+          eventId: instanceId,
+          resourceEmail: mailboxEmail,
+          organizerUserEmail
+        }, integration, loggedInUserId);
+        results.push({
+          date,
+          eventId: instanceId,
+          excluded: true
+        });
+      } catch (error) {
+        this.logger.warn(loggedInUserId, this.resolveSkipDatesIfAny.name, this.fileName, "Failed to cancel skip-date occurrence", {
+          seriesId,
+          date,
+          mailboxEmail,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        results.push({
+          date,
+          excluded: false
+        });
+      }
+    }
+    return results;
   }
-  /**
-   * The organizing user's mailbox, or undefined when the room ends up organizing.
-   */
-  organizerUserMailbox(request) {
-    return request.organizerUserEmail?.trim() || void 0;
+  async findOccurrenceInstanceId(seriesId, date, mailboxEmail, integration, loggedInUserId) {
+    const response = await this.microsoftApiClient.apiCall({
+      apiMethod: HTTP_METHOD.GET,
+      url: MICROSOFT_GRAPH_PATHS.userCalendarView(mailboxEmail, `${date}T00:00:00`, `${date}T23:59:59`)
+    }, integration, loggedInUserId);
+    return (response.value ?? []).find((occurrence) => occurrence.seriesMasterId === seriesId)?.id;
   }
-  /**
-   * The room only needs to be invited as an attendee when the event lives in someone
-   * else's mailbox. Posting into the room's own calendar already books it.
-   */
-  resourceAsAttendee(mailboxEmail, resourceId) {
-    return mailboxEmail.trim().toLowerCase() === resourceId.trim().toLowerCase() ? void 0 : resourceId;
+  /** Mailbox the Graph call targets: the organizing user if known, else the room. */
+  pickMailbox(organizerEmail, roomEmail) {
+    return this.organizerUserMailbox(organizerEmail) ?? roomEmail?.trim() ?? "";
   }
-  assertResourceId(resourceId) {
-    if (!resourceId?.trim()) {
-      throw new dvssBackendModuleUtility.CustomException("BAD_REQUEST", "resourceId is required");
+  /** The organizing user's mailbox, or undefined when the room ends up organizing. */
+  organizerUserMailbox(organizerEmail) {
+    return organizerEmail?.trim() || void 0;
+  }
+  assertMailbox(mailboxEmail) {
+    if (!mailboxEmail?.trim()) {
+      throw new dvssBackendModuleUtility.CustomException("BAD_REQUEST", "a requested-for or resource mailbox is required");
     }
   }
   assertEventId(eventId) {
@@ -4788,15 +4819,9 @@ exports.MicrosoftCalendarBookingHandler = class MicrosoftCalendarBookingHandler
   async deleteCalendarBooking(request, integration, loggedInUserId) {
     return this.microsoftCalendarBookingService.deleteEvent(request, integration, loggedInUserId);
   }
-  async getCalendarBooking(request, integration, loggedInUserId) {
-    return this.microsoftCalendarBookingService.getEvent(request, integration, loggedInUserId);
-  }
   async getCalendarBookings(request, integration, loggedInUserId) {
     return this.microsoftCalendarBookingService.getEvents(request, integration, loggedInUserId);
   }
-  async syncCalendarBookings(request, integration, loggedInUserId) {
-    return this.microsoftCalendarBookingService.syncEvents(request, integration, loggedInUserId);
-  }
 };
 exports.MicrosoftCalendarBookingHandler = _ts_decorate36([
   common.Injectable(),
@@ -5112,6 +5137,30 @@ exports.CalendarIntegrationManager = _ts_decorate44([
   })
 ], exports.CalendarIntegrationManager);
 
+Object.defineProperty(exports, "BEHAVIOUR_TYPE_ENUM", {
+  enumerable: true,
+  get: function () { return models.BEHAVIOUR_TYPE_ENUM; }
+});
+Object.defineProperty(exports, "DAY_OF_WEEK", {
+  enumerable: true,
+  get: function () { return models.DAY_OF_WEEK; }
+});
+Object.defineProperty(exports, "OFFERING_BOOKING_TIME_TYPE", {
+  enumerable: true,
+  get: function () { return models.OFFERING_BOOKING_TIME_TYPE; }
+});
+Object.defineProperty(exports, "OFFERING_BOOKING_TYPE_ENUM", {
+  enumerable: true,
+  get: function () { return models.OFFERING_BOOKING_TYPE_ENUM; }
+});
+Object.defineProperty(exports, "SCHEDULE_MONTHLY_UNIT", {
+  enumerable: true,
+  get: function () { return models.SCHEDULE_MONTHLY_UNIT; }
+});
+Object.defineProperty(exports, "SCHEDULE_REPEAT_TYPE", {
+  enumerable: true,
+  get: function () { return models.SCHEDULE_REPEAT_TYPE; }
+});
 exports.BOOKABLE_ITEM_STATUS_ENUM = BOOKABLE_ITEM_STATUS_ENUM;
 exports.BOOKABLE_ITEM_TYPE_ENUM = BOOKABLE_ITEM_TYPE_ENUM;
 exports.BaseAccessManagement = BaseAccessManagement;
@@ -5144,6 +5193,7 @@ exports.CREDIT_STATUS_ENUM = CREDIT_STATUS_ENUM;
 exports.CREDIT_TYPE_ENUM = CREDIT_TYPE_ENUM;
 exports.DOWNLOAD_CUSTOMER_ACCOUNTING_STATEMENT_FILTER_BY_ENUM = DOWNLOAD_CUSTOMER_ACCOUNTING_STATEMENT_FILTER_BY_ENUM;
 exports.DOWNLOAD_CUSTOMER_ACCOUNTING_STATEMENT_STATUS_ENUM = DOWNLOAD_CUSTOMER_ACCOUNTING_STATEMENT_STATUS_ENUM;
+exports.EVENT_INSTANCE_KIND = EVENT_INSTANCE_KIND;
 exports.GET_CUSTOMER_CREDIT_NOTES_FILTER_BY = GET_CUSTOMER_CREDIT_NOTES_FILTER_BY;
 exports.GET_CUSTOMER_CREDIT_NOTES_SORT_BY = GET_CUSTOMER_CREDIT_NOTES_SORT_BY;
 exports.GET_INVOICES_FILTER_BY_ENUM = GET_INVOICES_FILTER_BY_ENUM;