@blazeo.com/appointment-client 1.0.4 → 1.0.6

package/dist/calendar/createCalendar.d.ts

@@ -1,51 +1,81 @@
-import type { IStateTreeNode } from "mobx-state-tree";
-import type { CalendarInput } from "../types/calendar.js";
-export type CreateCalendarOptions = {
-    /** Overrides packaged defaults / global `configure` when set. */
-    baseUrl?: string;
-    consumer?: string;
-    /**
-     * When true, only builds the MST `Calendar` node (no HTTP).
-     * Default false: calls `calendar.create()` → POST `/Calendar/Create`.
-     */
-    localOnly?: boolean;
-};
-/** Typical Blazeo `reqPost` / `calendar.create()` result shape. */
-export type BlazeoCalendarCreateResponse = {
-    status: string;
-    message?: string;
-    data?: unknown;
-};
-export type CreateCalendarSuccess = {
-    ok: true;
-    calendar: IStateTreeNode;
-    apiResponse?: BlazeoCalendarCreateResponse;
-};
-export type CreateCalendarFailure = {
-    ok: false;
-    error: string;
-    apiResponse?: BlazeoCalendarCreateResponse;
-};
-export type CreateCalendarResult = CreateCalendarSuccess | CreateCalendarFailure;
 /** Merge per-call options with global Blazeo config (defaults file + `configure`). */
