@blazeo.com/appointment-client 1.0.6 → 1.0.7

package/dist/calendar/buildUnifiedCalendarView.d.ts

@@ -6,18 +6,26 @@ export interface UnifiedCalendarMember {
     status: number | null;
     /** Full row from Participants/GetInfo (plain object). */
     participantInfo?: Record<string, unknown> | null;
+    __typename?: string;
 }
 export interface UnifiedParticipantWithHours extends UnifiedCalendarMember {
     openingHours: UnifiedOpeningHourRow[];
 }
 export interface UnifiedOpeningHourRow {
+    id?: number | string;
+    createdOn?: string;
+    modifiedOn?: string;
     member: number | string;
+    openingHourId?: string;
+    calendarId?: string;
+    participantId?: string;
     days: string[];
     startHour: number;
     startMinute: number;
     endHour: number;
     endMinute: number;
     off: boolean;
+    __typename?: string;
 }
 export type UnifiedCalendarView = Record<string, unknown> & {
     members: UnifiedCalendarMember[];

package/dist/calendar/buildUnifiedCalendarView.js

@@ -206,6 +206,7 @@ export function buildUnifiedCalendarView(calendarSnapshot, openingHoursRows, par
                 email: email ?? null,
                 status: deriveMemberStatus({}, inf),
                 participantInfo: participantInfoPlain,
+                __typename: "Member",
             });
         }
     }
@@ -227,13 +228,20 @@ export function buildUnifiedCalendarView(calendarSnapshot, openingHoursRows, par
         const endMinute = Number(pick(row, "endMinute", "EndMinute", "end_minute") ?? 0) || 0;
         const off = Boolean(pick(row, "off", "Off"));
         openingHours.push({
+            id: pick(row, "id", "Id") ?? 0,
+            createdOn: pick(row, "createdOn", "CreatedOn", "created_on") ?? "0001-01-01T00:00:00.000Z",
+            modifiedOn: pick(row, "modifiedOn", "ModifiedOn", "modified_on") ?? "0001-01-01T00:00:00.000Z",
             member: memberId,
+            openingHourId: pick(row, "openingHourId", "OpeningHourId", "opening_hour_id") ?? "",
+            calendarId: pick(row, "calendarId", "CalendarId", "calendar_id") ?? "",
+            participantId: pick(row, "participantId", "ParticipantId", "participant_id") ?? "",
             days,
             startHour,
             startMinute,
             endHour,
             endMinute,
             off,
+            __typename: "OpeningHour",
         });
     }
     mergeOpeningHoursBySlot(openingHours);
@@ -242,6 +250,7 @@ export function buildUnifiedCalendarView(calendarSnapshot, openingHoursRows, par
         members,
         openingHours,
         participants: buildNestedParticipants(members, openingHours),
+        __typename: "Calendar",
     };
     return view;
 }
