@blazeo.com/appointment-client 1.0.5 → 1.0.6

package/dist/calendar/blazeoCalendarRelationMethods.d.ts

@@ -1,40 +1,8 @@
-import type { IStateTreeNode } from "mobx-state-tree";
-/**
- * Participant & opening-hour **save** APIs on a Blazeo `Calendar` MST node
- * (`CalendarModel.create` from `@blazeo.com/calendar-client`).
- *
- * Source: `node_modules/@blazeo.com/calendar-client/dist/index.mjs` (Calendar model actions).
- *
- * | Instance method | Route | Notes |
- * |-----------------|-------|--------|
- * | `addParticipant(participantId)` | `GET /Calendar/Participant/Add` | Query: `calendar_id`, `participant_id` |
- * | `removeParticipant(participantId)` | `GET /Calendar/Participant/Remove` | Remove participant from calendar |
- * | `saveOpeningHour(payload)` | `POST /Calendar/Participant/Availability/OpeningHour/Save` | Single opening-hour row |
- * | `saveOpeningHours(payload)` | `POST /Calendar/Participant/Availability/OpeningHours/Save` | Batch variant (same family) |
- * | `getParticipantOpeningHours(params?)` | `GET /Calendar/Participant/OpeningHours/Get` | Read |
- * | `removeParticipantOpeningHours(participantId)` | `GET /Calendar/Participant/OpeningHour/Remove` | Clear hours for participant |
- *
- * Alternative **static** helpers on `CalendarModel` (different flow): `createWithParticipants`,
- * `editWithParticipants` — not used by `appointment-client` relation facade (we use create + `addParticipant`).
- */
-export type BlazeoCalendarRelationResponse = {
-    status: string;
-    message?: string;
-    data?: unknown;
-};
-export type BlazeoCalendarForRelations = IStateTreeNode & {
-    readonly calendarId?: string;
-    addParticipant(participantId: string): Promise<BlazeoCalendarRelationResponse>;
-    removeParticipant(participantId: string): Promise<BlazeoCalendarRelationResponse>;
-    saveOpeningHour(payload: Record<string, unknown>): Promise<BlazeoCalendarRelationResponse>;
-    saveOpeningHours(payload: Record<string, unknown> | unknown[]): Promise<BlazeoCalendarRelationResponse>;
-};
 /** `GET /Calendar/Participant/Add` — attach `participantId` to this calendar. */
-export declare function addParticipantToCalendar(calendar: BlazeoCalendarForRelations, participantId: string): Promise<BlazeoCalendarRelationResponse>;
+export declare function addParticipantToCalendar(calendar: any, participantId: string): any;
 /** `GET /Calendar/Participant/Remove` */
-export declare function removeParticipantFromCalendar(calendar: BlazeoCalendarForRelations, participantId: string): Promise<BlazeoCalendarRelationResponse>;
+export declare function removeParticipantFromCalendar(calendar: any, participantId: string): any;
 /** `POST /Calendar/Participant/Availability/OpeningHour/Save` — one day/slot. */
-export declare function saveCalendarOpeningHour(calendar: BlazeoCalendarForRelations, payload: Record<string, unknown>): Promise<BlazeoCalendarRelationResponse>;
+export declare function saveCalendarOpeningHour(calendar: any, payload: any): any;
 /** `POST /Calendar/Participant/Availability/OpeningHours/Save` — batch body (API-specific shape). */
-export declare function saveCalendarOpeningHoursBatch(calendar: BlazeoCalendarForRelations, payload: Record<string, unknown> | unknown[]): Promise<BlazeoCalendarRelationResponse>;
-//# sourceMappingURL=blazeoCalendarRelationMethods.d.ts.map
+export declare function saveCalendarOpeningHoursBatch(calendar: any, payload: any): any;

package/dist/calendar/blazeoCalendarRelationMethods.js