-export declare function resolveBlazeoConnection(options?: CreateCalendarOptions): {
-    baseUrl?: string;
-    consumer?: string;
+export declare function resolveBlazeoConnection(options?: any): {
+    baseUrl: any;
+    consumer: any;
 };
 /** Shared MST `env` for Blazeo models (`Calendar`, `Event`, …). */
-export declare function buildModelEnv(baseUrl: string | undefined, consumer: string | undefined, forLocalOnly: boolean): Record<string, unknown>;
+export declare function buildModelEnv(baseUrl: string | undefined, consumer: string | undefined, forLocalOnly: boolean): any;
 /**
  * Uses {@link resolveBlazeoConnection} (defaults + `configure` + optional overrides),
  * then `CalendarModel.create` and `calendar.create()` unless `localOnly`.
  */
-export declare function createCalendarAsync(calendar: CalendarInput, options?: CreateCalendarOptions): Promise<CreateCalendarResult>;
+export declare function createCalendarAsync(calendar: any, options?: any): Promise<{
+    ok: boolean;
+    error: string;
+    calendar?: undefined;
+    apiResponse?: undefined;
+} | {
+    ok: boolean;
+    calendar: any;
+    error?: undefined;
+    apiResponse?: undefined;
+} | {
+    ok: boolean;
+    error: any;
+    apiResponse: any;
+    calendar?: undefined;
+} | {
+    ok: boolean;
+    calendar: any;
+    apiResponse: any;
+    error?: undefined;
+}>;
 /**
  * Uses {@link resolveBlazeoConnection}, builds a `Calendar` node from {@link mapCalendarBOToSnapshot},
  * then `calendar.update()` → POST `/Calendar/Event/Update` unless `localOnly`.
  */
-export declare function updateCalendarAsync(calendar: CalendarInput, options?: CreateCalendarOptions): Promise<CreateCalendarResult>;
+export declare function updateCalendarAsync(calendar: any, options?: any): Promise<{
+    ok: boolean;
+    error: string;
+    calendar?: undefined;
+    apiResponse?: undefined;
+} | {
+    ok: boolean;
+    calendar: any;
+    error?: undefined;
+    apiResponse?: undefined;
+} | {
+    ok: boolean;
+    error: any;
+    apiResponse: any;
+    calendar?: undefined;
+} | {
+    ok: boolean;
+    calendar: any;
+    apiResponse: any;
+    error?: undefined;
+}>;
 /**
  * Removes a calendar via `calendar.remove()` → GET `/Calendar/Remove?calendar_id=…`.
  */
-export declare function deleteCalendarAsync(calendarId: string, options?: CreateCalendarOptions): Promise<CreateCalendarResult>;
-//# sourceMappingURL=createCalendar.d.ts.map
+export declare function deleteCalendarAsync(calendarId: string, options?: any): Promise<{
+    ok: boolean;
+    error: string;
+    calendar?: undefined;
+    apiResponse?: undefined;
+} | {
+    ok: boolean;
+    calendar: any;
+    error?: undefined;
+    apiResponse?: undefined;
+} | {
+    ok: boolean;
+    error: any;
+    apiResponse: any;
+    calendar?: undefined;
+} | {
+    ok: boolean;
+    calendar: any;
+    apiResponse: any;
+    error?: undefined;
+}>;

package/dist/calendar/createCalendar.js

@@ -110,8 +110,7 @@ export async function updateCalendarAsync(calendar, options = {}) {
         const baseUrl = resolvedBase;
         const consumer = resolvedConsumer;
         const snapshot = mapCalendarBOToSnapshot(calendar);
-        if (!options.localOnly &&
-            !(calendar.calendarId?.trim())) {
+        if (!options.localOnly && !(calendar.calendarId?.trim())) {
             return {
                 ok: false,
                 error: "calendarId is required for update. Pass an existing id.",
@@ -205,4 +204,3 @@ export async function deleteCalendarAsync(calendarId, options = {}) {
         return { ok: false, error: message };
     }
 }
-//# sourceMappingURL=createCalendar.js.map

package/dist/calendar/fetchCalendarDetails.d.ts

@@ -0,0 +1,73 @@
+import { type UnifiedCalendarView } from "./buildUnifiedCalendarView.js";
+/**
+ * Normalizes the REST envelope from `calendar.getParticipantOpeningHours()`
+ * (`GET /Calendar/Participant/OpeningHours/Get`) into a plain row array.
+ */
+export declare function normalizeOpeningHours(res: any): any[];
+/**
+ * Calendar + legacy opening hours + full detail bundle (`fetchCalendarDetails`), **or**
+ * only the **single unified object** via {@link fetchCalendarBundle}.
+ *
+ * **Flow**
+ * 1. **Calendar** — parallel `CalendarModel.get` + `getRaw` (both `GET /Calendar/Get`: model + raw envelope).
+ * 2. **Legacy `openingHours`** — embed from raw, else `getParticipantOpeningHours` (narrow endpoint).
+ * 3. **`calendarView` (one object)** — in parallel after calendar is known:
+ *    - `GET /Calendar/Participant/All` and optional `/Participant/Get` merge when both return rows.
+ *    - `GET /Calendar/Participants/GetInfo`
+ *    - `GET /Calendar/Participant/OpeningHours/All/Get` when options enable it (`preferAllParticipantOpeningHours`)
+ *    Then `calendarView` = calendar snapshot fields + **`members`** (with **`participantInfo`**) + **`openingHours`**
+ *    (`openingHours[].member` → `members[].id`).
+ *
+ * Server still performs multiple HTTP calls; on the client, **`calendarView`** is returned as **one object**.
+ */
+export declare function fetchCalendarDetails(calendarId: string, options?: {
+    includeParticipantsInfo?: boolean;
+    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;
+}>;
+/**
+ * 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>;

package/dist/calendar/fetchCalendarDetails.js

@@ -0,0 +1,192 @@
+import { CalendarModel } from "@blazeo.com/calendar-client";
+import { getSnapshot } from "mobx-state-tree";
+import { unwrapCalendarGetData, pickOpeningHoursArrayFromCalendarPayload, normalizeParticipantOpeningHoursResponse, } from "./fetchCalendarWithOpeningHours.js";
+import { buildUnifiedCalendarView } from "./buildUnifiedCalendarView.js";
+/**
+ * Normalizes the REST envelope from `calendar.getParticipantOpeningHours()`
+ * (`GET /Calendar/Participant/OpeningHours/Get`) into a plain row array.
+ */
+export function normalizeOpeningHours(res) {
+    const { list } = normalizeParticipantOpeningHoursResponse(res);
+    return Array.isArray(list) ? list : [];
+}
+function normalizeAllParticipantOpeningHoursResult(raw) {
+    if (Array.isArray(raw))
+        return raw;
+    const { list } = normalizeParticipantOpeningHoursResponse(raw);
+    return Array.isArray(list) ? list : [];
+}
+/** Prefer union of `/Participant/All` and `/Participant/Get` so members reconcile when either list is incomplete. */
+function mergeParticipantSnapshots(a, b) {
+    const byKey = new Map();
+    const ingest = (p) => {
+        if (p == null)
+            return;
+        const participantId = String(p.participantId ?? p.ParticipantId ?? p.participant_id ?? "").trim().toLowerCase();
+        const calPartId = String(p.calendarParticipantId ?? p.CalendarParticipantId ?? p.calendarparticipant_id ?? "").trim()
+            .toLowerCase();
+        const key = participantId || calPartId;
+        if (!key)
+            return;
+        if (!byKey.has(key))
+            byKey.set(key, p);
+    };
+    if (Array.isArray(a))
+        a.forEach(ingest);
+    if (Array.isArray(b))
+        b.forEach(ingest);
+    return [...byKey.values()];
+}
+/** Coerce MST / envelope / nested `data` shapes into a plain array for participants and GetInfo lists. */
+function unwrapModelList(raw) {
+    if (raw == null)
+        return [];
+    if (Array.isArray(raw))
+        return raw;
+    if (typeof raw === "string") {
+        try {
+            return unwrapModelList(JSON.parse(raw));
+        }
+        catch {
+            return [];
+        }
+    }
+    if (typeof raw !== "object")
+        return [];
+    const topArr = raw.items ?? raw.Items;
+    if (Array.isArray(topArr))
+        return topArr;
+    const d = raw.data ?? raw.Data;
+    if (Array.isArray(d))
+        return d;
+    if (d != null && typeof d === "object") {
+        const inner = d.data ?? d.Data ?? d.items ?? d.Items;
+        if (Array.isArray(inner))
+            return inner;
+    }
+    return [];
+}
+/**
+ * Calendar + legacy opening hours + full detail bundle (`fetchCalendarDetails`), **or**
+ * only the **single unified object** via {@link fetchCalendarBundle}.
+ *
+ * **Flow**
+ * 1. **Calendar** — parallel `CalendarModel.get` + `getRaw` (both `GET /Calendar/Get`: model + raw envelope).
+ * 2. **Legacy `openingHours`** — embed from raw, else `getParticipantOpeningHours` (narrow endpoint).
+ * 3. **`calendarView` (one object)** — in parallel after calendar is known:
+ *    - `GET /Calendar/Participant/All` and optional `/Participant/Get` merge when both return rows.
+ *    - `GET /Calendar/Participants/GetInfo`
+ *    - `GET /Calendar/Participant/OpeningHours/All/Get` when options enable it (`preferAllParticipantOpeningHours`)
+ *    Then `calendarView` = calendar snapshot fields + **`members`** (with **`participantInfo`**) + **`openingHours`**
+ *    (`openingHours[].member` → `members[].id`).
+ *
+ * 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 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) {
+        return {
+            calendar: null,
+            cal: null,
+            calendarView: null,
+            openingHours: [],
+            participants: [],
+            participantsInfo: null,
+            allParticipantOpeningHours: null,
+            embeddedFromGet: [],
+            fromCalendarGet: false,
+            fromParticipantApi: false,
+            participantOpeningHoursResponse: null,
+            rawGet: rawRes,
+            meta: { ok: false, reason: "calendar_not_found" },
+        };
+    }
+    const payload = unwrapCalendarGetData(rawRes);
+    const embedded = pickOpeningHoursArrayFromCalendarPayload(payload) ?? [];
+    let participantOpeningHoursResponse = null;
+    let resolved = embedded.length > 0 ? embedded : null;
+    if ((resolved == null || resolved.length === 0) && cal != null) {
+        participantOpeningHoursResponse = await cal.getParticipantOpeningHours({ calendarId });
+        const { list } = normalizeParticipantOpeningHoursResponse(participantOpeningHoursResponse);
+        if (list != null && list.length > 0)
+            resolved = list;
+    }
+    const openingHours = Array.isArray(resolved) ? resolved : [];
+    // 2) Participants + participant info + all participant opening hours (parallel)
+    const getCalPart = CalendarModel.getCalendarParticipant;
+    const participantsViaGetPromise = includeUnifiedCalendarView && typeof getCalPart === "function"
+        ? getCalPart.call(CalendarModel, calendarId)
+        : Promise.resolve(null);
+    const [participants, participantsViaGet, participantsInfo, allHoursRaw] = await Promise.all([
+        CalendarModel.getParticipants(calendarId),
+        participantsViaGetPromise,
+        fetchParticipantsInfo ? CalendarModel.getParticipantsInfo(calendarId) : Promise.resolve(null),
+        fetchAllHours ? CalendarModel.getAllParticipantOpeningHours(calendarId) : 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 allParticipantOpeningHours = fetchAllHours ? normalizeAllParticipantOpeningHoursResult(allHoursRaw) : null;
+    const openingHoursForUnifiedView = includeUnifiedCalendarView &&
+        preferAllParticipantOpeningHours &&
+        allParticipantOpeningHours != null &&
+        allParticipantOpeningHours.length > 0
+        ? allParticipantOpeningHours
+        : openingHours;
+    const calendarView = includeUnifiedCalendarView
+        ? buildUnifiedCalendarView(snap, openingHoursForUnifiedView, participantList, infoListForView)
+        : 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,
+                }
+                : {}),
+        },
+    };
+}
+/**
+ * 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 async function fetchCalendarBundle(calendarId) {
+    const d = await fetchCalendarDetails(calendarId, {
+        includeUnifiedCalendarView: true,
+        includeParticipantsInfo: true,
+        preferAllParticipantOpeningHours: true,
+    });
+    if (!d.meta.ok)
+        return null;
+    return d.calendarView;
+}

package/dist/calendar/fetchCalendarWithOpeningHours.d.ts

@@ -1,21 +1,34 @@
-export declare function unwrapCalendarGetData(res: unknown): unknown | null;
-export declare function pickOpeningHoursArrayFromCalendarPayload(data: unknown): unknown[] | null;
-export declare function normalizeParticipantOpeningHoursResponse(res: unknown): {
-    list: unknown[] | null;
-    raw: unknown;
-};
-export declare function fetchCalendarWithOpeningHours(calendarId: string, options?: {
-    includeRawGet?: boolean;
-}): Promise<{
-    calendar: (Record<string, unknown> & {
-        openingHours: unknown[];
-    }) | null;
-    /** Live MST calendar node (same as `CalendarModel.get`) — use for `getParticipants()`, etc. */
-    cal: unknown;
-    openingHours: unknown[];
-    embeddedFromGet: unknown[];
-    fromCalendarGet: boolean;
-    fromParticipantApi: boolean;
-    participantOpeningHoursResponse: unknown;
-    rawGet?: unknown;
-}>;
+/**
+ * Unwrap nested REST shapes: `res.data`, `res.Data`, or `res.data.data`.
+ */
+export declare function unwrapCalendarGetData(res: any): any;
+/** `openingHours` / `OpeningHours` on the calendar object returned by GET /Calendar/
+ * Robustly picks opening hours array from a raw calendar payload.
+ */
+export declare function pickOpeningHoursArrayFromCalendarPayload(data: any): any[] | null;
+/**
+ * Normalize `calendar.getParticipantOpeningHours()` response (`GET /Calendar/Participant/OpeningHours/Get`).
+ * Supports various Blazeo API shapes including nested data and common property names.
+ */
+export declare function normalizeParticipantOpeningHoursResponse(res: any): {
+    list: null;
+    raw: any;
+} | {
+    list: any[];
+    raw: any;
+};
+/**
+ * Loads `CalendarModel` and attaches **`openingHours`** to the MST snapshot:
+ * 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;
+}>;

package/dist/calendar/fetchCalendarWithOpeningHours.js

@@ -1,75 +1,95 @@
-import { CalendarModel } from "@blazeo.com/calendar-client";
-import { getSnapshot } from "mobx-state-tree";
-/**
- * Unwrap nested REST shapes: `res.data`, `res.Data`, or `res.data.data`.
- */
-export function unwrapCalendarGetData(res) {
-    if (res == null || typeof res !== "object")
-        return null;
-    let d = res.data ?? res.Data;
-    if (d == null)
-        return null;
-    if (typeof d === "object" && (d.data != null || d.Data != null)) {
-        d = d.data ?? d.Data;
-    }
-    return d;
-}
-/** `openingHours` / `OpeningHours` on the calendar object returned by GET /Calendar/Get (matches GraphQL-style payloads). */
-export function pickOpeningHoursArrayFromCalendarPayload(data) {
-    if (data == null || typeof data !== "object")
-        return null;
-    const h = data.openingHours ?? data.OpeningHours;
-    return Array.isArray(h) ? h : null;
-}
-/**
- * Normalize `calendar.getParticipantOpeningHours()` response (`GET /Calendar/Participant/OpeningHours/Get`).
- */
-export function normalizeParticipantOpeningHoursResponse(res) {
-    if (res == null)
-        return { list: null, raw: res };
-    const d = res.data ?? res.Data;
-    if (Array.isArray(d))
-        return { list: d, raw: res };
-    if (d && typeof d === "object") {
-        if (Array.isArray(d.openingHours))
-            return { list: d.openingHours, raw: res };
-        if (Array.isArray(d.OpeningHours))
-            return { list: d.OpeningHours, raw: res };
-        if (Array.isArray(d.items))
-            return { list: d.items, raw: res };
-    }
-    return { list: null, raw: res };
-}
-/**
- * Loads `CalendarModel` and attaches **`openingHours`** to the MST snapshot:
- * 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 async function fetchCalendarWithOpeningHours(calendarId, options = {}) {
-    const { includeRawGet = false } = options;
-    const rawRes = await CalendarModel.getRaw(calendarId);
-    const cal = await CalendarModel.get(calendarId);
-    const payload = unwrapCalendarGetData(rawRes);
-    const embedded = pickOpeningHoursArrayFromCalendarPayload(payload) ?? [];
-    let resolved = embedded.length > 0 ? embedded : null;
-    let participantRes = null;
-    if ((resolved == null || resolved.length === 0) && cal != null) {
-        participantRes = await cal.getParticipantOpeningHours({});
-        const { list } = normalizeParticipantOpeningHoursResponse(participantRes);
-        if (list != null && list.length > 0)
-            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 } : {}),
-    };
-}
+import { CalendarModel } from "@blazeo.com/calendar-client";
+import { getSnapshot } from "mobx-state-tree";
+/**
+ * Unwrap nested REST shapes: `res.data`, `res.Data`, or `res.data.data`.
+ */
+export function unwrapCalendarGetData(res) {
+    if (res == null || typeof res !== "object")
+        return null;
+    let d = res.data ?? res.Data;
+    if (d == null)
+        return null;
+    if (typeof d === "object" && (d.data != null || d.Data != null)) {
+        d = d.data ?? d.Data;
+    }
+    return d;
+}
+/** `openingHours` / `OpeningHours` on the calendar object returned by GET /Calendar/
+ * Robustly picks opening hours array from a raw calendar payload.
+ */
+export function pickOpeningHoursArrayFromCalendarPayload(data) {
+    if (data == null)
+        return null;
+    const { list } = normalizeParticipantOpeningHoursResponse(data);
+    return list;
+}
+/**
+ * Normalize `calendar.getParticipantOpeningHours()` response (`GET /Calendar/Participant/OpeningHours/Get`).
+ * Supports various Blazeo API shapes including nested data and common property names.
+ */
+export function normalizeParticipantOpeningHoursResponse(res) {
+    if (res == null)
+        return { list: null, raw: res };
+    // 1. Check for standard envelope: res.data or res.Data
+    let d = res.data ?? res.Data ?? res;
+    // 2. Handle double-nested data (common in some Blazeo API versions)
+    if (d && typeof d === "object" && !Array.isArray(d)) {
+        if (d.data !== undefined)
+            d = d.data;
+        else if (d.Data !== undefined)
+            d = d.Data;
+    }
+    // 3. If d is now an array, that's our list
+    if (Array.isArray(d))
+        return { list: d, raw: res };
+    // 4. Otherwise check for known list properties on the object
+    if (d && typeof d === "object") {
+        const list = d.openingHours ??
+            d.OpeningHours ??
+            d.participantOpeningHours ??
+            d.ParticipantOpeningHours ??
+            d.rows ??
+            d.Rows ??
+            d.items ??
+            d.Items ??
+            d.list ??
+            d.List;
+        if (Array.isArray(list))
+            return { list, raw: res };
+    }
+    return { list: null, raw: res };
+}
+/**
+ * Loads `CalendarModel` and attaches **`openingHours`** to the MST snapshot:
+ * 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 async function fetchCalendarWithOpeningHours(calendarId, options = {}) {
+    const { includeRawGet = false } = options;
+    const rawRes = await CalendarModel.getRaw(calendarId);
+    const cal = await CalendarModel.get(calendarId);
+    const payload = unwrapCalendarGetData(rawRes);
+    const embedded = pickOpeningHoursArrayFromCalendarPayload(payload) ?? [];
+    let resolved = embedded.length > 0 ? embedded : null;
+    let participantRes = null;
+    if ((resolved == null || resolved.length === 0) && cal != null) {
+        // Pass calendarId explicitly because some server shapes do not populate `self.calendarId` on the MST model.
+        participantRes = await cal.getParticipantOpeningHours({ calendarId });
+        const { list } = normalizeParticipantOpeningHoursResponse(participantRes);
+        if (list != null && list.length > 0)
+            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 } : {}),
+    };
+}

package/dist/calendar/getAllParticipantOpeningHours.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Fetch all participant opening hours for a calendar.
+ * Uses `GET /Calendar/Participant/OpeningHours/All/Get`.
+ */
+export declare function getAllParticipantOpeningHours(calendarId: string): Promise<{
+    openingHours: any[];
+    raw: any[];
+    meta: {
+        ok: true;
+        shape: "array";
+    };
+} | {
+    openingHours: any[];
+    raw: any;
+    meta: {
+        ok: boolean;
+        shape?: undefined;
+    };
+}>;