@blackcode_sa/metaestetics-api 1.15.14 → 1.15.17

package/src/admin/booking/booking.calculator.ts

@@ -13,6 +13,7 @@ import {
 } from "../../types/calendar";
 import { PractitionerClinicWorkingHours } from "../../types/practitioner";
 import { Clinic } from "../../types/clinic";
+import { ResourceCalendarEvent } from "../../types/resource";
 
 /**
  * Calculator for determining available booking slots
@@ -88,11 +89,20 @@ export class BookingAvailabilityCalculator {
       practitionerCalendarEvents
     );
 
+    // Step 5: Apply resource availability constraints (if procedure requires resources)
+    if (request.resourceCalendarEventsMap) {
+      availableIntervals = this.applyResourceAvailability(
+        availableIntervals,
+        request.resourceCalendarEventsMap,
+        timeframe
+      );
+    }
+
     console.log(
       `After all filters, have ${availableIntervals.length} available intervals`
     );
 
-    // Step 5: Generate available slots based on scheduling interval and procedure duration
+    // Step 6: Generate available slots based on scheduling interval and procedure duration
     const availableSlots = this.generateAvailableSlots(
       availableIntervals,
       schedulingIntervalMinutes,
@@ -709,4 +719,132 @@ export class BookingAvailabilityCalculator {
 
     return result;
   }
+
+  /**
+   * Apply resource availability constraints to the available intervals.
+   * For each required resource:
+   *   - Compute each instance's availability (full timeframe minus its busy events)
+   *   - Union all instance availabilities (at least one must be free)
+   * Then intersect all resource availabilities with the current doctor availability.
+   *
+   * @param intervals - Current available intervals (doctor availability)
+   * @param resourceEventsMap - Map of resource data with per-instance calendar events
+   * @param timeframe - Overall timeframe being considered
+   * @returns Intervals where doctor AND all required resources are available
+   */
+  private static applyResourceAvailability(
+    intervals: TimeInterval[],
+    resourceEventsMap: Record<
+      string,
+      {
+        resourceId: string;
+        resourceName: string;
+        quantity: number;
+        instanceEvents: Record<string, ResourceCalendarEvent[]>;
+      }
+    >,
+    timeframe: { start: Timestamp; end: Timestamp }
+  ): TimeInterval[] {
+    if (!intervals.length) return [];
+
+    const resourceIds = Object.keys(resourceEventsMap);
+    if (resourceIds.length === 0) return intervals;
+
+    console.log(
+      `Applying resource availability for ${resourceIds.length} resource(s)`
+    );
+
+    let result = intervals;
+
+    // For each required resource, compute its combined availability and intersect
+    for (const resourceId of resourceIds) {
+      const resourceData = resourceEventsMap[resourceId];
+      const resourceAvailability = this.computeResourceAvailability(
+        resourceData.instanceEvents,
+        timeframe
+      );
+
+      console.log(
+        `Resource "${resourceData.resourceName}" (qty=${resourceData.quantity}): ${resourceAvailability.length} available intervals`
+      );
+
+      // Intersect doctor availability with this resource's availability
+      result = this.intersectIntervals(result, resourceAvailability);
+
+      if (result.length === 0) {
+        console.log(
+          `No availability remaining after applying resource "${resourceData.resourceName}"`
+        );
+        return [];
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Compute combined availability for a single resource across all its instances.
+   * For each instance, subtract its busy events from the full timeframe.
+   * Then union all instance availabilities — if at least one instance is free, the resource is available.
+   *
+   * @param instanceEvents - Calendar events keyed by instanceId
+   * @param timeframe - Overall timeframe
+   * @returns Combined availability intervals for the resource
+   */
+  private static computeResourceAvailability(
+    instanceEvents: Record<string, ResourceCalendarEvent[]>,
+    timeframe: { start: Timestamp; end: Timestamp }
+  ): TimeInterval[] {
+    const instanceIds = Object.keys(instanceEvents);
+    if (instanceIds.length === 0) {
+      // No instances means the full timeframe is available (no constraints)
+      return [{ start: timeframe.start, end: timeframe.end }];
+    }
+
+    // Collect availability intervals from all instances
+    const allInstanceAvailabilities: TimeInterval[] = [];
+
+    for (const instanceId of instanceIds) {
+      const events = instanceEvents[instanceId];
+      // Start with full timeframe
+      let instanceAvailability: TimeInterval[] = [
+        { start: timeframe.start, end: timeframe.end },
+      ];
+
+      // Subtract each busy event from this instance's availability
+      for (const event of events) {
+        // Blocking events always subtract from availability regardless of status.
+        // Booking events only subtract when actively held (pending or confirmed).
+        const isBlockingEvent =
+          (event as any).eventType === CalendarEventType.BLOCKING ||
+          (event as any).eventType === CalendarEventType.BREAK ||
+          (event as any).eventType === CalendarEventType.FREE_DAY;
+
+        const isActiveBooking =
+          event.status === CalendarEventStatus.PENDING ||
+          event.status === CalendarEventStatus.CONFIRMED;
+
+        if (isBlockingEvent || isActiveBooking) {
+          const busyInterval: TimeInterval = {
+            start: event.eventTime.start,
+            end: event.eventTime.end,
+          };
+
+          const newAvailability: TimeInterval[] = [];
+          for (const interval of instanceAvailability) {
+            newAvailability.push(
+              ...this.subtractInterval(interval, busyInterval)
+            );
+          }
+          instanceAvailability = newAvailability;
+        }
+      }
+
+      // Add this instance's available intervals to the combined pool
+      allInstanceAvailabilities.push(...instanceAvailability);
+    }
+
+    // Union (merge) all instance availabilities — at least one instance being free is sufficient
+    return this.mergeOverlappingIntervals(allInstanceAvailabilities);
+  }
 }

package/src/admin/booking/booking.types.ts

@@ -3,6 +3,7 @@ import { Clinic } from "../../types/clinic";
 import { Practitioner } from "../../types/practitioner";
 import { Procedure } from "../../types/procedure";
 import { CalendarEvent } from "../../types/calendar";
+import { ResourceCalendarEvent } from "../../types/resource";
 
 /**
  * Request parameters for calculating available booking slots
@@ -31,6 +32,22 @@ export interface BookingAvailabilityRequest {
 
   /** IANA timezone of the clinic */
   tz: string;
+
+  /**
+   * Resource calendar events per resource, keyed by resourceId.
+   * Each entry contains all instances' events for that resource.
+   * Only present when the procedure has resourceRequirements.
+   */
+  resourceCalendarEventsMap?: Record<
+    string,
+    {
+      resourceId: string;
+      resourceName: string;
+      quantity: number;
+      /** Calendar events keyed by instanceId */
+      instanceEvents: Record<string, ResourceCalendarEvent[]>;
+    }
+  >;
 }
 
 /**

package/src/admin/calendar/README.md

@@ -4,4 +4,59 @@ This directory contains services related to calendar functionality that are inte
 
 ## Services
 
-- `synced-calendars.service.ts`: Manages the synchronization of calendars with external providers. It should not be used on the client side.
+### `calendar.admin.service.ts` — CalendarAdminService
+
+Manages calendar events for practitioners, patients, and clinics. Used by the `AppointmentAggregationService` to update calendar event statuses and times during the appointment lifecycle.
+
+**Key methods:**
+- `updateAppointmentCalendarEventStatus(appointment, newStatus)` — Updates the status of all calendar events for an appointment
+- `updateAppointmentCalendarEventTime(appointment, newEventTime)` — Updates the time range of calendar events (on reschedule)
+- `deleteAppointmentCalendarEvents(appointment)` — Deletes all calendar events for a deleted appointment
+
+---
+
+### `resource-calendar.admin.ts` — ResourceCalendarAdminService
+
+Manages calendar events on **resource instances** throughout the appointment lifecycle. This service is part of the [Clinic Resources System](../../../../docs/RESOURCE_SYSTEM.md).
+
+**Constructor:**
+```typescript
+constructor(firestore?: admin.firestore.Firestore)
+```
+
+**Methods:**
+
+#### `updateResourceBookingEventsStatus(appointment, newStatus)`
+Updates the status of all resource calendar events for an appointment. Iterates through `appointment.resourceBookings` and updates each event's `status` and `updatedAt`.
+
+**Firestore path:** `clinics/{clinicBranchId}/resources/{resourceId}/instances/{instanceId}/calendar/{calendarEventId}`
+
+#### `updateResourceBookingEventsTime(appointment, newEventTime)`
+Updates the time range of all resource calendar events (used during reschedule). Updates `eventTime.start`, `eventTime.end`, and `updatedAt`.
+
+#### `deleteResourceBookingEvents(appointment)`
+Deletes all resource calendar events for a deleted appointment. Uses a Firestore batch to delete all events atomically.
+
+**Lifecycle integration:** Called by `AppointmentAggregationService` during appointment transitions:
+
+| Transition | Action |
+|---|---|
+| PENDING → CONFIRMED | `updateResourceBookingEventsStatus(after, CONFIRMED)` |
+| RESCHEDULED → CONFIRMED | `updateResourceBookingEventsStatus(after, CONFIRMED)` |
+| Any → CANCELLED / NO_SHOW | `updateResourceBookingEventsStatus(after, CANCELLED)` |
+| Any → COMPLETED | `updateResourceBookingEventsStatus(after, COMPLETED)` |
+| RESCHEDULED_BY_CLINIC | `updateResourceBookingEventsTime()` + `updateResourceBookingEventsStatus(after, PENDING)` |
+| Time change (same status) | `updateResourceBookingEventsTime()` |
+| Appointment deleted | `deleteResourceBookingEvents()` |
+
+**Safety:** All methods check for `appointment.resourceBookings` before proceeding. If no resource bookings exist (backward-compatible appointments), the methods return early.
+
+---
+
+### `synced-calendars.service.ts`
+
+Manages the synchronization of calendars with external providers. It should not be used on the client side.
+
+## Export
+
+`index.ts` exports `CalendarAdminService` and `ResourceCalendarAdminService`.

package/src/admin/calendar/index.ts

@@ -1 +1,2 @@
 export * from "./calendar.admin.service";
+export * from "./resource-calendar.admin";

package/src/admin/calendar/resource-calendar.admin.ts

@@ -0,0 +1,198 @@
+import * as admin from "firebase-admin";
+import { Appointment } from "../../types/appointment";
+import { CalendarEventStatus } from "../../types/calendar";
+import { Logger } from "../logger";
+import { CLINICS_COLLECTION } from "../../types/clinic";
+import {
+  RESOURCES_COLLECTION,
+  RESOURCE_INSTANCES_SUBCOLLECTION,
+  RESOURCE_CALENDAR_SUBCOLLECTION,
+  ResourceBookingInfo,
+} from "../../types/resource";
+
+/**
+ * @class ResourceCalendarAdminService
+ * @description Handles administrative tasks for resource calendar events linked to appointments,
+ * such as status updates, time changes, or deletions during appointment lifecycle events.
+ */
+export class ResourceCalendarAdminService {
+  private db: admin.firestore.Firestore;
+
+  constructor(firestore?: admin.firestore.Firestore) {
+    this.db = firestore || admin.firestore();
+    Logger.info("[ResourceCalendarAdminService] Initialized.");
+  }
+
+  /**
+   * Builds the Firestore document path for a resource calendar event.
+   */
+  private getResourceCalendarEventPath(
+    clinicBranchId: string,
+    booking: ResourceBookingInfo
+  ): string {
+    return `${CLINICS_COLLECTION}/${clinicBranchId}/${RESOURCES_COLLECTION}/${booking.resourceId}/${RESOURCE_INSTANCES_SUBCOLLECTION}/${booking.resourceInstanceId}/${RESOURCE_CALENDAR_SUBCOLLECTION}/${booking.calendarEventId}`;
+  }
+
+  /**
+   * Updates the status of all resource calendar events associated with a given appointment.
+   *
+   * @param appointment - The appointment object containing resourceBookings.
+   * @param newStatus - The new CalendarEventStatus to set.
+   */
+  async updateResourceBookingEventsStatus(
+    appointment: Appointment,
+    newStatus: CalendarEventStatus
+  ): Promise<void> {
+    const resourceBookings = appointment.resourceBookings;
+    if (!resourceBookings || resourceBookings.length === 0) {
+      Logger.debug(
+        `[ResourceCalendarAdminService] No resource bookings on appointment ${appointment.id}, skipping status update.`
+      );
+      return;
+    }
+
+    Logger.info(
+      `[ResourceCalendarAdminService] Updating ${resourceBookings.length} resource calendar event(s) to ${newStatus} for appointment ${appointment.id}`
+    );
+
+    const batch = this.db.batch();
+    const serverTimestamp = admin.firestore.FieldValue.serverTimestamp();
+
+    for (const booking of resourceBookings) {
+      const eventPath = this.getResourceCalendarEventPath(
+        appointment.clinicBranchId,
+        booking
+      );
+      const eventRef = this.db.doc(eventPath);
+      batch.update(eventRef, {
+        status: newStatus,
+        updatedAt: serverTimestamp,
+      });
+      Logger.debug(
+        `[ResourceCalendarAdminService] Added status update for resource event ${booking.calendarEventId} (${booking.resourceName} / ${booking.resourceInstanceLabel})`
+      );
+    }
+
+    try {
+      await batch.commit();
+      Logger.info(
+        `[ResourceCalendarAdminService] Successfully updated ${resourceBookings.length} resource calendar event statuses for appointment ${appointment.id}.`
+      );
+    } catch (error) {
+      Logger.error(
+        `[ResourceCalendarAdminService] Error updating resource calendar event statuses for appointment ${appointment.id}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Updates the eventTime (start and end) of all resource calendar events
+   * associated with a given appointment.
+   *
+   * @param appointment - The appointment object containing resourceBookings.
+   * @param newEventTime - The new event time with admin Timestamps.
+   */
+  async updateResourceBookingEventsTime(
+    appointment: Appointment,
+    newEventTime: {
+      start: admin.firestore.Timestamp;
+      end: admin.firestore.Timestamp;
+    }
+  ): Promise<void> {
+    const resourceBookings = appointment.resourceBookings;
+    if (!resourceBookings || resourceBookings.length === 0) {
+      Logger.debug(
+        `[ResourceCalendarAdminService] No resource bookings on appointment ${appointment.id}, skipping time update.`
+      );
+      return;
+    }
+
+    Logger.info(
+      `[ResourceCalendarAdminService] Updating ${resourceBookings.length} resource calendar event time(s) for appointment ${appointment.id}`
+    );
+
+    const batch = this.db.batch();
+    const serverTimestamp = admin.firestore.FieldValue.serverTimestamp();
+
+    for (const booking of resourceBookings) {
+      const eventPath = this.getResourceCalendarEventPath(
+        appointment.clinicBranchId,
+        booking
+      );
+      const eventRef = this.db.doc(eventPath);
+      batch.update(eventRef, {
+        eventTime: {
+          start: newEventTime.start,
+          end: newEventTime.end,
+        },
+        updatedAt: serverTimestamp,
+      });
+      Logger.debug(
+        `[ResourceCalendarAdminService] Added time update for resource event ${booking.calendarEventId} (${booking.resourceName} / ${booking.resourceInstanceLabel})`
+      );
+    }
+
+    try {
+      await batch.commit();
+      Logger.info(
+        `[ResourceCalendarAdminService] Successfully updated ${resourceBookings.length} resource calendar event times for appointment ${appointment.id}.`
+      );
+    } catch (error) {
+      Logger.error(
+        `[ResourceCalendarAdminService] Error updating resource calendar event times for appointment ${appointment.id}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Deletes all resource calendar events associated with a given appointment.
+   *
+   * @param appointment - The appointment object containing resourceBookings.
+   */
+  async deleteResourceBookingEvents(
+    appointment: Appointment
+  ): Promise<void> {
+    const resourceBookings = appointment.resourceBookings;
+    if (!resourceBookings || resourceBookings.length === 0) {
+      Logger.debug(
+        `[ResourceCalendarAdminService] No resource bookings on appointment ${appointment.id}, skipping deletion.`
+      );
+      return;
+    }
+
+    Logger.info(
+      `[ResourceCalendarAdminService] Deleting ${resourceBookings.length} resource calendar event(s) for appointment ${appointment.id}`
+    );
+
+    const batch = this.db.batch();
+
+    for (const booking of resourceBookings) {
+      const eventPath = this.getResourceCalendarEventPath(
+        appointment.clinicBranchId,
+        booking
+      );
+      const eventRef = this.db.doc(eventPath);
+      batch.delete(eventRef);
+      Logger.debug(
+        `[ResourceCalendarAdminService] Added deletion for resource event ${booking.calendarEventId} (${booking.resourceName} / ${booking.resourceInstanceLabel})`
+      );
+    }
+
+    try {
+      await batch.commit();
+      Logger.info(
+        `[ResourceCalendarAdminService] Successfully deleted ${resourceBookings.length} resource calendar events for appointment ${appointment.id}.`
+      );
+    } catch (error) {
+      Logger.error(
+        `[ResourceCalendarAdminService] Error deleting resource calendar events for appointment ${appointment.id}:`,
+        error
+      );
+      throw error;
+    }
+  }
+}

package/src/config/index.ts

@@ -12,6 +12,7 @@ export {
   PERMISSION_KEYS,
   TIER_CONFIG,
   DEFAULT_ROLE_PERMISSIONS,
+  DEFAULT_PLAN_CONFIG,
   resolveEffectiveTier,
 } from "./tiers.config";
 export type { PermissionKey } from "./tiers.config";

package/src/config/tiers.config.ts

@@ -1,5 +1,6 @@
 import { ClinicRole } from '../types/clinic/rbac.types';
 import type { TierConfig } from '../types/clinic/rbac.types';
+import type { PlanConfigDocument } from '../types/system/planConfig.types';
 
 /**
  * Permission keys used for role-based access control.
@@ -27,6 +28,12 @@ export const PERMISSION_KEYS = {
   'procedures.edit': true,
   'procedures.delete': true,
 
+  // Resources
+  'resources.view': true,
+  'resources.create': true,
+  'resources.edit': true,
+  'resources.delete': true,
+
   // Patients
   'patients.view': true,
   'patients.edit': true,
@@ -57,11 +64,11 @@ export type PermissionKey = keyof typeof PERMISSION_KEYS;
  * - Appointments and messages are NEVER limited (bad patient UX)
  * - Providers are per branch, not per clinic group
  * - Procedures are per provider (each provider gets this allowance)
- * - Add-ons available on Connect/Pro: +1 branch, +1 provider, +10 procedures
+ * - Add-ons available on Connect/Pro: +1 branch, +1 provider, +5 treatments
  *
- * Free: 1 branch, 1 provider/branch, 3 procedures/provider
- * Connect (CHF 59/mo): 1 branch, 3 providers/branch, 10 procedures/provider
- * Pro (CHF 149/mo): 3 branches, 10 providers/branch, 20 procedures/provider
+ * Free: 1 branch, 1 provider/branch, 3 treatments/provider
+ * Connect (CHF 199/mo): 1 branch, 3 providers/branch, 10 treatments/provider
+ * Pro (CHF 449/mo): 3 branches, 5 providers/branch, 20 treatments/provider
  */
 export const TIER_CONFIG: Record<string, TierConfig> = {
   free: {
@@ -86,7 +93,7 @@ export const TIER_CONFIG: Record<string, TierConfig> = {
     tier: 'pro',
     name: 'Pro',
     limits: {
-      maxProvidersPerBranch: 10,
+      maxProvidersPerBranch: 5,
       maxProceduresPerProvider: 20,
       maxBranches: 3,
     },
@@ -111,6 +118,10 @@ export const DEFAULT_ROLE_PERMISSIONS: Record<ClinicRole, Record<string, boolean
     'procedures.create': true,
     'procedures.edit': true,
     'procedures.delete': true,
+    'resources.view': true,
+    'resources.create': true,
+    'resources.edit': true,
+    'resources.delete': true,
     'patients.view': true,
     'patients.edit': true,
     'providers.view': true,
@@ -133,6 +144,10 @@ export const DEFAULT_ROLE_PERMISSIONS: Record<ClinicRole, Record<string, boolean
     'procedures.create': true,
     'procedures.edit': true,
     'procedures.delete': true,
+    'resources.view': true,
+    'resources.create': true,
+    'resources.edit': true,
+    'resources.delete': true,
     'patients.view': true,
     'patients.edit': true,
     'providers.view': true,
@@ -155,6 +170,10 @@ export const DEFAULT_ROLE_PERMISSIONS: Record<ClinicRole, Record<string, boolean
     'procedures.create': false,
     'procedures.edit': false,
     'procedures.delete': false,
+    'resources.view': true,
+    'resources.create': false,
+    'resources.edit': false,
+    'resources.delete': false,
     'patients.view': true,
     'patients.edit': true,
     'providers.view': true,
@@ -177,6 +196,10 @@ export const DEFAULT_ROLE_PERMISSIONS: Record<ClinicRole, Record<string, boolean
     'procedures.create': false,
     'procedures.edit': false,
     'procedures.delete': false,
+    'resources.view': true,
+    'resources.create': false,
+    'resources.edit': false,
+    'resources.delete': false,
     'patients.view': true,
     'patients.edit': false,
     'providers.view': true,
@@ -199,6 +222,10 @@ export const DEFAULT_ROLE_PERMISSIONS: Record<ClinicRole, Record<string, boolean
     'procedures.create': false,
     'procedures.edit': false,
     'procedures.delete': false,
+    'resources.view': true,
+    'resources.create': false,
+    'resources.edit': false,
+    'resources.delete': false,
     'patients.view': true,
     'patients.edit': false,
     'providers.view': true,
@@ -210,6 +237,95 @@ export const DEFAULT_ROLE_PERMISSIONS: Record<ClinicRole, Record<string, boolean
   },
 };
 
+/**
+ * Default PlanConfigDocument — used as fallback when Firestore `system/planConfig`
+ * doesn't exist or is unavailable. Also used as the seed value.
+ *
+ * Stripe price IDs reference the SKS Innovation SA sandbox account.
+ */
+export const DEFAULT_PLAN_CONFIG: PlanConfigDocument = {
+  version: 1,
+  updatedAt: null,
+  updatedBy: 'system',
+
+  tiers: {
+    free: {
+      name: 'Free',
+      limits: { maxProvidersPerBranch: 1, maxProceduresPerProvider: 3, maxBranches: 1 },
+    },
+    connect: {
+      name: 'Connect',
+      limits: { maxProvidersPerBranch: 3, maxProceduresPerProvider: 10, maxBranches: 1 },
+    },
+    pro: {
+      name: 'Pro',
+      limits: { maxProvidersPerBranch: 5, maxProceduresPerProvider: 20, maxBranches: 3 },
+    },
+  },
+
+  plans: {
+    FREE: {
+      priceId: null,
+      priceMonthly: 0,
+      currency: 'CHF',
+      description: 'Get started with basic access',
+      stripeProductId: null,
+    },
+    CONNECT: {
+      priceId: 'price_1TD0l7AaFI0fqFWNC8Lg3QJG',
+      priceMonthly: 199,
+      currency: 'CHF',
+      description: 'Consultation tools and integrated booking',
+      stripeProductId: null,
+    },
+    PRO: {
+      priceId: 'price_1TD0lEAaFI0fqFWN3tzCrfUb',
+      priceMonthly: 449,
+      currency: 'CHF',
+      description: 'Complete clinic management with CRM and analytics',
+      stripeProductId: null,
+    },
+  },
+
+  addons: {
+    seat: {
+      priceId: 'price_1TD0lKAaFI0fqFWNH9pQgTzI',
+      pricePerUnit: 39,
+      currency: 'CHF',
+      allowedTiers: ['connect', 'pro'],
+    },
+    branch: {
+      connect: { priceId: 'price_1TD0lSAaFI0fqFWNjsPvzW1T', pricePerUnit: 119, currency: 'CHF' },
+      pro: { priceId: 'price_1TD0lTAaFI0fqFWNYxUnvUxH', pricePerUnit: 279, currency: 'CHF' },
+      allowedTiers: ['connect', 'pro'],
+    },
+    procedure: {
+      priceId: 'price_1TCL3eAaFI0fqFWNJVuMYjii',
+      pricePerBlock: 19,
+      proceduresPerBlock: 5,
+      currency: 'CHF',
+      allowedTiers: ['connect', 'pro'],
+    },
+  },
+
+  priceToModel: {
+    'price_1TD0l7AaFI0fqFWNC8Lg3QJG': 'connect',
+    'price_1TD0lEAaFI0fqFWN3tzCrfUb': 'pro',
+  },
+
+  priceToType: {
+    'price_1TD0l7AaFI0fqFWNC8Lg3QJG': 'CONNECT',
+    'price_1TD0lEAaFI0fqFWN3tzCrfUb': 'PRO',
+  },
+
+  addonPriceIds: [
+    'price_1TD0lKAaFI0fqFWNH9pQgTzI',  // seat
+    'price_1TD0lSAaFI0fqFWNjsPvzW1T',  // branch connect
+    'price_1TD0lTAaFI0fqFWNYxUnvUxH',  // branch pro
+    'price_1TCL3eAaFI0fqFWNJVuMYjii',  // procedure
+  ],
+};
+
 /**
  * Maps subscription model strings to tier keys.
  */

package/src/services/index.ts

@@ -9,6 +9,7 @@ export * from "./notifications";
 export * from "./patient";
 export * from "./practitioner";
 export * from "./procedure";
+export * from "./resource";
 export * from "./reviews";
 export * from "./user";
 export * from "./base.service";