@@ -249,17 +258,23 @@ export function buildUnifiedCalendarView(calendarSnapshot, openingHoursRows, par
  * Groups opening hours into their respective participant objects.
  */
 function buildNestedParticipants(members, openingHours) {
-    return members.map((m) => {
-        const hours = openingHours.filter((oh) => {
+    const nested = [];
+    members.forEach((m) => {
+        const hoursForThisMember = openingHours.filter((oh) => {
             const mid = String(oh.member).trim().toLowerCase();
             const pid = String(m.id).trim().toLowerCase();
             return mid === pid;
         });
         // Remove the 'member' field from the nested opening hours as it's redundant.
-        const nestedHours = hours.map(({ member, ...rest }) => rest);
-        return {
+        const nestedHours = hoursForThisMember.map(({ member, ...rest }) => ({
+            ...rest,
+            __typename: "OpeningHour"
+        }));
+        nested.push({
             ...m,
             openingHours: nestedHours,
-        };
+            __typename: "Member",
+        });
     });
+    return nested;
 }

package/dist/calendar/fetchCalendarDetails.d.ts

@@ -25,49 +25,17 @@ export declare function fetchCalendarDetails(calendarId: string, options?: {
     includeUnifiedCalendarView?: boolean;
     /** Prefer all-participant opening hours for **`calendarView`** when the API returns rows (default `true`). */
     preferAllParticipantOpeningHours?: boolean;
-}): Promise<{
-    calendar: null;
-    cal: null;
-    calendarView: UnifiedCalendarView | null;
-    openingHours: any[];
-    participants: any[];
-    participantsInfo: any;
-    allParticipantOpeningHours: any[] | null;
-    embeddedFromGet: any[];
-    fromCalendarGet: boolean;
-    fromParticipantApi: boolean;
-    participantOpeningHoursResponse: any;
-    rawGet: any;
-    meta: {
-        ok: false;
-        reason: string;
-    };
-} | {
-    calendar: any;
-    cal: any;
-    calendarView: UnifiedCalendarView | null;
-    openingHours: any[];
-    participants: any[];
-    participantsInfo: unknown;
-    allParticipantOpeningHours: any[] | null;
-    embeddedFromGet: any[];
-    fromCalendarGet: boolean;
-    fromParticipantApi: boolean;
-    participantOpeningHoursResponse: any;
-    meta: {
-        calendarViewMemberCount?: number | undefined;
-        calendarViewOpeningHourCount?: number | undefined;
-        ok: true;
-        /** `calendarView.openingHours` came from OpeningHours/All/Get */
-        calendarViewUsedAllParticipantOpeningHours: boolean;
-        reason?: undefined;
-    };
-    rawGet?: undefined;
-}>;
+    /** Optional; applied with `resolveBlazeoConnection` so `CalendarModel.get` sees `baseUrl` without prior global `configure`. */
+    baseUrl?: string;
+    consumer?: string;
+}): Promise<any>;
 /**
  * Single return value only: unified calendar **`calendarView`** —
  * snapshot fields plus **`members`** (with **`participantInfo`**) plus **`openingHours`**
  * (prefers all-participant opening hours when available). Same shape as `fetchCalendarDetails().calendarView`.
  * Returns **`null`** if the calendar cannot be loaded (`CalendarModel.get`).
  */
-export declare function fetchCalendarBundle(calendarId: string): Promise<UnifiedCalendarView | null>;
+export declare function fetchCalendarBundle(calendarId: string, connection?: {
+    baseUrl?: string;
+    consumer?: string;
+}): Promise<UnifiedCalendarView | null>;

package/dist/calendar/fetchCalendarDetails.js

@@ -1,7 +1,8 @@
 import { CalendarModel } from "@blazeo.com/calendar-client";
-import { getSnapshot } from "mobx-state-tree";
+import { ensureBlazeoHttpReady } from "../config/ensureBlazeoHttpReady.js";
 import { unwrapCalendarGetData, pickOpeningHoursArrayFromCalendarPayload, normalizeParticipantOpeningHoursResponse, } from "./fetchCalendarWithOpeningHours.js";
 import { buildUnifiedCalendarView } from "./buildUnifiedCalendarView.js";
+import { mapToDesiredCalendarResponse } from "./mapToDesiredResponse.js";
 /**
  * Normalizes the REST envelope from `calendar.getParticipantOpeningHours()`
  * (`GET /Calendar/Participant/OpeningHours/Get`) into a plain row array.
@@ -83,21 +84,37 @@ function unwrapModelList(raw) {
  * Server still performs multiple HTTP calls; on the client, **`calendarView`** is returned as **one object**.
  */
 export async function fetchCalendarDetails(calendarId, options = {}) {
-    const { includeParticipantsInfo = false, includeUnifiedCalendarView = true, preferAllParticipantOpeningHours = true, } = options;
+    const { includeParticipantsInfo = false, includeUnifiedCalendarView = true, preferAllParticipantOpeningHours = true, baseUrl: optBaseUrl, consumer: optConsumer, } = options;
+    const conn = ensureBlazeoHttpReady({ baseUrl: optBaseUrl, consumer: optConsumer });
+    if (!conn.ok) {
+        return {
+            calendar: null,
+            cal: null,
+            calendarView: null,
+            openingHours: [],
+            participants: [],
+            participantsInfo: null,
+            allParticipantOpeningHours: null,
+            embeddedFromGet: [],
+            fromCalendarGet: false,
+            fromParticipantApi: false,
+            participantOpeningHoursResponse: null,
+            rawGet: null,
+            meta: { ok: false, reason: "missing_base_url", detail: conn.error },
+        };
+    }
     const fetchParticipantsInfo = includeParticipantsInfo || includeUnifiedCalendarView;
     const fetchAllHours = includeUnifiedCalendarView && preferAllParticipantOpeningHours;
-    // Calendar: `GET /Calendar/Get` is used twice (model + raw for embed) — run in parallel.
-    const [cal, rawRes] = await Promise.all([
-        CalendarModel.get(calendarId),
-        CalendarModel.getRaw(calendarId),
-    ]);
-    if (cal == null) {
+    // Calendar: `GET /Calendar/Get` is used to get the raw data first.
+    const rawRes = await CalendarModel.getRaw(calendarId);
+    const payload = unwrapCalendarGetData(rawRes);
+    if (!payload) {
         return {
             calendar: null,
             cal: null,
             calendarView: null,
             openingHours: [],
-            participants: [],
+            participants: null,
             participantsInfo: null,
             allParticipantOpeningHours: null,
             embeddedFromGet: [],
@@ -108,7 +125,9 @@ export async function fetchCalendarDetails(calendarId, options = {}) {
             meta: { ok: false, reason: "calendar_not_found" },
         };
     }
-    const payload = unwrapCalendarGetData(rawRes);
+    // Build the model instance manually to ensure the environment is correctly set.
+    // The static CalendarModel.get in calendar-client has a bug where it wraps env in { env: ... }.
+    const cal = CalendarModel.create({ ...payload, calendarId }, { baseUrl: conn.baseUrl, consumer: conn.consumer });
     const embedded = pickOpeningHoursArrayFromCalendarPayload(payload) ?? [];
     let participantOpeningHoursResponse = null;
     let resolved = embedded.length > 0 ? embedded : null;
@@ -124,17 +143,69 @@ export async function fetchCalendarDetails(calendarId, options = {}) {
     const participantsViaGetPromise = includeUnifiedCalendarView && typeof getCalPart === "function"
         ? getCalPart.call(CalendarModel, calendarId)
         : Promise.resolve(null);
-    const [participants, participantsViaGet, participantsInfo, allHoursRaw] = await Promise.all([
-        CalendarModel.getParticipants(calendarId),
+    const [participantsRaw, participantsViaGet, participantsInfoRaw, allHoursRaw] = await Promise.all([
+        cal.getParticipants(),
         participantsViaGetPromise,
-        fetchParticipantsInfo ? CalendarModel.getParticipantsInfo(calendarId) : Promise.resolve(null),
-        fetchAllHours ? CalendarModel.getAllParticipantOpeningHours(calendarId) : Promise.resolve(null),
+        fetchParticipantsInfo ? cal.getParticipantsInfo() : Promise.resolve(null),
+        fetchAllHours ? cal.getAllParticipantOpeningHours() : Promise.resolve(null),
     ]);
-    const snap = getSnapshot(cal);
-    const calendar = { ...snap, openingHours };
-    const participantList = mergeParticipantSnapshots(unwrapModelList(participants), unwrapModelList(participantsViaGet));
-    const infoUnwrapped = fetchParticipantsInfo ? unwrapModelList(participantsInfo) : [];
-    const infoListForView = infoUnwrapped.length > 0 ? infoUnwrapped : null;
+    const participantList = mergeParticipantSnapshots(unwrapModelList(participantsRaw), unwrapModelList(participantsViaGet));
+    const infoList = unwrapModelList(participantsInfoRaw);
+    // Merge participantList and infoList to ensure we have all members
+    const mergedParticipantsMap = new Map();
+    const getAnyId = (obj) => obj.id ?? obj.Id ?? obj.participantId ?? obj.ParticipantId ?? obj.participant_id;
+    // 1. Add from standard list
+    participantList.forEach((p) => {
+        const id = getAnyId(p);
+        if (id) {
+            mergedParticipantsMap.set(String(id).toLowerCase(), {
+                id: id,
+                name: p.name ?? p.Name ?? p.alias ?? p.Alias ?? "Member",
+                email: p.email ?? p.Email,
+                status: p.status ?? p.Status ?? 0,
+            });
+        }
+    });
+    // 2. Add from info list (fallback/enrich)
+    infoList.forEach((i) => {
+        const id = getAnyId(i);
+        if (!id)
+            return;
+        const key = String(id).toLowerCase();
+        const existing = mergedParticipantsMap.get(key);
+        if (!existing) {
+            mergedParticipantsMap.set(key, {
+                id: id,
+                name: i.alias || i.Alias || i.name || i.Name || "Member",
+                email: i.email || i.Email,
+                status: i.status ?? i.Status ?? (i.isApproved ? 1 : 0),
+            });
+        }
+        else {
+            // Enrich existing with email/name if missing
+            if (!existing.email)
+                existing.email = i.email || i.Email;
+            if (!existing.name || existing.name === "Member") {
+                existing.name = i.alias || i.Alias || i.name || i.Name || existing.name;
+            }
+        }
+    });
+    // 3. Synthetic Fallback: If openingHours reference a member we don't have, add them.
+    openingHours.forEach((oh) => {
+        const mid = oh.member ?? oh.Member ?? oh.participantId ?? oh.ParticipantId;
+        if (mid) {
+            const key = String(mid).toLowerCase();
+            if (!mergedParticipantsMap.has(key)) {
+                mergedParticipantsMap.set(key, {
+                    id: mid,
+                    name: "Member",
+                    email: null,
+                    status: 0,
+                });
+            }
+        }
+    });
+    const finalParticipantList = Array.from(mergedParticipantsMap.values());
     const allParticipantOpeningHours = fetchAllHours ? normalizeAllParticipantOpeningHoursResult(allHoursRaw) : null;
     const openingHoursForUnifiedView = includeUnifiedCalendarView &&
         preferAllParticipantOpeningHours &&
@@ -142,37 +213,34 @@ export async function fetchCalendarDetails(calendarId, options = {}) {
         allParticipantOpeningHours.length > 0
         ? allParticipantOpeningHours
         : openingHours;
-    const calendarView = includeUnifiedCalendarView
-        ? buildUnifiedCalendarView(snap, openingHoursForUnifiedView, participantList, infoListForView)
+    const calendarViewRaw = includeUnifiedCalendarView
+        ? buildUnifiedCalendarView(payload, openingHoursForUnifiedView, finalParticipantList, infoList)
         : null;
+    const calendarView = calendarViewRaw ? mapToDesiredCalendarResponse(calendarViewRaw, calendarViewRaw.openingHours, calendarViewRaw.members) : null;
     const unifiedUsedAllEndpoint = includeUnifiedCalendarView &&
         preferAllParticipantOpeningHours &&
         allParticipantOpeningHours != null &&
         allParticipantOpeningHours.length > 0;
-    return {
-        calendar,
-        cal,
-        calendarView,
-        openingHours,
-        participants: participantList,
-        participantsInfo,
-        allParticipantOpeningHours,
-        embeddedFromGet: embedded,
-        fromCalendarGet: embedded.length > 0,
-        fromParticipantApi: embedded.length === 0 && openingHours.length > 0 && participantOpeningHoursResponse != null,
-        participantOpeningHoursResponse,
-        meta: {
-            ok: true,
-            /** `calendarView.openingHours` came from OpeningHours/All/Get */
-            calendarViewUsedAllParticipantOpeningHours: unifiedUsedAllEndpoint,
-            ...(calendarView != null
-                ? {
-                    calendarViewMemberCount: calendarView.members.length,
-                    calendarViewOpeningHourCount: calendarView.openingHours.length,
-                }
-                : {}),
+    if (!calendarView)
+        return null;
+    // Attach metadata as non-enumerable properties so they don't show up in JSON.stringify
+    // but are still accessible for debugging if needed.
+    Object.defineProperties(calendarView, {
+        _cal: { value: cal, enumerable: false },
+        _participants: { value: participantList, enumerable: false },
+        _openingHours: { value: openingHours, enumerable: false },
+        _rawGet: { value: rawRes, enumerable: false },
+        _meta: {
+            value: {
+                ok: true,
+                calendarViewUsedAllParticipantOpeningHours: unifiedUsedAllEndpoint,
+                calendarViewMemberCount: calendarView.members.length,
+                calendarViewOpeningHourCount: calendarView.openingHours.length,
+            },
+            enumerable: false
         },
-    };
+    });
+    return calendarView;
 }
 /**
  * Single return value only: unified calendar **`calendarView`** —
@@ -180,13 +248,14 @@ export async function fetchCalendarDetails(calendarId, options = {}) {
  * (prefers all-participant opening hours when available). Same shape as `fetchCalendarDetails().calendarView`.
  * Returns **`null`** if the calendar cannot be loaded (`CalendarModel.get`).
  */
-export async function fetchCalendarBundle(calendarId) {
+export async function fetchCalendarBundle(calendarId, connection) {
     const d = await fetchCalendarDetails(calendarId, {
         includeUnifiedCalendarView: true,
         includeParticipantsInfo: true,
         preferAllParticipantOpeningHours: true,
+        ...connection,
     });
-    if (!d.meta.ok)
+    if (!d)
         return null;
-    return d.calendarView;
+    return d;
 }

package/dist/calendar/fetchCalendarWithOpeningHours.d.ts

@@ -22,13 +22,4 @@ export declare function normalizeParticipantOpeningHoursResponse(res: any): {
  * 1. Prefer rows embedded on **GET /Calendar/Get** (`CalendarModel.getRaw` payload — `@blazeo.com/calendar-client` MST omits them).
  * 2. If missing/empty, calls **`calendar.getParticipantOpeningHours()`** (`GET /Calendar/Participant/OpeningHours/Get`).
  */
-export declare function fetchCalendarWithOpeningHours(calendarId: string, options?: any): Promise<{
-    rawGet?: any;
-    calendar: any;
-    cal: any;
-    openingHours: any[];
-    embeddedFromGet: any[];
-    fromCalendarGet: boolean;
-    fromParticipantApi: boolean;
-    participantOpeningHoursResponse: any;
-}>;
+export declare function fetchCalendarWithOpeningHours(calendarId: string, options?: any): Promise<any>;

package/dist/calendar/fetchCalendarWithOpeningHours.js

@@ -1,5 +1,6 @@
 import { CalendarModel } from "@blazeo.com/calendar-client";
-import { getSnapshot } from "mobx-state-tree";
+import { resolveBlazeoConnection } from "./createCalendar.js";
+import { mapToDesiredCalendarResponse } from "./mapToDesiredResponse.js";
 /**
  * Unwrap nested REST shapes: `res.data`, `res.Data`, or `res.data.data`.
  */
@@ -65,10 +66,23 @@ export function normalizeParticipantOpeningHoursResponse(res) {
  * 2. If missing/empty, calls **`calendar.getParticipantOpeningHours()`** (`GET /Calendar/Participant/OpeningHours/Get`).
  */
 export async function fetchCalendarWithOpeningHours(calendarId, options = {}) {
-    const { includeRawGet = false } = options;
+    const { includeRawGet = false, baseUrl, consumer } = options;
+    const { baseUrl: resolvedBase, consumer: resolvedConsumer } = resolveBlazeoConnection({ baseUrl, consumer });
     const rawRes = await CalendarModel.getRaw(calendarId);
-    const cal = await CalendarModel.get(calendarId);
     const payload = unwrapCalendarGetData(rawRes);
+    let cal = null;
+    if (payload) {
+        // Manually create the model instance to fix a bug in calendar-client static get.
+        cal = CalendarModel.create({ ...payload, calendarId }, { baseUrl: resolvedBase, consumer: resolvedConsumer });
+    }
+    if (cal == null) {
+        return {
+            calendar: null,
+            openingHours: [],
+            raw: rawRes,
+            meta: { ok: false, reason: "calendar_not_found" },
+        };
+    }
     const embedded = pickOpeningHoursArrayFromCalendarPayload(payload) ?? [];
     let resolved = embedded.length > 0 ? embedded : null;
     let participantRes = null;
@@ -80,16 +94,21 @@ export async function fetchCalendarWithOpeningHours(calendarId, options = {}) {
             resolved = list;
     }
     const openingHours = Array.isArray(resolved) ? resolved : [];
-    const snap = cal != null ? getSnapshot(cal) : null;
-    const calendar = snap != null ? { ...snap, openingHours } : null;
-    return {
-        calendar,
-        cal,
-        openingHours,
-        embeddedFromGet: embedded,
-        fromCalendarGet: embedded.length > 0,
-        fromParticipantApi: embedded.length === 0 && openingHours.length > 0 && participantRes != null,
-        participantOpeningHoursResponse: participantRes,
-        ...(includeRawGet ? { rawGet: rawRes } : {}),
-    };
+    const mappedOpeningHours = openingHours.map(oh => ({
+        ...oh,
+    }));
+    const rawMembers = payload?.members ?? payload?.Members ?? payload?.participants ?? payload?.Participants;
+    const mappedMembers = Array.isArray(rawMembers)
+        ? rawMembers.map((m) => ({ ...m }))
+        : [];
+    const calendar = mapToDesiredCalendarResponse(payload, openingHours, mappedMembers);
+    if (!calendar)
+        return null;
+    Object.defineProperties(calendar, {
+        _cal: { value: cal, enumerable: false },
+        _openingHours: { value: openingHours, enumerable: false },
+        _embeddedFromGet: { value: embedded, enumerable: false },
+        _rawGet: { value: rawRes, enumerable: false },
+    });
+    return calendar;
 }

package/dist/calendar/getAllParticipantOpeningHours.d.ts

@@ -2,7 +2,10 @@
  * Fetch all participant opening hours for a calendar.
  * Uses `GET /Calendar/Participant/OpeningHours/All/Get`.
  */
-export declare function getAllParticipantOpeningHours(calendarId: string): Promise<{
+export declare function getAllParticipantOpeningHours(calendarId: string, options?: {
+    baseUrl?: string;
+    consumer?: string;
+}): Promise<{
     openingHours: any[];
     raw: any[];
     meta: {

package/dist/calendar/getAllParticipantOpeningHours.js

@@ -1,10 +1,15 @@
 import { CalendarModel } from "@blazeo.com/calendar-client";
+import { ensureBlazeoHttpReady } from "../config/ensureBlazeoHttpReady.js";
 import { normalizeParticipantOpeningHoursResponse } from "./fetchCalendarWithOpeningHours.js";
 /**
  * Fetch all participant opening hours for a calendar.
  * Uses `GET /Calendar/Participant/OpeningHours/All/Get`.
  */
-export async function getAllParticipantOpeningHours(calendarId) {
+export async function getAllParticipantOpeningHours(calendarId, options = {}) {
+    const ready = ensureBlazeoHttpReady(options);
+    if (!ready.ok) {
+        throw new Error(ready.error);
+    }
     const raw = await CalendarModel.getAllParticipantOpeningHours(calendarId);
     // calendar-client static helper returns either `unknown[] | null` or an envelope depending on version/entrypoint.
     if (Array.isArray(raw)) {

package/dist/calendar/getOpeningHours.d.ts

@@ -2,4 +2,7 @@
  * Fetches opening hours for a calendar.
  * Automatically handles embedded calendar-level hours and participant-level fallbacks.
  */
-export declare function getOpeningHours(calendarId: string): Promise<any[]>;
+export declare function getOpeningHours(calendarId: string, options?: {
+    baseUrl?: string;
+    consumer?: string;
+}): Promise<any>;

package/dist/calendar/getOpeningHours.js

@@ -3,7 +3,7 @@ import { fetchCalendarWithOpeningHours } from "./fetchCalendarWithOpeningHours.j
  * Fetches opening hours for a calendar.
  * Automatically handles embedded calendar-level hours and participant-level fallbacks.
  */
-export async function getOpeningHours(calendarId) {
-    const result = await fetchCalendarWithOpeningHours(calendarId);
+export async function getOpeningHours(calendarId, options = {}) {
+    const result = await fetchCalendarWithOpeningHours(calendarId, options);
     return result.openingHours;
 }

package/dist/calendar/getParticipantOpeningHours.js

@@ -1,5 +1,6 @@
 import { CalendarModel } from "@blazeo.com/calendar-client";
-import { normalizeParticipantOpeningHoursResponse } from "./fetchCalendarWithOpeningHours.js";
+import { resolveBlazeoConnection } from "./createCalendar.js";
+import { unwrapCalendarGetData, normalizeParticipantOpeningHoursResponse } from "./fetchCalendarWithOpeningHours.js";
 /**
  * Direct wrapper around `calendar.getParticipantOpeningHours()` for a calendar id.
  *
@@ -8,15 +9,19 @@ import { normalizeParticipantOpeningHoursResponse } from "./fetchCalendarWithOpe
  */
 export async function getParticipantOpeningHours(calendarId, options = {}) {
     try {
-        const cal = await CalendarModel.get(calendarId);
-        if (cal == null) {
+        const { baseUrl, consumer, ...passThrough } = options;
+        const { baseUrl: resolvedBase, consumer: resolvedConsumer } = resolveBlazeoConnection({ baseUrl, consumer });
+        const rawRes = await CalendarModel.getRaw(calendarId);
+        const payload = unwrapCalendarGetData(rawRes);
+        if (!payload) {
             return {
                 openingHours: [],
                 raw: null,
                 meta: { ok: false, reason: "calendar_not_found" },
             };
         }
-        const raw = await cal.getParticipantOpeningHours({ calendarId, ...(options ?? {}) });
+        const cal = CalendarModel.create({ ...payload, calendarId }, { baseUrl: resolvedBase, consumer: resolvedConsumer });
+        const raw = await cal.getParticipantOpeningHours({ calendarId, ...(passThrough ?? {}) });
         const { list } = normalizeParticipantOpeningHoursResponse(raw);
         const openingHours = Array.isArray(list) ? list : [];
         return {

package/dist/calendar/getParticipants.d.ts

@@ -1,4 +1,7 @@
 /**
  * Fetches participants for a calendar.
  */
-export declare function getParticipants(calendarId: string): Promise<any[]>;
+export declare function getParticipants(calendarId: string, options?: {
+    baseUrl?: string;
+    consumer?: string;
+}): Promise<any[]>;

package/dist/calendar/getParticipants.js

@@ -1,8 +1,13 @@
 import { CalendarModel } from "@blazeo.com/calendar-client";
+import { ensureBlazeoHttpReady } from "../config/ensureBlazeoHttpReady.js";
 /**
  * Fetches participants for a calendar.
  */
-export async function getParticipants(calendarId) {
+export async function getParticipants(calendarId, options = {}) {
+    const ready = ensureBlazeoHttpReady(options);
+    if (!ready.ok) {
+        throw new Error(ready.error);
+    }
     const participants = await CalendarModel.getParticipants(calendarId);
     return Array.isArray(participants) ? participants : [];
 }

package/dist/calendar/mapToDesiredResponse.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Maps a raw Blazeo API calendar payload (often PascalCase) to the specific camelCase
+ * shape requested by the user, including typenames and normalized fields.
+ */
+export declare function mapToDesiredCalendarResponse(payload: any, openingHours?: any[], members?: any[]): {
+    id: number | null;
+    durationUnit: number | null;
+    minimumBookingNotice: number | null;
+    minimumBookingNoticeUnit: number | null;
+    minimumCancelationNotice: number | null;
+    minimumCancelationNoticeUnit: number | null;
+    futureLimit: number | null;
+    futureLimitUnit: number | null;
+    bufferTime: number | null;
+    bufferTimeUnit: number | null;
+    calendarLink: any;
+    uuid: any;
+    location: any;
+    bookingPageTitle: any;
+    reminderChannelStatuses: {
+        id: any;
+        calendarId: any;
+        channelId: any;
+        status: boolean;
+        appointmentReminders: any;
+        __typename: string;
+    }[];
+    members: {
+        id: any;
+        name: any;
+        email: any;
+        status: any;
+        __typename: string;
+    }[];
+    createdOn: any;
+    modifiedOn: any;
+    name: any;
+    timeZoneId: any;
+    description: any;
+    assignmentType: number | null;
+    duration: number | null;
+    bookingLimit: number | null;
+    calendarJson: any;
+    isThirdPartySaved: boolean;
+    themeId: number | null;
+    theme: {
+        id: any;
+        color: any;
+        logoUrl: any;
+        __typename: string;
+    } | null;
+    openingHours: {
+        id: any;
+        createdOn: any;
+        modifiedOn: any;
+        member: any;
+        openingHourId: any;
+        calendarId: any;
+        participantId: any;
+        days: any;
+        startHour: any;
+        startMinute: any;
+        endHour: any;
+        endMinute: any;
+        off: boolean;
+        __typename: string;
+    }[];
+    appointmentUserDefinedFields: any;
+    __typename: string;
+} | null;