@dv4resi/dvss-backend-module-offering-im 0.0.4 → 0.0.5

package/dist/index.js

@@ -603,10 +603,10 @@ var BaseAuth = class {
   }
 };
 
-// ../../packages/dvss-integration-libs/src/integration-operation-skeletons/capabilities/wellness/appointment-booking.base.ts
-var BaseWellnessAppointmentBooking = class {
+// ../../packages/dvss-integration-libs/src/integration-operation-skeletons/capabilities/wellness/wellness-management.base.ts
+var BaseWellnessManagement = class {
   static {
-    __name(this, "BaseWellnessAppointmentBooking");
+    __name(this, "BaseWellnessManagement");
   }
 };
 
@@ -739,6 +739,29 @@ var INTEGRATION_PROVIDER_ENUM = /* @__PURE__ */ (function(INTEGRATION_PROVIDER_E
   INTEGRATION_PROVIDER_ENUM2["TRYBE"] = "TRYBE";
   return INTEGRATION_PROVIDER_ENUM2;
 })({});
+
+// ../../packages/dvss-integration-libs/src/integration-common-utils/models/wellness-management.model.ts
+var BOOKABLE_ITEM_TYPE_ENUM = /* @__PURE__ */ (function(BOOKABLE_ITEM_TYPE_ENUM2) {
+  BOOKABLE_ITEM_TYPE_ENUM2["APPOINTMENT"] = "APPOINTMENT";
+  BOOKABLE_ITEM_TYPE_ENUM2["SESSION"] = "SESSION";
+  BOOKABLE_ITEM_TYPE_ENUM2["COURSE"] = "COURSE";
+  return BOOKABLE_ITEM_TYPE_ENUM2;
+})({});
+var BOOKABLE_ITEM_STATUS_ENUM = /* @__PURE__ */ (function(BOOKABLE_ITEM_STATUS_ENUM2) {
+  BOOKABLE_ITEM_STATUS_ENUM2["ACTIVE"] = "ACTIVE";
+  BOOKABLE_ITEM_STATUS_ENUM2["INACTIVE"] = "INACTIVE";
+  return BOOKABLE_ITEM_STATUS_ENUM2;
+})({});
+var DAY_OF_WEEK = /* @__PURE__ */ (function(DAY_OF_WEEK2) {
+  DAY_OF_WEEK2["MON"] = "MON";
+  DAY_OF_WEEK2["TUE"] = "TUE";
+  DAY_OF_WEEK2["WED"] = "WED";
+  DAY_OF_WEEK2["THU"] = "THU";
+  DAY_OF_WEEK2["FRI"] = "FRI";
+  DAY_OF_WEEK2["SAT"] = "SAT";
+  DAY_OF_WEEK2["SUN"] = "SUN";
+  return DAY_OF_WEEK2;
+})({});
 function _ts_decorate11(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -959,10 +982,12 @@ function mapTrybeCreditsToSystem(res, integration) {
     groups.set(key, list);
   }
   const records = [];
+  let index = 0;
   for (const [, items] of groups) {
     const first = items[0];
     const couponCodes = items.map((i) => i.coupon_code);
     records.push({
+      id: BigInt(index + 1),
       capabilityIntegrationId: integration.id,
       projectId: integration.projectId,
       name: first.coupon_name,
@@ -986,6 +1011,7 @@ function mapTrybeCreditsToSystem(res, integration) {
         }
       }
     });
+    index++;
   }
   return {
     totalCount: records.length,
@@ -1073,7 +1099,438 @@ exports.TrybeCreditBooking = _ts_decorate13([
   ])
 ], exports.TrybeCreditBooking);
 