@@ -14,4 +14,3 @@ export function saveCalendarOpeningHour(calendar, payload) {
 export function saveCalendarOpeningHoursBatch(calendar, payload) {
     return calendar.saveOpeningHours(payload);
 }
-//# sourceMappingURL=blazeoCalendarRelationMethods.js.map

package/dist/calendar/buildUnifiedCalendarView.d.ts

@@ -0,0 +1,31 @@
+export interface UnifiedCalendarMember {
+    id: number | string;
+    name: string;
+    email: string | null;
+    /** When API exposes status; otherwise derived from participant info flags. */
+    status: number | null;
+    /** Full row from Participants/GetInfo (plain object). */
+    participantInfo?: Record<string, unknown> | null;
+}
+export interface UnifiedParticipantWithHours extends UnifiedCalendarMember {
+    openingHours: UnifiedOpeningHourRow[];
+}
+export interface UnifiedOpeningHourRow {
+    member: number | string;
+    days: string[];
+    startHour: number;
+    startMinute: number;
+    endHour: number;
+    endMinute: number;
+    off: boolean;
+}
+export type UnifiedCalendarView = Record<string, unknown> & {
+    members: UnifiedCalendarMember[];
+    openingHours: UnifiedOpeningHourRow[];
+    participants?: UnifiedParticipantWithHours[];
+};
+/**
+ * Build a consumer-friendly `{ id, name, members, openingHours }` shape where
+ * `openingHours[].member` references `members[].id`.
+ */
+export declare function buildUnifiedCalendarView(calendarSnapshot: Record<string, any> | null, openingHoursRows: any[], participants: any[] | null | undefined, participantsInfo: any[] | null | undefined): UnifiedCalendarView | null;

package/dist/calendar/buildUnifiedCalendarView.js

@@ -0,0 +1,265 @@
+import { getSnapshot, isStateTreeNode } from "mobx-state-tree";
+const DAY_NAMES = ["SUNDAY", "MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY", "SATURDAY"];
+function pick(row, ...keys) {
+    if (row == null || typeof row !== "object")
+        return undefined;
+    for (const k of keys) {
+        if (row[k] !== undefined && row[k] !== null)
+            return row[k];
+    }
+    return undefined;
+}
+function toPlain(value) {
+    if (value == null)
+        return value;
+    if (isStateTreeNode(value))
+        return getSnapshot(value);
+    if (Array.isArray(value))
+        return value.map((x) => toPlain(x));
+    return value;
+}
+function normParticipantKey(v) {
+    if (v == null)
+        return "";
+    return String(v).trim().toLowerCase();
+}
+function coerceMemberId(v) {
+    if (v == null || v === "")
+        return null;
+    if (typeof v === "number" && !Number.isNaN(v))
+        return v;
+    if (typeof v === "string") {
+        const t = v.trim();
+        if (/^\d+$/.test(t))
+            return Number(t);
+        return t;
+    }
+    return null;
+}
+/**
+ * Canonical member id used in both `members[].id` and `openingHours[].member`.
+ */
+function resolveParticipantMemberId(calPart) {
+    const n = pick(calPart, "id", "Id");
+    if (n != null && typeof n === "number" && !Number.isNaN(n))
+        return n;
+    const sid = pick(calPart, "participantId", "ParticipantId", "participant_id");
+    if (sid != null && String(sid).trim() !== "") {
+        const t = String(sid).trim();
+        if (/^\d+$/.test(t))
+            return Number(t);
+        return t;
+    }
+    return "";
+}
+function dayOrderIndex(d) {
+    const u = d.toUpperCase();
+    const i = DAY_NAMES.indexOf(u);
+    return i >= 0 ? i : 999;
+}
+/** Merge rows that share participant + time span + off into one row with combined `days`. */
+function mergeOpeningHoursBySlot(rows) {
+    const map = new Map();
+    for (const r of rows) {
+        const key = [r.member, r.startHour, r.startMinute, r.endHour, r.endMinute, r.off].join("|");
+        const existing = map.get(key);
+        if (!existing) {
+            map.set(key, { ...r, days: [...r.days] });
+        }
+        else {
+            const set = new Set([...existing.days, ...r.days]);
+            existing.days = Array.from(set).sort((a, b) => dayOrderIndex(a) - dayOrderIndex(b));
+        }
+    }
+    rows.length = 0;
+    rows.push(...map.values());
+}
+function normalizeDaysFromRow(row) {
+    const rawDays = pick(row, "days", "Days");
+    if (Array.isArray(rawDays)) {
+        return rawDays.map((d) => String(d).trim().toUpperCase()).filter(Boolean);
+    }
+    const dayNum = pick(row, "day", "Day");
+    if (dayNum != null && typeof dayNum === "number" && dayNum >= 0 && dayNum <= 6) {
+        return [DAY_NAMES[dayNum]];
+    }
+    const dayStr = pick(row, "dayName", "DayName", "dayOfWeek", "DayOfWeek");
+    if (dayStr != null && String(dayStr).trim() !== "") {
+        return [String(dayStr).trim().toUpperCase()];
+    }
+    return [];
+}
+function resolveOpeningHourMemberId(row, byParticipantKey, byCalendarParticipantKey) {
+    const calPartHook = pick(row, "calendarParticipantId", "CalendarParticipantId", "calendarparticipant_id");
+    if (calPartHook != null && String(calPartHook).trim() !== "") {
+        const ck = normParticipantKey(String(calPartHook));
+        if (byCalendarParticipantKey.has(ck))
+            return byCalendarParticipantKey.get(ck);
+    }
+    const pid = pick(row, "participantId", "ParticipantId", "participant_id");
+    if (pid != null && String(pid).trim() !== "") {
+        const k = normParticipantKey(String(pid));
+        if (byParticipantKey.has(k))
+            return byParticipantKey.get(k);
+        return coerceMemberId(pid);
+    }
+    const member = pick(row, "member", "Member");
+    if (member != null && typeof member === "object") {
+        const mid = coerceMemberId(pick(member, "id", "Id")) ??
+            coerceMemberId(pick(member, "participantId", "ParticipantId", "participant_id"));
+        if (mid != null)
+            return mid;
+    }
+    if (member != null && (typeof member === "number" || typeof member === "string")) {
+        const m = coerceMemberId(member);
+        if (m != null) {
+            const k = normParticipantKey(m);
+            if (byParticipantKey.has(k))
+                return byParticipantKey.get(k);
+        }
+        return m;
+    }
+    return null;
+}
+function deriveMemberStatus(calPart, info) {
+    const direct = pick(calPart, "status", "Status") ?? pick(info ?? {}, "status", "Status");
+    if (direct != null && typeof direct === "number" && !Number.isNaN(direct))
+        return direct;
+    const approved = Boolean(pick(calPart, "isApproved", "IsApproved", "is_approved")) ||
+        Boolean(pick(info ?? {}, "isApproved", "IsApproved", "is_approved"));
+    if (approved)
+        return approved ? 1 : 0;
+    return null;
+}
+/**
+ * Build a consumer-friendly `{ id, name, members, openingHours }` shape where
+ * `openingHours[].member` references `members[].id`.
+ */
+export function buildUnifiedCalendarView(calendarSnapshot, openingHoursRows, participants, participantsInfo) {
+    if (calendarSnapshot == null || typeof calendarSnapshot !== "object")
+        return null;
+    const calSnap = toPlain(calendarSnapshot);
+    const partsPlain = participants != null ? participants.map((p) => toPlain(p)) : [];
+    const infoPlain = participantsInfo != null ? participantsInfo.map((p) => toPlain(p)) : [];
+    const infoByPid = new Map();
+    for (const inf of infoPlain) {
+        const pid = inf?.participantId ?? inf?.ParticipantId ?? inf?.participant_id;
+        if (pid != null && String(pid).trim() !== "") {
+            infoByPid.set(normParticipantKey(String(pid)), inf);
+        }
+    }
+    const byParticipantKey = new Map();
+    const byCalendarParticipantKey = new Map();
+    const members = [];
+    if (partsPlain.length > 0) {
+        for (const cp of partsPlain) {
+            const memberId = resolveParticipantMemberId(cp);
+            const pidStr = pick(cp, "participantId", "ParticipantId", "participant_id") ?? "";
+            if (memberId === "" && (!pidStr || pidStr.trim() === ""))
+                continue;
+            const ik = normParticipantKey(pidStr || String(memberId));
+            const inf = ik ? infoByPid.get(ik) : undefined;
+            const participantInfoPlain = inf != null ? { ...toPlain(inf) } : null;
+            const alias = inf?.alias ?? inf?.Alias;
+            const name = typeof alias === "string" && alias.trim() !== ""
+                ? alias.trim()
+                : pidStr && pidStr.trim() !== ""
+                    ? pidStr.trim()
+                    : String(memberId);
+            const email = (inf?.email ?? inf?.Email ?? null);
+            const id = memberId === "" ? coerceMemberId(pidStr) ?? pidStr : memberId;
+            const calPartPk = pick(cp, "calendarParticipantId", "CalendarParticipantId", "calendarparticipant_id");
+            const calPartKey = calPartPk != null ? normParticipantKey(String(calPartPk)) : "";
+            if (calPartKey)
+                byCalendarParticipantKey.set(calPartKey, id);
+            const keyParticipant = ik || normParticipantKey(String(id));
+            if (keyParticipant) {
+                byParticipantKey.set(keyParticipant, id);
+                byParticipantKey.set(normParticipantKey(String(id)), id);
+            }
+            members.push({
+                id,
+                name,
+                email: email ?? null,
+                status: deriveMemberStatus(cp, inf),
+                participantInfo: participantInfoPlain,
+            });
+        }
+    }
+    else if (infoPlain.length > 0) {
+        for (const inf of infoPlain) {
+            const pid = inf?.participantId ?? inf?.ParticipantId ?? inf?.participant_id;
+            if (pid == null || String(pid).trim() === "")
+                continue;
+            const id = coerceMemberId(pid) ?? String(pid).trim();
+            const ik = normParticipantKey(String(pid));
+            const participantInfoPlain = { ...toPlain(inf) };
+            if (ik)
+                byParticipantKey.set(ik, id);
+            byParticipantKey.set(normParticipantKey(id), id);
+            const alias = inf.alias ?? inf.Alias ?? "";
+            const name = typeof alias === "string" && alias.trim() !== "" ? alias.trim() : String(pid);
+            const email = (inf.email ?? inf.Email ?? null);
+            members.push({
+                id,
+                name,
+                email: email ?? null,
+                status: deriveMemberStatus({}, inf),
+                participantInfo: participantInfoPlain,
+            });
+        }
+    }
+    const rawRows = Array.isArray(openingHoursRows) ? openingHoursRows : [];
+    const openingHours = [];
+    for (const raw of rawRows) {
+        const row = toPlain(raw);
+        let memberId = resolveOpeningHourMemberId(row, byParticipantKey, byCalendarParticipantKey);
+        if (memberId == null) {
+            const m = pick(row, "member", "Member");
+            memberId = typeof m === "number" || typeof m === "string" ? coerceMemberId(m) : null;
+        }
+        if (memberId == null)
+            continue;
+        const days = normalizeDaysFromRow(row);
+        const startHour = Number(pick(row, "startHour", "StartHour", "start_hour") ?? 0) || 0;
+        const startMinute = Number(pick(row, "startMinute", "StartMinute", "start_minute") ?? 0) || 0;
+        const endHour = Number(pick(row, "endHour", "EndHour", "end_hour") ?? 0) || 0;
+        const endMinute = Number(pick(row, "endMinute", "EndMinute", "end_minute") ?? 0) || 0;
+        const off = Boolean(pick(row, "off", "Off"));
+        openingHours.push({
+            member: memberId,
+            days,
+            startHour,
+            startMinute,
+            endHour,
+            endMinute,
+            off,
+        });
+    }
+    mergeOpeningHoursBySlot(openingHours);
+    const view = {
+        ...calSnap,
+        members,
+        openingHours,
+        participants: buildNestedParticipants(members, openingHours),
+    };
+    return view;
+}
+/**
+ * Groups opening hours into their respective participant objects.
+ */
+function buildNestedParticipants(members, openingHours) {
+    return members.map((m) => {
+        const hours = 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 {
+            ...m,
+            openingHours: nestedHours,
+        };
+    });
+}

package/dist/calendar/calendarCreation.d.ts

@@ -0,0 +1,27 @@
+import { deleteCalendarAsync } from "./createCalendar.js";
+/**
+ * Resolves Blazeo `participantId` for an opening-hour row: explicit `participantId`,
+ * matching `CalendarCreation.SaveOpeningHours`.
+ */
+export declare function resolveParticipantIdForOpeningHour(openingHour: any): string | undefined;
+/**
+ * Orchestrates the same steps as Apex `CalendarCreation.CreateCalendarAsync`:
+ * save calendar (`POST /Calendar/Create`), then add participants, then save opening hours
+ * per day (`POST /Calendar/Participant/Availability/OpeningHour/Save`).
+ */
+export declare function createCalendarWithRelationsAsync(calendar: any, options?: any): Promise<any>;
+/**
+ * Calendar body update, then same member + opening-hour saves as create (Apex-style follow-up).
+ * For member add/remove *diffs* against existing DB membership, use server-side Apex; this client
+ * only performs additive Blazeo calls matching the payload.
+ */
+export declare function updateCalendarWithRelationsAsync(calendar: any, options?: any): Promise<any>;
+/**
+ * Aligned with `CalendarCreation`: create/update with members & opening hours,
+ * or delete calendar only.
+ */
+export declare class CalendarCreation {
+    static createWithRelationsAsync: typeof createCalendarWithRelationsAsync;
+    static updateWithRelationsAsync: typeof updateCalendarWithRelationsAsync;
+    static deleteCalendarAsync: typeof deleteCalendarAsync;
+}

package/dist/calendar/calendarCreation.js

@@ -0,0 +1,167 @@
+import { getSnapshot } from "mobx-state-tree";
+import { addParticipantToCalendar, saveCalendarOpeningHour } from "./blazeoCalendarRelationMethods.js";
+import { createCalendarAsync, updateCalendarAsync, deleteCalendarAsync } from "./createCalendar.js";
+function isFailureStatus(res) {
+    return res.status !== "success" && res.status !== "Success";
+}
+function normalizeParticipantGuid(id) {
+    if (id == null || !String(id).trim())
+        return undefined;
+    return String(id).trim().replace(/^\{|\}$/g, "");
+}
+function newOpeningHourId() {
+    const c = globalThis.crypto;
+    if (c?.randomUUID)
+        return c.randomUUID();
+    return `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+}
+/**
+ * Resolves Blazeo `participantId` for an opening-hour row: explicit `participantId`,
+ * matching `CalendarCreation.SaveOpeningHours`.
+ */
+export function resolveParticipantIdForOpeningHour(openingHour) {
+    const direct = normalizeParticipantGuid(openingHour.participantId);
+    if (direct)
+        return direct;
+    return undefined;
+}
+function effectiveCalendarId(calendarNode, input) {
+    const snap = getSnapshot(calendarNode);
+    const fromNode = snap.calendarId?.trim();
+    if (fromNode && fromNode !== "new")
+        return fromNode;
+    return (input.calendarId?.trim() || undefined);
+}
+/**
+ * Orchestrates the same steps as Apex `CalendarCreation.CreateCalendarAsync`:
+ * save calendar (`POST /Calendar/Create`), then add participants, then save opening hours
+ * per day (`POST /Calendar/Participant/Availability/OpeningHour/Save`).
+ */
+export async function createCalendarWithRelationsAsync(calendar, options = {}) {
+    const hasMembers = (calendar.members?.length ?? 0) > 0;
+    const hasHours = (calendar.openingHours?.length ?? 0) > 0;
+    if (!hasMembers && !hasHours) {
+        const r = await createCalendarAsync(calendar, options);
+        if (!r.ok)
+            return r;
+        return { ...r, membersAdded: 0, openingHoursSaved: 0 };
+    }
+    if (options.localOnly) {
+        const r = await createCalendarAsync(calendar, options);
+        if (!r.ok)
+            return r;
+        return { ...r, membersAdded: 0, openingHoursSaved: 0 };
+    }
+    const created = await createCalendarAsync(calendar, options);
+    if (!created.ok)
+        return created;
+    return runMembersAndOpeningHoursAfterCalendarSave(calendar, created.calendar, created);
+}
+/**
+ * After calendar `create` or `update`, add members and opening hours (same order as Apex facade).
+ */
+async function runMembersAndOpeningHoursAfterCalendarSave(calendar, calendarNode, baseSuccess) {
+    const calendarIdStr = effectiveCalendarId(calendarNode, calendar);
+    if (!calendarIdStr) {
+        return {
+            ok: false,
+            error: "Could not resolve calendar id after save. Ensure the API returned a calendar id.",
+        };
+    }
+    let membersAdded = 0;
+    for (const m of calendar.members ?? []) {
+        const pid = normalizeParticipantGuid(m.id);
+        if (!pid) {
+            return {
+                ok: false,
+                error: `Member id ${m.id}: thirdPartyMemberId is required to add a participant.`,
+            };
+        }
+        const res = await addParticipantToCalendar(calendarNode, pid);
+        if (isFailureStatus(res)) {
+            const msg = res.message ??
+                (typeof res.data === "string" ? res.data : undefined) ??
+                JSON.stringify(res);
+            return {
+                ok: false,
+                error: `addParticipant failed for member ${m.id}: ${msg}`,
+                apiResponse: res,
+            };
+        }
+        membersAdded += 1;
+    }
+    let openingHoursSaved = 0;
+    for (const oh of calendar.openingHours ?? []) {
+        const participantId = resolveParticipantIdForOpeningHour(oh);
+        if (!participantId) {
+            return {
+                ok: false,
+                error: `Opening hour id ${oh.id}: participantId is required.`,
+            };
+        }
+        for (const day of oh.days ?? []) {
+            const payload = {
+                calendarId: calendarIdStr,
+                participantId,
+                day,
+                startHour: oh.startHour,
+                startMinute: oh.startMinute,
+                endHour: oh.endHour,
+                endMinute: oh.endMinute,
+                off: oh.off,
+                openingHourId: oh.openingHourId?.trim() || newOpeningHourId(),
+            };
+            const res = await saveCalendarOpeningHour(calendarNode, payload);
+            if (isFailureStatus(res)) {
+                const msg = res.message ??
+                    (typeof res.data === "string" ? res.data : undefined) ??
+                    JSON.stringify(res);
+                return {
+                    ok: false,
+                    error: `saveOpeningHour failed (opening hour ${oh.id}, day ${day}): ${msg}`,
+                    apiResponse: res,
+                };
+            }
+            openingHoursSaved += 1;
+        }
+    }
+    return {
+        ...baseSuccess,
+        membersAdded,
+        openingHoursSaved,
+    };
+}
+/**
+ * Calendar body update, then same member + opening-hour saves as create (Apex-style follow-up).
+ * For member add/remove *diffs* against existing DB membership, use server-side Apex; this client
+ * only performs additive Blazeo calls matching the payload.
+ */
+export async function updateCalendarWithRelationsAsync(calendar, options = {}) {
+    const hasMembers = (calendar.members?.length ?? 0) > 0;
+    const hasHours = (calendar.openingHours?.length ?? 0) > 0;
+    if (!hasMembers && !hasHours) {
+        const r = await updateCalendarAsync(calendar, options);
+        if (!r.ok)
+            return r;
+        return { ...r, membersAdded: 0, openingHoursSaved: 0 };
+    }
+    if (options.localOnly) {
+        const r = await updateCalendarAsync(calendar, options);
+        if (!r.ok)
+            return r;
+        return { ...r, membersAdded: 0, openingHoursSaved: 0 };
+    }
+    const updated = await updateCalendarAsync(calendar, options);
+    if (!updated.ok)
+        return updated;
+    return runMembersAndOpeningHoursAfterCalendarSave(calendar, updated.calendar, updated);
+}
+/**
+ * Aligned with `CalendarCreation`: create/update with members & opening hours,
+ * or delete calendar only.
+ */
+export class CalendarCreation {
+    static createWithRelationsAsync = createCalendarWithRelationsAsync;
+    static updateWithRelationsAsync = updateCalendarWithRelationsAsync;
+    static deleteCalendarAsync = deleteCalendarAsync;
+}

package/dist/calendar/calendarCreationFacade.d.ts

@@ -1,29 +1,21 @@
-import type { CalendarInput, OpeningHourBOInput } from "../types/calendar.js";
-import { deleteCalendarAsync, type CreateCalendarOptions, type CreateCalendarResult, type CreateCalendarSuccess } from "./createCalendar.js";
+import { deleteCalendarAsync } from "./createCalendar.js";
 /**
  * Resolves Blazeo `participantId` for an opening-hour row: explicit `participantId`,
  * matching `CalendarCreationAPIFacade.SaveOpeningHours`.
  */
-export declare function resolveParticipantIdForOpeningHour(openingHour: OpeningHourBOInput): string | undefined;
-export type CalendarWithRelationsSuccess = CreateCalendarSuccess & {
-    membersAdded: number;
-    openingHoursSaved: number;
-};
-export type CalendarWithRelationsResult = CalendarWithRelationsSuccess | Extract<CreateCalendarResult, {
-    ok: false;
-}>;
+export declare function resolveParticipantIdForOpeningHour(openingHour: any): string | undefined;
 /**
  * Orchestrates the same steps as Apex `CalendarCreationAPIFacade.CreateCalendarAsync`:
  * save calendar (`POST /Calendar/Create`), then add participants, then save opening hours
  * per day (`POST /Calendar/Participant/Availability/OpeningHour/Save`).
  */
-export declare function createCalendarWithRelationsAsync(calendar: CalendarInput, options?: CreateCalendarOptions): Promise<CalendarWithRelationsResult>;
+export declare function createCalendarWithRelationsAsync(calendar: any, options?: any): Promise<any>;
 /**
  * Calendar body update, then same member + opening-hour saves as create (Apex-style follow-up).
  * For member add/remove *diffs* against existing DB membership, use server-side Apex; this client
  * only performs additive Blazeo calls matching the payload.
  */
-export declare function updateCalendarWithRelationsAsync(calendar: CalendarInput, options?: CreateCalendarOptions): Promise<CalendarWithRelationsResult>;
+export declare function updateCalendarWithRelationsAsync(calendar: any, options?: any): Promise<any>;
 /**
  * Facade aligned with `CalendarCreationAPIFacade`: create/update with members & opening hours,
  * or delete calendar only.
@@ -33,4 +25,3 @@ export declare class CalendarCreationFacade {
     static updateWithRelationsAsync: typeof updateCalendarWithRelationsAsync;
     static deleteCalendarAsync: typeof deleteCalendarAsync;
 }
-//# sourceMappingURL=calendarCreationFacade.d.ts.map

package/dist/calendar/calendarCreationFacade.js

@@ -1,6 +1,6 @@
 import { getSnapshot } from "mobx-state-tree";
-import { addParticipantToCalendar, saveCalendarOpeningHour, } from "./blazeoCalendarRelationMethods.js";
-import { createCalendarAsync, updateCalendarAsync, deleteCalendarAsync, } from "./createCalendar.js";
+import { addParticipantToCalendar, saveCalendarOpeningHour } from "./blazeoCalendarRelationMethods.js";
+import { createCalendarAsync, updateCalendarAsync, deleteCalendarAsync } from "./createCalendar.js";
 function isFailureStatus(res) {
     return res.status !== "success" && res.status !== "Success";
 }
@@ -30,8 +30,7 @@ function effectiveCalendarId(calendarNode, input) {
     const fromNode = snap.calendarId?.trim();
     if (fromNode && fromNode !== "new")
         return fromNode;
-    return (input.calendarId?.trim() ||
-        undefined);
+    return (input.calendarId?.trim() || undefined);
 }
 /**
  * Orchestrates the same steps as Apex `CalendarCreationAPIFacade.CreateCalendarAsync`:
@@ -166,4 +165,3 @@ export class CalendarCreationFacade {
     static updateWithRelationsAsync = updateCalendarWithRelationsAsync;
     static deleteCalendarAsync = deleteCalendarAsync;
 }
-//# sourceMappingURL=calendarCreationFacade.js.map