-// ../../packages/dvss-integration-trybe/src/app.module.ts
+// ../../packages/dvss-integration-trybe/src/utils/date.util.ts
+function formatDateForTrybe(date, isStartOfDay) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  const hours = isStartOfDay ? "00" : "23";
+  const minutes = isStartOfDay ? "00" : "59";
+  const seconds = isStartOfDay ? "00" : "59";
+  const offset = -date.getTimezoneOffset();
+  const offsetHours = String(Math.floor(Math.abs(offset) / 60)).padStart(2, "0");
+  const offsetMinutes = String(Math.abs(offset) % 60).padStart(2, "0");
+  const offsetSign = offset >= 0 ? "+" : "-";
+  return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}${offsetSign}${offsetHours}:${offsetMinutes}`;
+}
+__name(formatDateForTrybe, "formatDateForTrybe");
+function extractTimeFromIsoString(isoString) {
+  const timeMatch = isoString.match(/T(\d{2}:\d{2})/);
+  return timeMatch ? timeMatch[1] : "";
+}
+__name(extractTimeFromIsoString, "extractTimeFromIsoString");
+function snakeToCamel(str) {
+  return str.replaceAll(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+__name(snakeToCamel, "snakeToCamel");
+function convertKeysToCamelCase(object) {
+  if (object === null || object === void 0) {
+    return object;
+  }
+  if (Array.isArray(object)) {
+    return object.map((item) => convertKeysToCamelCase(item));
+  }
+  if (typeof object === "object") {
+    const converted = {};
+    for (const [key, value] of Object.entries(object)) {
+      converted[snakeToCamel(key)] = convertKeysToCamelCase(value);
+    }
+    return converted;
+  }
+  return object;
+}
+__name(convertKeysToCamelCase, "convertKeysToCamelCase");
+
+// ../../packages/dvss-integration-trybe/src/utils/pagination.util.ts
+var fetchAllPages = /* @__PURE__ */ __name(async (firstPageResponse, shouldFetchAll, fetchPage) => {
+  const items = [];
+  items.push(...firstPageResponse.data);
+  if (!shouldFetchAll) {
+    return items;
+  }
+  const lastPage = firstPageResponse.meta.last_page;
+  for (let page = 2; page <= lastPage; page += 1) {
+    const pageResponse = await fetchPage(page);
+    items.push(...pageResponse.data);
+  }
+  return items;
+}, "fetchAllPages");
+
+// ../../packages/dvss-integration-trybe/src/models/wellness-management.model.ts
+var TRYBE_OFFERING_TYPE_ENUM = /* @__PURE__ */ (function(TRYBE_OFFERING_TYPE_ENUM2) {
+  TRYBE_OFFERING_TYPE_ENUM2["APPOINTMENT"] = "APPOINTMENT";
+  TRYBE_OFFERING_TYPE_ENUM2["SESSION"] = "SESSION";
+  TRYBE_OFFERING_TYPE_ENUM2["COURSE"] = "COURSE";
+  return TRYBE_OFFERING_TYPE_ENUM2;
+})({});
+
+// ../../packages/dvss-integration-trybe/src/capabilities/wellness/wellness-management.mapper.ts
+var TRYBE_WEEKDAYS_MAPPING = {
+  monday: DAY_OF_WEEK.MON,
+  tuesday: DAY_OF_WEEK.TUE,
+  wednesday: DAY_OF_WEEK.WED,
+  thursday: DAY_OF_WEEK.THU,
+  friday: DAY_OF_WEEK.FRI,
+  saturday: DAY_OF_WEEK.SAT,
+  sunday: DAY_OF_WEEK.SUN
+};
+function mapTrybeImageToMedia(image) {
+  if (!image) return void 0;
+  return {
+    id: image.id,
+    url: image.url,
+    originalUrl: image.original_url,
+    fileName: image.file_name,
+    mimeType: image.mime_type
+  };
+}
+__name(mapTrybeImageToMedia, "mapTrybeImageToMedia");
+function mapTrybeWeekdays(weekdays) {
+  return weekdays.map((day) => TRYBE_WEEKDAYS_MAPPING[day.toLowerCase()]);
+}
+__name(mapTrybeWeekdays, "mapTrybeWeekdays");
+function mapTrybePriceRuleToPriceMeta(priceRule, currency, index) {
+  const normalizedCurrency = currency ? currency.toUpperCase() : "USD";
+  if (!priceRule.weekdays || priceRule.weekdays.length === 0) {
+    return [
+      {
+        id: BigInt(index),
+        externalId: priceRule.id,
+        status: BOOKABLE_ITEM_STATUS_ENUM.ACTIVE,
+        price: priceRule.price,
+        currency: normalizedCurrency,
+        config: priceRule
+      }
+    ];
+  }
+  return [
+    {
+      id: BigInt(index),
+      externalId: priceRule.id,
+      status: BOOKABLE_ITEM_STATUS_ENUM.ACTIVE,
+      price: priceRule.price,
+      currency: normalizedCurrency,
+      configuredForDays: mapTrybeWeekdays(priceRule.weekdays)
+    }
+  ];
+}
+__name(mapTrybePriceRuleToPriceMeta, "mapTrybePriceRuleToPriceMeta");
+function mapTrybePriceRulesToPrices(priceRules, currency, externalResourceId) {
+  const normalizedCurrency = currency ? currency.toUpperCase() : "USD";
+  return priceRules.map((priceRule, index) => ({
+    id: BigInt(index + 1),
+    label: void 0,
+    currency: normalizedCurrency,
+    price: priceRule.price,
+    externalResourceId,
+    configuredForDays: priceRule.weekdays ? mapTrybeWeekdays(priceRule.weekdays) : void 0,
+    pricesMeta: mapTrybePriceRuleToPriceMeta(priceRule, currency, index + 1),
+    config: priceRule
+  }));
+}
+__name(mapTrybePriceRulesToPrices, "mapTrybePriceRulesToPrices");
+function mapTrybeAppointmentToBookableItem(appointment, index, linkedItems) {
+  return {
+    id: BigInt(index + 1),
+    externalId: appointment.id,
+    name: appointment.name,
+    description: appointment.description,
+    type: BOOKABLE_ITEM_TYPE_ENUM.APPOINTMENT,
+    status: BOOKABLE_ITEM_STATUS_ENUM.ACTIVE,
+    icon: mapTrybeImageToMedia(appointment.image),
+    primaryAsset: mapTrybeImageToMedia(appointment.image),
+    prices: mapTrybePriceRulesToPrices(appointment.price_rules, appointment.currency, appointment.id),
+    linkedBookableItems: linkedItems,
+    updatedAt: appointment.updated_at ? new Date(appointment.updated_at) : void 0,
+    meta: {
+      // All Trybe-specific fields that don't map to system response
+      externalId: appointment.id,
+      productCode: appointment.product_code,
+      siteIds: appointment.site_ids,
+      roomIds: appointment.room_ids,
+      equipmentIds: appointment.equipment_ids,
+      practitionerIds: appointment.practitioner_ids,
+      durations: appointment.durations,
+      endBuffer: appointment.end_buffer,
+      startTimeInterval: appointment.start_time_interval,
+      maxAdvanceBookingsInterval: appointment.max_advance_bookings_interval,
+      minAdvanceBookingsInterval: appointment.min_advance_bookings_interval,
+      tagIds: appointment.tag_ids,
+      tags: appointment.tags,
+      categoryIds: appointment.category_ids,
+      offeredOnline: appointment.offered_online,
+      private: appointment.private,
+      visibility: appointment.visibility,
+      customersOnly: appointment.customers_only,
+      membersOnly: appointment.members_only,
+      membershipBookingWindowsEnabled: appointment.membership_booking_windows_enabled,
+      membershipBookingWindows: appointment.membership_booking_windows,
+      trybeMeta: appointment.meta,
+      upsellOfferings: appointment.upsell_offerings,
+      crossSellOfferings: appointment.cross_sell_offerings,
+      relatedRetailOfferings: appointment.related_retail_offerings,
+      customerCancellationPermitted: appointment.customer_cancellation_permitted,
+      customerCancellationMinDuration: appointment.customer_cancellation_min_duration,
+      minGuests: appointment.min_guests,
+      maxGuests: appointment.max_guests,
+      allocateMultiCapacityRooms: appointment.allocate_multi_capacity_rooms,
+      enquiriesEnabled: appointment.enquiries_enabled,
+      revenueCentre: appointment.revenue_centre,
+      includePricingOnCalendar: appointment.include_pricing_on_calendar,
+      maxPerBasket: appointment.max_per_basket,
+      maxPerGuest: appointment.max_per_guest,
+      shopPractitionerSelectionEnabled: appointment.shop_practitioner_selection_enabled,
+      deletedAt: appointment.deleted_at
+    }
+  };
+}
+__name(mapTrybeAppointmentToBookableItem, "mapTrybeAppointmentToBookableItem");
+function mapTrybeSessionToBookableItem(session, index, linkedItems) {
+  return {
+    id: BigInt(index + 1),
+    externalId: session.id,
+    name: session.name,
+    description: session.description,
+    type: BOOKABLE_ITEM_TYPE_ENUM.SESSION,
+    status: BOOKABLE_ITEM_STATUS_ENUM.ACTIVE,
+    icon: mapTrybeImageToMedia(session.image),
+    primaryAsset: mapTrybeImageToMedia(session.image),
+    prices: mapTrybePriceRulesToPrices(session.price_rules, session.currency, session.id),
+    linkedBookableItems: linkedItems,
+    updatedAt: session.updated_at ? new Date(session.updated_at) : void 0,
+    meta: {
+      // All Trybe-specific fields
+      externalId: session.id,
+      productCode: session.product_code,
+      siteId: session.site_id,
+      duration: session.duration,
+      categoryIds: session.category_ids,
+      offeredOnline: session.offered_online,
+      private: session.private,
+      visibility: session.visibility,
+      customersOnly: session.customers_only,
+      membersOnly: session.members_only,
+      membershipBookingWindowsEnabled: session.membership_booking_windows_enabled,
+      membershipBookingWindows: session.membership_booking_windows,
+      maxBookingsPerMember: session.max_bookings_per_member,
+      trybeMeta: session.meta,
+      upsellOfferings: session.upsell_offerings,
+      crossSellOfferings: session.cross_sell_offerings,
+      relatedRetailOfferings: session.related_retail_offerings,
+      customerCancellationPermitted: session.customer_cancellation_permitted,
+      customerCancellationMinDuration: session.customer_cancellation_min_duration,
+      waitlistEnabled: session.waitlist_enabled,
+      maxAdvanceBookingsInterval: session.max_advance_bookings_interval,
+      minAdvanceBookingsInterval: session.min_advance_bookings_interval,
+      minGuests: session.min_guests,
+      maxGuests: session.max_guests,
+      maxBasketsPerSession: session.max_baskets_per_session,
+      recurrenceGroups: session.recurrence_groups,
+      revenueCentre: session.revenue_centre,
+      includePricingOnCalendar: session.include_pricing_on_calendar,
+      maxPerBasket: session.max_per_basket,
+      maxPerGuest: session.max_per_guest,
+      deletedAt: session.deleted_at
+    }
+  };
+}
+__name(mapTrybeSessionToBookableItem, "mapTrybeSessionToBookableItem");
+function mapTrybeCourseToBookableItem(course, index) {
+  return {
+    id: BigInt(index + 1),
+    externalId: course.id,
+    name: course.name,
+    description: course.description,
+    type: BOOKABLE_ITEM_TYPE_ENUM.COURSE,
+    status: BOOKABLE_ITEM_STATUS_ENUM.ACTIVE,
+    icon: mapTrybeImageToMedia(course.image),
+    primaryAsset: mapTrybeImageToMedia(course.image),
+    prices: mapTrybePriceRulesToPrices(course.price_rules, course.currency, course.id),
+    updatedAt: course.updated_at ? new Date(course.updated_at) : void 0,
+    meta: {
+      // All Trybe-specific fields
+      externalId: course.id,
+      productCode: course.product_code,
+      couponId: course.coupon_id,
+      offerings: course.offerings.map((offering) => ({
+        offeringType: offering.offering_type,
+        offeringId: offering.offering_id,
+        offeringName: offering.offering_name
+      })),
+      offeringType: course.offering_type,
+      offeringId: course.offering_id,
+      quantity: course.quantity,
+      creditsValidityInterval: course.credits_validity_interval,
+      siteId: course.site_id,
+      categoryIds: course.category_ids,
+      offeredOnline: course.offered_online,
+      private: course.private,
+      visibility: course.visibility,
+      customersOnly: course.customers_only,
+      membersOnly: course.members_only,
+      trybeMeta: course.meta,
+      upsellOfferings: course.upsell_offerings,
+      crossSellOfferings: course.cross_sell_offerings,
+      relatedRetailOfferings: course.related_retail_offerings,
+      availabilityRules: course.availability_rules,
+      revenueCentre: course.revenue_centre,
+      deletedAt: course.deleted_at
+    }
+  };
+}
+__name(mapTrybeCourseToBookableItem, "mapTrybeCourseToBookableItem");
+function mapTrybeCategoryToBookableItemCategory(category, index) {
+  return {
+    id: BigInt(index + 1),
+    externalId: category.id,
+    name: category.name,
+    meta: {
+      voucherApplicable: category.voucher_applicable
+    }
+  };
+}
+__name(mapTrybeCategoryToBookableItemCategory, "mapTrybeCategoryToBookableItemCategory");
+function mapTrybeAppointmentsToSystemResponse(appointments, totalCount, courseLookup) {
+  const records = appointments.map((apt, index) => {
+    const linkedCourses = courseLookup?.get(apt.id) ?? [];
+    const linkedItems = linkedCourses.map((course, courseIndex) => mapTrybeCourseToBookableItem(course, courseIndex));
+    return mapTrybeAppointmentToBookableItem(apt, index, linkedItems.length > 0 ? linkedItems : void 0);
+  });
+  return {
+    totalCount,
+    records
+  };
+}
+__name(mapTrybeAppointmentsToSystemResponse, "mapTrybeAppointmentsToSystemResponse");
+function mapTrybeSessionsToSystemResponse(sessions, totalCount, courseLookup) {
+  const records = sessions.map((session, index) => {
+    const linkedCourses = courseLookup?.get(session.id) ?? [];
+    const linkedItems = linkedCourses.map((course, courseIndex) => mapTrybeCourseToBookableItem(course, courseIndex));
+    return mapTrybeSessionToBookableItem(session, index, linkedItems.length > 0 ? linkedItems : void 0);
+  });
+  return {
+    totalCount,
+    records
+  };
+}
+__name(mapTrybeSessionsToSystemResponse, "mapTrybeSessionsToSystemResponse");
+function mapTrybeCoursesToSystemResponse(courses, totalCount) {
+  const records = courses.map((course, index) => mapTrybeCourseToBookableItem(course, index));
+  return {
+    totalCount,
+    records
+  };
+}
+__name(mapTrybeCoursesToSystemResponse, "mapTrybeCoursesToSystemResponse");
+function mapTrybeCategoriesToSystemResponse(categories, totalCount) {
+  const records = categories.map((category, index) => mapTrybeCategoryToBookableItemCategory(category, index));
+  return {
+    totalCount,
+    records
+  };
+}
+__name(mapTrybeCategoriesToSystemResponse, "mapTrybeCategoriesToSystemResponse");
+function mapTrybeOfferingTypeToBookableItemType(offeringType) {
+  switch (offeringType) {
+    case TRYBE_OFFERING_TYPE_ENUM.APPOINTMENT:
+      return BOOKABLE_ITEM_TYPE_ENUM.APPOINTMENT;
+    case TRYBE_OFFERING_TYPE_ENUM.SESSION:
+      return BOOKABLE_ITEM_TYPE_ENUM.SESSION;
+    case TRYBE_OFFERING_TYPE_ENUM.COURSE:
+      return BOOKABLE_ITEM_TYPE_ENUM.COURSE;
+    default:
+      return BOOKABLE_ITEM_TYPE_ENUM.APPOINTMENT;
+  }
+}
+__name(mapTrybeOfferingTypeToBookableItemType, "mapTrybeOfferingTypeToBookableItemType");
+function mapTrybeCouponCodeOfferingToBookableItem(offering, index) {
+  return {
+    id: BigInt(index + 1),
+    externalId: offering.offering_id,
+    name: offering.offering_name,
+    type: mapTrybeOfferingTypeToBookableItemType(offering.offering_type),
+    status: BOOKABLE_ITEM_STATUS_ENUM.ACTIVE
+  };
+}
+__name(mapTrybeCouponCodeOfferingToBookableItem, "mapTrybeCouponCodeOfferingToBookableItem");
+function mapTrybeCouponCodeOfferingsToSystemResponse(offerings) {
+  const records = offerings.map((offering, index) => mapTrybeCouponCodeOfferingToBookableItem(offering, index));
+  return {
+    totalCount: records.length,
+    records
+  };
+}
+__name(mapTrybeCouponCodeOfferingsToSystemResponse, "mapTrybeCouponCodeOfferingsToSystemResponse");
+function groupByDate(items, getDateKey) {
+  const result = {};
+  for (const item of items) {
+    const key = getDateKey(item);
+    if (!result[key]) result[key] = [];
+    result[key].push(item);
+  }
+  return result;
+}
+__name(groupByDate, "groupByDate");
+function mapTrybeSessionAvailabilityToSystemResponse(sessions) {
+  const filtered = sessions.filter((s) => s.remaining_capacity > 0);
+  const grouped = groupByDate(filtered, (s) => {
+    const dateMatch = s.start_time.match(/^(\d{4}-\d{2}-\d{2})/);
+    return dateMatch ? dateMatch[1] : "";
+  });
+  const dates = Object.entries(grouped).filter(([date]) => date !== "").map(([date, sessionList]) => {
+    const time = sessionList.map((session) => {
+      const fromTime = extractTimeFromIsoString(session.start_time);
+      const toTime = extractTimeFromIsoString(session.end_time);
+      const { start_time: _s, end_time: _e, ...meta } = session;
+      const camelCaseMeta = convertKeysToCamelCase(meta);
+      return {
+        fromTime,
+        toTime,
+        meta: camelCaseMeta
+      };
+    });
+    return {
+      date: new Date(date),
+      meta: {},
+      time
+    };
+  }).sort((a, b) => a.date.getTime() - b.date.getTime());
+  return {
+    dates
+  };
+}
+__name(mapTrybeSessionAvailabilityToSystemResponse, "mapTrybeSessionAvailabilityToSystemResponse");
+function mapTrybeAppointmentAvailabilityToSystemResponse(slots) {
+  const filtered = slots.filter((s) => s.quantity_available > 0);
+  const grouped = groupByDate(filtered, (s) => {
+    const dateMatch = s.start_time.match(/^(\d{4}-\d{2}-\d{2})/);
+    return dateMatch ? dateMatch[1] : "";
+  });
+  const dates = Object.entries(grouped).filter(([date]) => date !== "").map(([date, slotList]) => {
+    const time = slotList.map((slot) => {
+      const fromTime = extractTimeFromIsoString(slot.start_time);
+      const toTime = extractTimeFromIsoString(slot.end_time);
+      const { start_time: _s, end_time: _e, ...meta } = slot;
+      const camelCaseMeta = convertKeysToCamelCase(meta);
+      return {
+        fromTime,
+        toTime,
+        meta: camelCaseMeta
+      };
+    });
+    return {
+      date: new Date(date),
+      meta: {},
+      time
+    };
+  }).sort((a, b) => a.date.getTime() - b.date.getTime());
+  return {
+    dates
+  };
+}
+__name(mapTrybeAppointmentAvailabilityToSystemResponse, "mapTrybeAppointmentAvailabilityToSystemResponse");
+
+// ../../packages/dvss-integration-trybe/src/capabilities/wellness/wellness-management.service.ts
 function _ts_decorate14(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -1081,12 +1538,250 @@ function _ts_decorate14(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate14, "_ts_decorate");
+function _ts_metadata11(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata11, "_ts_metadata");
+exports.TrybeWellnessManagement = class _TrybeWellnessManagement {
+  static {
+    __name(this, "TrybeWellnessManagement");
+  }
+  logger;
+  trafficGatewayService;
+  trybeAuthService;
+  fileName = "wellness-management.service";
+  constructor(logger, trafficGatewayService, trybeAuthService) {
+    this.logger = logger;
+    this.trafficGatewayService = trafficGatewayService;
+    this.trybeAuthService = trybeAuthService;
+  }
+  fetchPractitioners() {
+    throw new Error("Method not implemented.");
+  }
+  fetchWellnessAppointmentSession() {
+    throw new Error("Method not implemented.");
+  }
+  checkWellnessAppointmentSessionAvailability() {
+    throw new Error("Method not implemented.");
+  }
+  createWellnessAppointmentSessionOrder() {
+    throw new Error("Method not implemented.");
+  }
+  addWellnessAppointmentSessionOrderItems() {
+    throw new Error("Method not implemented.");
+  }
+  confirmWellnessAppointmentSessionOrder() {
+    throw new Error("Method not implemented.");
+  }
+  async fetchAppointments(request, integration, loggedInUserId) {
+    this.logger.info(loggedInUserId, this.fetchAppointments.name, this.fileName, `${_TrybeWellnessManagement.name} -> ${this.fetchAppointments.name} Called`, {
+      request
+    });
+    const validatedIntegration = this.trybeAuthService.validateConfig(integration, loggedInUserId);
+    const siteId = validatedIntegration.config.integrationConfig.siteId;
+    if (request.shouldFetchAllAppointments && request.options?.page !== void 0) {
+      throw new Error("Pagination options are not supported when fetching all appointments.");
+    }
+    const query = new URLSearchParams();
+    if (request.options?.page != null) {
+      query.set("page", String(request.options.page));
+    }
+    if (request.options?.count != null) {
+      query.set("per_page", String(request.options.count));
+    }
+    const queryString = query.toString();
+    const apiUrl = `/shop/appointment-types?site_id=${siteId}` + (request.practitionerIds && request.practitionerIds.length > 0 ? `&practitioner_id=${request.practitionerIds.join(",")}` : "") + (queryString ? `&${queryString}` : "");
+    const firstPageResponse = await this.trafficGatewayService.executeIntegrationRequest({
+      apiMethod: HTTP_METHOD.GET,
+      url: apiUrl,
+      baseUrl: validatedIntegration.config.platformConfig.baseUrl,
+      headers: validatedIntegration.headers
+    }, validatedIntegration, loggedInUserId);
+    const records = await fetchAllPages(firstPageResponse, request.shouldFetchAllAppointments, (page) => this.trafficGatewayService.executeIntegrationRequest({
+      apiMethod: HTTP_METHOD.GET,
+      url: `${apiUrl}&page=${page}`,
+      baseUrl: validatedIntegration.config.platformConfig.baseUrl,
+      headers: validatedIntegration.headers
+    }, validatedIntegration, loggedInUserId));
+    return mapTrybeAppointmentsToSystemResponse(records, firstPageResponse.meta.total);
+  }
+  async fetchSessions(request, integration, loggedInUserId) {
+    this.logger.info(loggedInUserId, this.fetchSessions.name, this.fileName, `${_TrybeWellnessManagement.name} -> ${this.fetchSessions.name} Called`, {
+      request
+    });
+    const validatedIntegration = this.trybeAuthService.validateConfig(integration, loggedInUserId);
+    const siteId = validatedIntegration.config.integrationConfig.siteId;
+    if (request.shouldFetchAllSessions && request.options?.page !== void 0) {
+      throw new Error("Pagination options are not supported when fetching all sessions.");
+    }
+    const query = new URLSearchParams();
+    if (request.options?.page != null) {
+      query.set("page", String(request.options.page));
+    }
+    if (request.options?.count != null) {
+      query.set("per_page", String(request.options.count));
+    }
+    const queryString = query.toString();
+    const apiUrl = `/shop/session-types?site_id=${siteId}` + (request.practitionerIds && request.practitionerIds.length > 0 ? `&practitioner_id=${request.practitionerIds.join(",")}` : "") + (queryString ? `&${queryString}` : "");
+    const firstPageResponse = await this.trafficGatewayService.executeIntegrationRequest({
+      apiMethod: HTTP_METHOD.GET,
+      url: apiUrl,
+      baseUrl: validatedIntegration.config.platformConfig.baseUrl,
+      headers: validatedIntegration.headers
+    }, validatedIntegration, loggedInUserId);
+    const records = await fetchAllPages(firstPageResponse, request.shouldFetchAllSessions, (page) => this.trafficGatewayService.executeIntegrationRequest({
+      apiMethod: HTTP_METHOD.GET,
+      url: `${apiUrl}&page=${page}`,
+      baseUrl: validatedIntegration.config.platformConfig.baseUrl,
+      headers: validatedIntegration.headers
+    }, validatedIntegration, loggedInUserId));
+    return mapTrybeSessionsToSystemResponse(records, firstPageResponse.meta.total);
+  }
+  async fetchCourses(request, integration, loggedInUserId) {
+    this.logger.info(loggedInUserId, this.fetchCourses.name, this.fileName, `${_TrybeWellnessManagement.name} -> ${this.fetchCourses.name} Called`, {
+      request
+    });
+    const validatedIntegration = this.trybeAuthService.validateConfig(integration, loggedInUserId);
+    const organisationId = validatedIntegration.config.integrationConfig.organisationId;
+    if (request.shouldFetchAllCourses && request.options?.page !== void 0) {
+      throw new Error("Pagination options are not supported when fetching all courses.");
+    }
+    const query = new URLSearchParams();
+    if (request.options?.page != null) {
+      query.set("page", String(request.options.page));
+    }
+    if (request.options?.count != null) {
+      query.set("per_page", String(request.options.count));
+    }
+    const queryString = query.toString();
+    const apiUrl = `/shop/course-types?organisation_id=${organisationId}` + (queryString ? `&${queryString}` : "");
+    const firstPageResponse = await this.trafficGatewayService.executeIntegrationRequest({
+      apiMethod: HTTP_METHOD.GET,
+      url: apiUrl,
+      baseUrl: validatedIntegration.config.platformConfig.baseUrl,
+      headers: validatedIntegration.headers
+    }, validatedIntegration, loggedInUserId);
+    const records = await fetchAllPages(firstPageResponse, request.shouldFetchAllCourses, (page) => this.trafficGatewayService.executeIntegrationRequest({
+      apiMethod: HTTP_METHOD.GET,
+      url: `${apiUrl}&page=${page}`,
+      baseUrl: validatedIntegration.config.platformConfig.baseUrl,
+      headers: validatedIntegration.headers
+    }, validatedIntegration, loggedInUserId));
+    return mapTrybeCoursesToSystemResponse(records, firstPageResponse.meta.total);
+  }
+  async fetchCategories(request, integration, loggedInUserId) {
+    this.logger.info(loggedInUserId, this.fetchCategories.name, this.fileName, `${_TrybeWellnessManagement.name} -> ${this.fetchCategories.name} Called`, {
+      request
+    });
+    const validatedIntegration = this.trybeAuthService.validateConfig(integration, loggedInUserId);
+    const organisationId = validatedIntegration.config.integrationConfig.organisationId;
+    if (request.shouldFetchAllCategories && request.options?.page !== void 0) {
+      throw new Error("Pagination options are not supported when fetching all categories.");
+    }
+    const query = new URLSearchParams();
+    if (request.options?.page != null) {
+      query.set("page", String(request.options.page));
+    }
+    if (request.options?.count != null) {
+      query.set("per_page", String(request.options.count));
+    }
+    const queryString = query.toString();
+    const apiUrl = `/shop/organisations/${organisationId}/categories` + (queryString ? `?${queryString}` : "");
+    const firstPageResponse = await this.trafficGatewayService.executeIntegrationRequest({
+      apiMethod: HTTP_METHOD.GET,
+      url: apiUrl,
+      baseUrl: validatedIntegration.config.platformConfig.baseUrl,
+      headers: validatedIntegration.headers
+    }, validatedIntegration, loggedInUserId);
+    const records = await fetchAllPages(firstPageResponse, request.shouldFetchAllCategories, (page) => this.trafficGatewayService.executeIntegrationRequest({
+      apiMethod: HTTP_METHOD.GET,
+      url: `${apiUrl}${apiUrl.includes("?") ? "&" : "?"}page=${page}`,
+      baseUrl: validatedIntegration.config.platformConfig.baseUrl,
+      headers: validatedIntegration.headers
+    }, validatedIntegration, loggedInUserId));
+    return mapTrybeCategoriesToSystemResponse(records, firstPageResponse.meta.total);
+  }
+  async fetchBookableItemsFromCredit(request, integration, loggedInUserId) {
+    this.logger.info(loggedInUserId, this.fetchBookableItemsFromCredit.name, this.fileName, `${_TrybeWellnessManagement.name} -> ${this.fetchBookableItemsFromCredit.name} Called`, {
+      request
+    });
+    const validatedIntegration = this.trybeAuthService.validateConfig(integration, loggedInUserId);
+    const query = new URLSearchParams();
+    if (request.options?.page != null) {
+      query.set("page", String(request.options.page));
+    }
+    if (request.options?.count != null) {
+      query.set("per_page", String(request.options.count));
+    }
+    const queryString = query.toString();
+    const apiUrl = `/shop/coupon-codes/${request.couponCodeId}/offering-discounts` + (queryString ? `?${queryString}` : "");
+    const response = await this.trafficGatewayService.executeIntegrationRequest({
+      apiMethod: HTTP_METHOD.GET,
+      url: apiUrl,
+      baseUrl: validatedIntegration.config.platformConfig.baseUrl,
+      headers: validatedIntegration.headers
+    }, validatedIntegration, loggedInUserId);
+    return mapTrybeCouponCodeOfferingsToSystemResponse(response.data.offerings);
+  }
+  async fetchSessionAvailabilityForOffering(request, integration, loggedInUserId) {
+    this.logger.info(loggedInUserId, this.fetchSessionAvailabilityForOffering.name, this.fileName, `${_TrybeWellnessManagement.name} -> ${this.fetchSessionAvailabilityForOffering.name} Called`, {
+      request
+    });
+    const validatedIntegration = this.trybeAuthService.validateConfig(integration, loggedInUserId);
+    const siteId = validatedIntegration.config.integrationConfig.siteId;
+    const formattedDateTimeFrom = formatDateForTrybe(request.dateTimeFrom, true);
+    const formattedDateTimeTo = formatDateForTrybe(request.dateTimeTo, false);
+    const apiUrl = `/shop/item-availability/sessions/${siteId}/${request.externalOfferingBookableItemId}?date_time_from=${encodeURIComponent(formattedDateTimeFrom)}&date_time_to=${encodeURIComponent(formattedDateTimeTo)}&offeringId=${request.externalOfferingBookableItemId}`;
+    const response = await this.trafficGatewayService.executeIntegrationRequest({
+      apiMethod: HTTP_METHOD.GET,
+      url: apiUrl,
+      baseUrl: validatedIntegration.config.platformConfig.baseUrl,
+      headers: validatedIntegration.headers
+    }, validatedIntegration, loggedInUserId);
+    return mapTrybeSessionAvailabilityToSystemResponse(response.data);
+  }
+  async fetchAppointmentAvailabilityForOffering(request, integration, loggedInUserId) {
+    this.logger.info(loggedInUserId, this.fetchAppointmentAvailabilityForOffering.name, this.fileName, `${_TrybeWellnessManagement.name} -> ${this.fetchAppointmentAvailabilityForOffering.name} Called`, {
+      request
+    });
+    const validatedIntegration = this.trybeAuthService.validateConfig(integration, loggedInUserId);
+    const siteId = validatedIntegration.config.integrationConfig.siteId;
+    const formattedDateTimeFrom = formatDateForTrybe(request.dateTimeFrom, true);
+    const formattedDateTimeTo = formatDateForTrybe(request.dateTimeTo, false);
+    const apiUrl = `/shop/item-availability/appointment-slots/${siteId}/${request.externalOfferingBookableItemId}?date_time_from=${encodeURIComponent(formattedDateTimeFrom)}&date_time_to=${encodeURIComponent(formattedDateTimeTo)}&OfferingID=${request.externalOfferingBookableItemId}`;
+    const response = await this.trafficGatewayService.executeIntegrationRequest({
+      apiMethod: HTTP_METHOD.GET,
+      url: apiUrl,
+      baseUrl: validatedIntegration.config.platformConfig.baseUrl,
+      headers: validatedIntegration.headers
+    }, validatedIntegration, loggedInUserId);
+    return mapTrybeAppointmentAvailabilityToSystemResponse(response.data);
+  }
+};
+exports.TrybeWellnessManagement = _ts_decorate14([
+  common.Injectable(),
+  _ts_metadata11("design:type", Function),
+  _ts_metadata11("design:paramtypes", [
+    typeof dvssBackendModuleUtility.LoggerService === "undefined" ? Object : dvssBackendModuleUtility.LoggerService,
+    typeof exports.TrafficGatewayService === "undefined" ? Object : exports.TrafficGatewayService,
+    typeof exports.TrybeAuthService === "undefined" ? Object : exports.TrybeAuthService
+  ])
+], exports.TrybeWellnessManagement);
+
+// ../../packages/dvss-integration-trybe/src/app.module.ts
+function _ts_decorate15(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate15, "_ts_decorate");
 exports.IntegrationTrybeModule = class AppModule2 {
   static {
     __name(this, "AppModule");
   }
 };
-exports.IntegrationTrybeModule = _ts_decorate14([
+exports.IntegrationTrybeModule = _ts_decorate15([
   common.Module({
     imports: [
       // Load environment variables from root .env file
@@ -1105,44 +1800,32 @@ exports.IntegrationTrybeModule = _ts_decorate14([
       AppService2,
       exports.TrybeAuthService,
       exports.TrybeCustomerManagement,
-      exports.TrybeCreditBooking
+      exports.TrybeCreditBooking,
+      exports.TrybeWellnessManagement
     ],
     exports: [
       exports.TrybeAuthService,
       exports.TrybeCustomerManagement,
-      exports.TrybeCreditBooking
+      exports.TrybeCreditBooking,
+      exports.TrybeWellnessManagement
     ]
   })
 ], exports.IntegrationTrybeModule);
 
-// ../../packages/dvss-integration-trybe/src/capabilities/package-management/package-management.service.ts
-var TrybePackageManagement = class {
-  static {
-    __name(this, "TrybePackageManagement");
-  }
-};
-
-// ../../packages/dvss-integration-trybe/src/capabilities/wellness/appointment-booking.service.ts
-var TrybeWellnessAppointmentBooking = class extends BaseWellnessAppointmentBooking {
-  static {
-    __name(this, "TrybeWellnessAppointmentBooking");
-  }
-};
-
 // src/app.module.ts
-function _ts_decorate15(decorators, target, key, desc) {
+function _ts_decorate16(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate15, "_ts_decorate");
+__name(_ts_decorate16, "_ts_decorate");
 exports.OfferingIntegrationManager = class AppModule3 {
   static {
     __name(this, "AppModule");
   }
 };
-exports.OfferingIntegrationManager = _ts_decorate15([
+exports.OfferingIntegrationManager = _ts_decorate16([
   common.Module({
     imports: [
       exports.IntegrationTrybeModule,
@@ -1163,6 +1846,8 @@ exports.OfferingIntegrationManager = _ts_decorate15([
   })
 ], exports.OfferingIntegrationManager);
 
+exports.BOOKABLE_ITEM_STATUS_ENUM = BOOKABLE_ITEM_STATUS_ENUM;
+exports.BOOKABLE_ITEM_TYPE_ENUM = BOOKABLE_ITEM_TYPE_ENUM;
 exports.BaseAccountingContactManagement = BaseAccountingContactManagement;
 exports.BaseAccountingCreditNoteManagement = BaseAccountingCreditNoteManagement;
 exports.BaseAccountingCustomerManagement = BaseAccountingCustomerManagement;
@@ -1179,14 +1864,18 @@ exports.BasePackageManagement = BasePackageManagement;
 exports.BasePayment = BasePayment;
 exports.BasePaymentMethodManagement = BasePaymentMethodManagement;
 exports.BasePaymentUserManagement = BasePaymentUserManagement;
-exports.BaseWellnessAppointmentBooking = BaseWellnessAppointmentBooking;
+exports.BaseWellnessManagement = BaseWellnessManagement;
 exports.CREDIT_FILTER_BY_ENUM = CREDIT_FILTER_BY_ENUM;
 exports.CREDIT_STATUS_ENUM = CREDIT_STATUS_ENUM;
 exports.CREDIT_TYPE_ENUM = CREDIT_TYPE_ENUM;
+exports.DAY_OF_WEEK = DAY_OF_WEEK;
 exports.HTTP_METHOD = HTTP_METHOD;
 exports.INTEGRATION_PROVIDER_ENUM = INTEGRATION_PROVIDER_ENUM;
 exports.TRAFFIC_ROUTER_CONFIGURATION_STORE_KEY = TRAFFIC_ROUTER_CONFIGURATION_STORE_KEY;
-exports.TrybePackageManagement = TrybePackageManagement;
-exports.TrybeWellnessAppointmentBooking = TrybeWellnessAppointmentBooking;
+exports.TRYBE_OFFERING_TYPE_ENUM = TRYBE_OFFERING_TYPE_ENUM;
+exports.convertKeysToCamelCase = convertKeysToCamelCase;
+exports.extractTimeFromIsoString = extractTimeFromIsoString;
+exports.fetchAllPages = fetchAllPages;
+exports.formatDateForTrybe = formatDateForTrybe;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map