@blazeo.com/calendar-client 1.0.2 → 1.0.4

package/dist/index.mjs

@@ -1,677 +1,129 @@
-// src/mapper.ts
-function pickStr(obj, ...keys) {
-  for (const k of keys) {
-    const v = obj[k];
-    if (v != null && typeof v === "string") return v;
+// src/models/appointment/Calendar.js
+import { types as types7, getEnv as getEnv2, applySnapshot as applySnapshot2 } from "mobx-state-tree";
+
+// src/ConfigModel.js
+import { types } from "mobx-state-tree";
+var ConfigModel = types.model("Config", {
+  baseUrl: types.optional(types.string, "")
+}).volatile(() => ({
+  fetch: void 0,
+  getDefaultOffset: () => -(/* @__PURE__ */ new Date()).getTimezoneOffset()
+})).actions((self) => ({
+  setBaseUrl(url) {
+    self.baseUrl = url;
+  },
+  setFetch(fn) {
+    self.fetch = fn;
+  },
+  setGetDefaultOffset(fn) {
+    self.getDefaultOffset = fn;
+  },
+  configure(env) {
+    if (env.baseUrl != null) self.baseUrl = env.baseUrl;
+    if (env.fetch != null) self.fetch = env.fetch;
+    if (env.getDefaultOffset != null) self.getDefaultOffset = env.getDefaultOffset;
+  }
+})).views((self) => ({
+  getEnv() {
+    return {
+      baseUrl: self.baseUrl || void 0,
+      fetch: self.fetch,
+      getDefaultOffset: self.getDefaultOffset
+    };
   }
-  return void 0;
+}));
+var _instance = null;
+function getConfigStore() {
+  if (!_instance) _instance = ConfigModel.create({});
+  return _instance;
 }
-function pickNum(obj, ...keys) {
-  for (const k of keys) {
-    const v = obj[k];
-    if (v != null) {
-      const n = typeof v === "number" ? v : Number(v);
-      if (!Number.isNaN(n)) return n;
-    }
-  }
-  return void 0;
+var ConfigModel_default = ConfigModel;
+
+// src/config.js
+function configure(env) {
+  const store = getConfigStore();
+  store.configure(env);
 }
-function parseDate(s) {
-  if (!s) return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  if (/^\d{4}-\d{2}-\d{2}$/.test(s)) return s;
-  const d = new Date(s);
-  return isNaN(d.getTime()) ? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10) : d.toISOString().slice(0, 10);
+function getConfig() {
+  const store = getConfigStore();
+  if (!store.baseUrl) return null;
+  return store.getEnv();
 }
-function mapCreateEventInputToEvent(input) {
-  const calendarId = input.calendarId ?? input.calendar_id;
-  const visitorName = pickStr(input, "visitorName", "visitor_name") ?? "";
-  const visitorEmail = pickStr(input, "visitorEmail", "visitor_email") ?? "";
-  const visitorPhone = pickStr(input, "visitorPhone", "visitor_phone") ?? "";
-  const startDateStr = pickStr(input, "startDate", "start_date");
-  const endDateStr = pickStr(input, "endDate", "end_date");
-  const startHour = pickNum(input, "startHour", "start_hour") ?? 0;
-  const startMinute = pickNum(input, "startMinute", "start_minute") ?? 0;
-  const endHour = pickNum(input, "endHour", "end_hour") ?? startHour;
-  const endMinute = pickNum(input, "endMinute", "end_minute") ?? startMinute;
-  let startDate = parseDate(startDateStr);
-  let parsedStartHour = startHour;
-  let parsedStartMinute = startMinute;
-  const startTime = pickStr(input, "startTime", "start_time");
-  if (startTime && /^\d{1,2}:\d{2}$/.test(startTime)) {
-    const [h, m] = startTime.split(":").map(Number);
-    parsedStartHour = h;
-    parsedStartMinute = m;
-  }
-  const endDate = endDateStr ? parseDate(endDateStr) : startDate;
-  const rawParticipantId = input.participantId ?? input.participant_id;
-  const participantId = rawParticipantId == null ? null : typeof rawParticipantId === "string" ? rawParticipantId : String(rawParticipantId);
-  return {
-    calendarId,
-    participantId,
-    title: input.title ?? "",
-    description: input.description ?? "",
-    startDate,
-    endDate,
-    startHour: parsedStartHour,
-    startMinute: parsedStartMinute,
-    endHour,
-    endMinute,
-    visitorName,
-    visitorEmail,
-    visitorPhone,
-    isRecurring: false,
-    recurringFrequency: 0
-  };
+function setBaseUrl(baseUrl) {
+  getConfigStore().setBaseUrl(baseUrl);
 }
 
-// src/client.ts
-function normalizeBaseUrl(baseUrl) {
-  return baseUrl.replace(/\/+$/, "");
-}
+// src/apiRequest.js
 function buildQuery(params) {
   const search = new URLSearchParams();
-  for (const [k, v] of Object.entries(params)) {
+  for (const [k, v] of Object.entries(params || {})) {
     if (v === void 0 || v === null) continue;
-    search.set(k, String(v));
+    if (Array.isArray(v)) {
+      for (const item of v) search.append(k, String(item));
+    } else {
+      search.set(k, String(v));
+    }
   }
   const q = search.toString();
   return q ? `?${q}` : "";
 }
-var AppointmentClient = class {
-  constructor(config) {
-    this.baseUrl = normalizeBaseUrl(config.baseUrl);
-    this.getDefaultOffset = config.getDefaultOffset ?? (() => (/* @__PURE__ */ new Date()).getTimezoneOffset());
-    this.fetchFn = config.fetch ?? (typeof fetch !== "undefined" ? fetch : (() => {
-      throw new Error("fetch not available");
-    })());
-  }
-  async request(path, options = {}) {
-    const { method = "GET", headers = {}, body, query, skipContentType } = options;
-    const url = `${this.baseUrl}${path}${buildQuery(query ?? {})}`;
-    const reqHeaders = { ...headers };
-    if (!skipContentType && typeof body === "string") {
-      reqHeaders["Content-Type"] = "application/json";
-    }
-    const res = await this.fetchFn(url, { method, headers: reqHeaders, body });
-    const text = await res.text();
-    let data;
-    try {
-      data = JSON.parse(text);
-    } catch {
-      data = { status: "failure", message: text || res.statusText };
-    }
-    if (!res.ok && data.status !== "failure") {
-      data.status = "failure";
-      data.message = data.message ?? `HTTP ${res.status}`;
-    }
-    return data;
-  }
-  // ---------- Event ----------
-  /** GET /event/get – by event_id or externalevent_id */
-  async getEvent(params) {
-    if (params.eventId ?? params.event_id) {
-      return this.request("/event/get", {
-        query: { event_id: params.eventId ?? params.event_id }
-      });
-    }
-    if (params.externalEventId ?? params.externalevent_id) {
-      return this.request("/event/get", {
-        query: { externalevent_id: params.externalEventId ?? params.externalevent_id }
-      });
-    }
-    return Promise.resolve({ status: "failure", message: "Provide eventId or externalEventId" });
-  }
-  /** GET /event/availability/get – slots for a day. Optional participant_id. */
-  async getAvailability(params) {
-    const calendarId = params.calendarId ?? params.calendar_id;
-    const offset = params.offset;
-    const query = {
-      calendar_id: calendarId,
-      year: params.year,
-      month: params.month,
-      day: params.day
-    };
-    if (params.participantId ?? params.participant_id) {
-      query.participant_id = params.participantId ?? params.participant_id;
-    }
-    return this.request("/event/availability/get", {
-      headers: { offset: String(offset) },
-      query
-    });
-  }
-  /** GET /event/day/selectable/get – whether the day has any slots. Optional participant_id. */
-  async getDaySelectable(params) {
-    const calendarId = params.calendarId ?? params.calendar_id;
-    const query = {
-      calendar_id: calendarId,
-      year: params.year,
-      month: params.month,
-      day: params.day
-    };
-    if (params.participantId ?? params.participant_id) {
-      query.participant_id = params.participantId ?? params.participant_id;
-    }
-    const res = await this.request("/event/day/selectable/get", {
-      headers: { offset: String(params.offset) },
-      query
-    });
-    if (res.data !== void 0) return { ...res, data: Boolean(res.data) };
-    return res;
-  }
-  /** GET /event/days/available/get – list of next N available days (yyyy-MM-dd). */
-  async getEarliestAvailableDays(params) {
-    const calendarId = params.calendarId ?? params.calendar_id;
-    const query = {
-      calendar_id: calendarId,
-      count: params.count
-    };
-    if (params.year != null) query.year = params.year;
-    if (params.month != null) query.month = params.month;
-    if (params.day != null) query.day = params.day;
-    return this.request("/event/days/available/get", {
-      headers: { offset: String(params.offset) },
-      query
-    });
-  }
-  /** GET /event/existing/getbyvisitoremail – by company_key or calendar_id */
-  async getExistingEventsByVisitorEmail(params) {
-    const query = {
-      email: params.email,
-      offset: params.offset
-    };
-    if (params.companyKey ?? params.company_key) query.company_key = params.companyKey ?? params.company_key;
-    if (params.calendarId ?? params.calendar_id) query.calendar_id = params.calendarId ?? params.calendar_id;
-    return this.request("/event/existing/getbyvisitoremail", {
-      headers: { offset: String(params.offset) },
-      query
-    });
-  }
-  /** GET /event/existing/getbyvisitorphone – by company_key or calendar_id */
-  async getExistingEventsByVisitorPhone(params) {
-    const query = {
-      phone: params.phone,
-      offset: params.offset
-    };
-    if (params.companyKey ?? params.company_key) query.company_key = params.companyKey ?? params.company_key;
-    if (params.calendarId ?? params.calendar_id) query.calendar_id = params.calendarId ?? params.calendar_id;
-    return this.request("/event/existing/getbyvisitorphone", {
-      headers: { offset: String(params.offset) },
-      query
-    });
-  }
-  /** POST /event/create – create event. Accepts flexible input; maps to backend shape. */
-  async createEvent(input, offsetMinutes) {
-    const offset = offsetMinutes ?? this.getDefaultOffset();
-    const body = mapCreateEventInputToEvent(input);
-    return this.request("/event/create", {
-      method: "POST",
-      headers: { offset: String(offset) },
-      body: JSON.stringify(body)
-    });
-  }
-  /** GET /event/cancel – cancel by event_id */
-  async cancelEvent(eventId) {
-    return this.request("/event/cancel", { query: { event_id: eventId } });
-  }
-  /** GET /event/cancellable – check if event can be cancelled */
-  async getCancellable(eventId) {
-    const res = await this.request("/event/cancellable", { query: { event_id: eventId } });
-    if (res.data !== void 0) return { ...res, data: Boolean(res.data) };
-    return res;
-  }
-  /** GET /event/participant/roundrobin/get – get assignable participant for calendar */
-  async getRoundRobinParticipant(calendarId) {
-    return this.request("/event/participant/roundrobin/get", {
-      query: { calendar_id: calendarId }
-    });
-  }
-  /** GET /event/attendeeStatus – set attendee status (route: /event/{eventId}/{attendeeStatus}) */
-  async setAttendeeStatus(eventId, attendeeStatus) {
-    return this.request(`/event/${encodeURIComponent(eventId)}/${encodeURIComponent(attendeeStatus)}`);
-  }
-  /** GET /event/seteventreminder/{event_id} */
-  async setEventReminder(eventId) {
-    return this.request(`/event/seteventreminder/${encodeURIComponent(eventId)}`);
-  }
-  /** POST /event/reschedule – reschedule event */
-  async rescheduleEvent(payload, offsetMinutes) {
-    const offset = offsetMinutes ?? this.getDefaultOffset();
-    return this.request("/event/reschedule", {
-      method: "POST",
-      headers: { offset: String(offset) },
-      body: JSON.stringify(payload)
-    });
-  }
-  /** POST /event/update – update event */
-  async updateEvent(payload) {
-    return this.request("/event/update", {
-      method: "POST",
-      body: JSON.stringify(payload)
-    });
-  }
-  /** POST /event/testcreate – test create (no notifications) */
-  async testCreateEvent(payload, offsetMinutes) {
-    const offset = offsetMinutes ?? this.getDefaultOffset();
-    return this.request("/event/testcreate", {
-      method: "POST",
-      headers: { offset: String(offset) },
-      body: JSON.stringify(payload)
-    });
-  }
-  /** POST /event/customdata/get – get custom field schema for calendar */
-  async getEventCustomData(calendarId, eventId) {
-    const query = { calendar_id: calendarId };
-    if (eventId) query.event_id = eventId;
-    return this.request("/event/customdata/get", {
-      method: "POST",
-      body: JSON.stringify({}),
-      query
-    });
-  }
-  // ---------- Calendar ----------
-  /** GET Calendar/Get – get calendar by calendar_id */
-  async getCalendar(calendarId) {
-    return this.request("/Calendar/Get", { query: { calendar_id: calendarId } });
-  }
-  /** GET Calendar/All – calendars by company_key */
-  async getCalendarsByCompany(companyKey) {
-    return this.request("/Calendar/All", { query: { company_key: companyKey } });
-  }
-  /** GET Calendar/TimeZones/Get */
-  async getTimeZones() {
-    return this.request("/Calendar/TimeZones/Get");
-  }
-  /** GET Calendar/TimeZone/Get – display name for timezone_id */
-  async getTimeZone(timezoneId) {
-    return this.request("/Calendar/TimeZone/Get", { query: { timezone_id: timezoneId } });
-  }
-  /** POST Calendar/Create – create or update calendar */
-  async createCalendar(payload) {
-    return this.request("/Calendar/Create", { method: "POST", body: JSON.stringify(payload) });
-  }
-  /** GET Calendar/Remove */
-  async removeCalendar(calendarId) {
-    return this.request(`/Calendar/Remove`, { query: { calendar_id: calendarId } });
-  }
-  /** POST Calendar/Event/Update – update calendar */
-  async updateCalendar(payload) {
-    return this.request("/Calendar/Event/Update", {
-      method: "POST",
-      body: JSON.stringify(payload)
-    });
-  }
-  /** GET Calendar/Participant/Add */
-  async addParticipantToCalendar(calendarId, participantId) {
-    return this.request("/Calendar/Participant/Add", {
-      query: { calendar_id: calendarId, participant_id: participantId }
-    });
-  }
-  /** GET Calendar/Participant/Remove */
-  async removeParticipantFromCalendar(calendarId, participantId) {
-    return this.request("/Calendar/Participant/Remove", {
-      query: { calendar_id: calendarId, participant_id: participantId }
-    });
-  }
-  /** GET Calendar/Participant/OpeningHours/Get */
-  async getParticipantOpeningHours(params) {
-    const query = {};
-    if (params.calendarParticipantId) query.calendarparticipant_id = params.calendarParticipantId;
-    if (params.participantId) query.participant_id = params.participantId;
-    if (params.calendarId) query.calendar_id = params.calendarId;
-    return this.request("/Calendar/Participant/OpeningHours/Get", { query });
-  }
-  /** POST Calendar/Participant/Availability/OpeningHour/Save */
-  async saveOpeningHour(payload) {
-    return this.request("/Calendar/Participant/Availability/OpeningHour/Save", {
-      method: "POST",
-      body: JSON.stringify(payload)
-    });
-  }
-  /** POST Calendar/Participant/Availability/OpeningHours/Save */
-  async saveOpeningHours(payload) {
-    return this.request("/Calendar/Participant/Availability/OpeningHours/Save", {
-      method: "POST",
-      body: JSON.stringify(payload)
-    });
-  }
-  /** GET Calendar/Participant/OpeningHour/Remove */
-  async removeParticipantOpeningHours(calendarId, participantId) {
-    return this.request("/Calendar/Participant/OpeningHour/Remove", {
-      query: { calendar_id: calendarId, participant_id: participantId }
-    });
-  }
-  /** GET Calendar/Participant/Availability/Add – backend expects body (AvailabilityDetail). Note: GET with body is non-standard; fetch may reject. Consider backend POST if needed. */
-  async addParticipantAvailability(calendarId, participantId, detail) {
-    return this.request("/Calendar/Participant/Availability/Add", {
-      method: "GET",
-      query: { calendar_id: calendarId, participant_id: participantId },
-      body: JSON.stringify(detail)
-    });
-  }
-  /** GET Calendar/Participant/All */
-  async getCalendarParticipants(calendarId) {
-    return this.request("/Calendar/Participant/All", {
-      query: { calendar_id: calendarId }
-    });
-  }
-  /** GET Calendar/CreateWithParticipants */
-  async createCalendarWithParticipants(params) {
-    const query = {
-      name: params.name,
-      company_key: params.companyKey,
-      participantids: params.participantIds.join(",")
-    };
-    if (params.description) query.description = params.description;
-    if (params.calendarId) query.calendar_id = params.calendarId;
-    return this.request("/Calendar/CreateWithParticipants", { query });
-  }
-  /** GET Calendar/EditWithParticipants */
-  async editCalendarWithParticipants(params) {
-    const query = {
-      calendar_id: params.calendarId,
-      name: params.name,
-      participantids: params.participantIds.join(",")
-    };
-    if (params.description) query.description = params.description;
-    return this.request("/Calendar/EditWithParticipants", { query });
-  }
-  /** GET Calendar/Month/Get */
-  async getCalendarMonth(calendarId, year, month) {
-    return this.request("/Calendar/Month/Get", {
-      query: { calendar_id: calendarId, year, month }
-    });
-  }
-  /** GET Calendar/Events/Get */
-  async getCalendarEvents(calendarId) {
-    return this.request("/Calendar/Events/Get", {
-      query: { calendar_id: calendarId }
-    });
-  }
-  // ---------- Participant ----------
-  /** GET participant/get */
-  async getParticipant(participantId) {
-    return this.request("/participant/get", { query: { participant_id: participantId } });
-  }
-  /** GET participant/participants/get */
-  async getParticipantsByIds(participantIds) {
-    return this.request("/participant/participants/get", {
-      query: { participantids: participantIds.join(",") }
-    });
-  }
-  /** GET Participant/All */
-  async getAllParticipants(companyKey) {
-    return this.request("/Participant/All", { query: { company_key: companyKey } });
-  }
-  /** GET participant/sendemail */
-  async sendParticipantEmail(participantId) {
-    return this.request("/participant/sendemail", { query: { participant_id: participantId } });
-  }
-  /** POST Participant/Add */
-  async addParticipant(payload, calendarId) {
-    const query = calendarId ? { calendar_id: calendarId } : void 0;
-    return this.request("/Participant/Add", {
-      method: "POST",
-      body: JSON.stringify(payload),
-      query
-    });
-  }
-  /** GET participant/remove */
-  async removeParticipant(participantId) {
-    return this.request("/participant/remove", { query: { participant_id: participantId } });
-  }
-  /** POST participant/update */
-  async updateParticipant(payload) {
-    return this.request("/participant/update", {
-      method: "POST",
-      body: JSON.stringify(payload)
-    });
-  }
-  /** POST participant/save */
-  async saveParticipant(payload) {
-    return this.request("/participant/save", {
-      method: "POST",
-      body: JSON.stringify(payload)
-    });
-  }
-  // ---------- CalendarParticipant ----------
-  /** GET Calendar/Participant/Get */
-  async getCalendarParticipant(calendarId) {
-    return this.request("/Calendar/Participant/Get", {
-      query: { calendar_id: calendarId }
-    });
-  }
-  /** GET Calendar/Participants/GetInfo */
-  async getCalendarParticipantsInfo(calendarId) {
-    return this.request("/Calendar/Participants/GetInfo", {
-      query: { calendar_id: calendarId }
-    });
-  }
-  /** GET Participant/calendar/get */
-  async getParticipantCalendars(participantId) {
-    return this.request("/Participant/calendar/get", {
-      query: { participant_id: participantId }
-    });
-  }
-  // ---------- CustomField ----------
-  /** GET CustomField/GetAll */
-  async getCustomFields(calendarId) {
-    return this.request("/CustomField/GetAll", { query: { calendar_id: calendarId } });
-  }
-  /** GET CustomField/FieldType/Get */
-  async getCustomFieldType(fieldType) {
-    return this.request("/CustomField/FieldType/Get", { query: { FieldType: fieldType } });
-  }
-  /** POST CustomField/Add */
-  async addCustomField(payload) {
-    return this.request("/CustomField/Add", {
-      method: "POST",
-      body: JSON.stringify(payload)
-    });
-  }
-  /** GET CustomField/FieldTypes/Get */
-  async getCustomFieldTypes() {
-    return this.request("/CustomField/FieldTypes/Get");
-  }
-  /** GET CustomField/RemoveField */
-  async removeCustomField(customFieldId) {
-    return this.request("/CustomField/RemoveField", { query: { customfield_id: customFieldId } });
-  }
-  /** GET CustomField/RemoveAllFields */
-  async removeAllCustomFields(calendarId) {
-    return this.request("/CustomField/RemoveAllFields", { query: { calendar_id: calendarId } });
-  }
-  /** GET CustomField/Form/Get */
-  async getCustomForm(calendarId, dataId) {
-    const query = { calendar_id: calendarId };
-    if (dataId) query.data_id = dataId;
-    return this.request("/CustomField/Form/Get", { query });
-  }
-  /** GET CustomField/Form/Data/Get */
-  async getCustomFormData(calendarId, dataId) {
-    const query = { calendar_id: calendarId };
-    if (dataId) query.data_id = dataId;
-    return this.request("/CustomField/Form/Data/Get", { query });
-  }
-  /** POST CustomField/Form/Save */
-  async saveCustomForm(calendarId, fields) {
-    return this.request("/CustomField/Form/Save", {
-      method: "POST",
-      body: JSON.stringify(fields),
-      query: { calendar_id: calendarId }
-    });
-  }
-  /** POST CustomField/Form/Data/Save */
-  async saveCustomFormData(dataId, fields) {
-    return this.request("/CustomField/Form/Data/Save", {
-      method: "POST",
-      body: JSON.stringify(fields),
-      query: { data_id: dataId }
-    });
-  }
-  /** POST CustomField/Form/Field/Data/Save */
-  async saveCustomFormFieldData(field) {
-    return this.request("/CustomField/Form/Field/Data/Save", {
-      method: "POST",
-      body: JSON.stringify(field)
-    });
-  }
-  // ---------- Setting ----------
-  /** GET setting/get */
-  async getSetting(calendarId) {
-    return this.request("/setting/get", { query: { calendar_id: calendarId } });
-  }
-  /** POST setting/save */
-  async saveSetting(payload) {
-    return this.request("/setting/save", {
-      method: "POST",
-      body: JSON.stringify(payload)
-    });
-  }
-  /** POST setting/logo/upload */
-  async uploadSettingLogo(calendarId, file) {
-    const form = new FormData();
-    form.append("file", file);
-    return this.request("/setting/logo/upload", {
-      method: "POST",
-      body: form,
-      query: { calendar_id: calendarId },
-      skipContentType: true
-    });
-  }
-  // ---------- Consumer ----------
-  /** POST Consumer/Register/EventListener */
-  async registerEventListener(payload) {
-    return this.request("/Consumer/Register/EventListener", {
-      method: "POST",
-      body: JSON.stringify(payload)
-    });
-  }
-  /** PUT Consumer/Update/EventListener */
-  async updateEventListener(payload) {
-    return this.request("/Consumer/Update/EventListener", {
-      method: "PUT",
-      body: JSON.stringify(payload)
-    });
-  }
-  /** POST Consumer/Register */
-  async registerConsumer(payload) {
-    return this.request("/Consumer/Register", {
-      method: "POST",
-      body: JSON.stringify(payload)
-    });
-  }
-  /** GET Consumer/Events/List */
-  async listEventListeners() {
-    return this.request("/Consumer/Events/List");
-  }
-  /** GET Consumer/List */
-  async listConsumers() {
-    return this.request("/Consumer/List");
-  }
-  // ---------- Preference ----------
-  /** POST /preference/{scope}/{key}/{option} */
-  async setPreference(scope, key, option, body) {
-    return this.request(`/preference/${encodeURIComponent(scope)}/${encodeURIComponent(key)}/${encodeURIComponent(option)}`, {
-      method: "POST",
-      body
-    });
-  }
-  /** GET /preference/scopes */
-  async getPreferenceScopes() {
-    return this.request("/preference/scopes");
-  }
-  /** GET /preference/options */
-  async getPreferenceOptions() {
-    return this.request("/preference/options");
-  }
-  /** GET /preference/options/{option} */
-  async getPreferenceOption(option) {
-    return this.request(`/preference/options/${encodeURIComponent(option)}`);
-  }
-  /** GET /preference/{option} */
-  async getPreference(option, keys) {
-    return this.request(`/preference/${encodeURIComponent(option)}`, {
-      query: { keys: keys.join(",") }
-    });
-  }
-  // ---------- Notification ----------
-  /** POST /notification/sms/outbound */
-  async sendSmsOutbound(payload) {
-    return this.request("/notification/sms/outbound", {
-      method: "POST",
-      body: JSON.stringify(payload)
-    });
-  }
-  /** GET /notification/sms/queue */
-  async getSmsQueue(id) {
-    return this.request("/notification/sms/queue", { query: { id } });
-  }
-  /** POST /notification/sms/inbound */
-  async smsInbound(formData) {
-    return this.request("/notification/sms/inbound", {
-      method: "POST",
-      body: formData,
-      skipContentType: true
-    });
-  }
-  /** POST /notification/sms/status */
-  async smsStatus(payload) {
-    return this.request("/notification/sms/status", {
-      method: "POST",
-      body: JSON.stringify(payload)
-    });
-  }
-  /** GET /notification/sms/outbox/send */
-  async sendSmsOutbox() {
-    return this.request("/notification/sms/outbox/send");
-  }
-  // ---------- Auth ----------
-  /** GET /CallBack – OAuth callback (typically used as redirect URL) */
-  getCallbackUrl() {
-    return `${this.baseUrl}/CallBack`;
-  }
-  /** POST Auth/AddParticipantCredentials */
-  async addParticipantCredentials(payload) {
-    return this.request("/Auth/AddParticipantCredentials", {
-      method: "POST",
-      body: JSON.stringify(payload)
-    });
-  }
-  /** GET Auth/ParticipantCredentials */
-  async getParticipantCredentials(participantId) {
-    return this.request("/Auth/ParticipantCredentials", { query: { participant_id: participantId } });
-  }
-  // ---------- Ping ----------
-  /** GET /ping */
-  async ping() {
-    return this.request("/ping");
-  }
-  /** GET /setup */
-  async setup(name) {
-    return this.request("/setup", { query: name ? { name } : void 0 });
-  }
-  /** GET /reset */
-  async reset() {
-    return this.request("/reset");
-  }
-  /** POST /ping */
-  async pingPost() {
-    return this.request("/ping", { method: "POST" });
-  }
-  // ---------- Schedule ----------
-  /** POST /schedule/calendar/ */
-  async scheduleCalendar(calendar) {
-    return this.request("/schedule/calendar/", {
-      method: "POST",
-      query: calendar ? { calendar } : void 0
-    });
-  }
-};
-
-// src/models/appointment/Calendar.ts
-import { types, getEnv, applySnapshot } from "mobx-state-tree";
+async function request(baseUrl, fetchFn, path, options = {}) {
+  const { method = "GET", headers = {}, body, query, skipContentType } = options;
+  const url = `${String(baseUrl).replace(/\/+$/, "")}${path}${buildQuery(query)}`;
+  const reqHeaders = { ...headers };
+  if (!skipContentType && typeof body === "string") reqHeaders["Content-Type"] = "application/json";
+  const res = await fetchFn(url, { method, headers: reqHeaders, body });
+  const text = await res.text();
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    data = { status: "failure", message: text || res.statusText };
+  }
+  if (!res.ok && data.status !== "failure") {
+    data.status = "failure";
+    data.message = data.message ?? `HTTP ${res.status}`;
+  }
+  return data;
+}
+function createRequestHelpers(self, getEnv9) {
+  const env = () => getEnv9(self);
+  const baseUrl = () => env().baseUrl;
+  const fetchFn = () => env().fetch ?? (typeof fetch !== "undefined" ? fetch : () => {
+    throw new Error("fetch not available");
+  });
+  const req = (path, opts = {}) => {
+    const url = baseUrl();
+    if (!url) throw new Error("Model env requires baseUrl. Call configure({ baseUrl }) at app startup.");
+    return request(url, fetchFn(), path, opts);
+  };
+  return {
+    req,
+    reqGet: (path, query, opts = {}) => req(path, { ...opts, query }),
+    reqPost: (path, body, query, opts = {}) => req(path, { ...opts, method: "POST", body: JSON.stringify(body), query })
+  };
+}
+function createRequestHelpersFromEnv(env) {
+  const e = env ?? getConfig();
+  if (!e) throw new Error("Env required. Pass env to the method or call configure({ baseUrl }) at app startup.");
+  const baseUrl = () => e == null ? void 0 : e.baseUrl;
+  const fetchFn = () => (e == null ? void 0 : e.fetch) ?? (typeof fetch !== "undefined" ? fetch : () => {
+    throw new Error("fetch not available");
+  });
+  const req = (path, opts = {}) => {
+    const url = baseUrl();
+    if (!url) throw new Error("Env requires baseUrl. Call configure({ baseUrl }) at app startup.");
+    return request(url, fetchFn(), path, opts);
+  };
+  return {
+    env: e,
+    req,
+    reqGet: (path, query, opts = {}) => req(path, { ...opts, query }),
+    reqPost: (path, body, query, opts = {}) => req(path, { ...opts, method: "POST", body: JSON.stringify(body), query })
+  };
+}
 
-// src/models/appointment/enums.ts
+// src/models/appointment/enums.js
 var Unit = {
   Minutes: 1,
   Hours: 2,
@@ -709,264 +161,991 @@ var DayOfWeek = {
   Saturday: 6
 };
 
-// src/models/appointment/Calendar.ts
-var CalendarModel = types.model("Calendar", {
-  id: types.maybeNull(types.number),
-  companyKey: types.maybeNull(types.string),
-  calendarId: types.identifier,
-  name: types.maybeNull(types.string),
-  location: types.maybeNull(types.string),
-  timeZoneId: types.maybeNull(types.string),
-  purpose: types.optional(types.string, ""),
-  description: types.maybeNull(types.string),
-  assignmentMethod: types.optional(types.number, AssignmentMethod.RoundRobin),
-  duration: types.optional(types.number, 0),
-  durationUnit: types.optional(types.number, Unit.Minutes),
-  minimumBookingNotice: types.optional(types.number, 0),
-  minimumBookingNoticeUnit: types.optional(types.number, Unit.Minutes),
-  minimumCancelationNotice: types.optional(types.number, 0),
-  minimumCancelationNoticeUnit: types.optional(types.number, Unit.Minutes),
-  futureLimit: types.optional(types.number, 0),
-  futureLimitUnit: types.optional(types.number, Unit.Days),
-  bufferTime: types.optional(types.number, 0),
-  bufferTimeUnit: types.optional(types.number, Unit.Minutes),
-  bookingLimit: types.optional(types.number, 0),
-  createdOn: types.maybeNull(types.string),
-  modifiedOn: types.maybeNull(types.string)
-}).actions((self) => ({
-  async create() {
-    const api = getEnv(self).api;
-    const payload = {
-      calendarId: self.calendarId,
-      companyKey: self.companyKey ?? void 0,
-      name: self.name ?? void 0,
-      location: self.location ?? void 0,
-      timeZoneId: self.timeZoneId ?? void 0,
-      purpose: self.purpose,
-      description: self.description ?? void 0,
-      assignmentMethod: self.assignmentMethod,
-      duration: self.duration,
-      durationUnit: self.durationUnit,
-      minimumBookingNotice: self.minimumBookingNotice,
-      minimumBookingNoticeUnit: self.minimumBookingNoticeUnit,
-      minimumCancelationNotice: self.minimumCancelationNotice,
-      minimumCancelationNoticeUnit: self.minimumCancelationNoticeUnit,
-      futureLimit: self.futureLimit,
-      futureLimitUnit: self.futureLimitUnit,
-      bufferTime: self.bufferTime,
-      bufferTimeUnit: self.bufferTimeUnit,
-      bookingLimit: self.bookingLimit
-    };
-    const res = await api.createCalendar(payload);
-    if (res.status === "success" && res.data) applySnapshot(self, { ...res.data, calendarId: self.calendarId });
-    return res;
-  },
-  async get() {
-    const api = getEnv(self).api;
-    const res = await api.getCalendar(self.calendarId);
-    if (res.status === "success" && res.data) applySnapshot(self, { ...res.data, calendarId: self.calendarId });
-    return res;
-  },
-  async remove() {
-    const api = getEnv(self).api;
-    return api.removeCalendar(self.calendarId);
-  }
-}));
-var Calendar_default = CalendarModel;
+// src/models/appointment/Event.js
+import { types as types3, getEnv, applySnapshot } from "mobx-state-tree";
 
-// src/models/appointment/Event.ts
-import { types as types2, getEnv as getEnv2, applySnapshot as applySnapshot2 } from "mobx-state-tree";
-var EventModel = types2.model("Event", {
-  id: types2.maybeNull(types2.number),
-  eventId: types2.identifier,
-  calendarId: types2.string,
-  participantId: types2.maybeNull(types2.string),
-  title: types2.maybeNull(types2.string),
-  description: types2.maybeNull(types2.string),
-  isRecurring: types2.optional(types2.boolean, false),
-  recurringFrequency: types2.optional(types2.number, RecurringFrequency.None),
-  startDate: types2.string,
-  endDate: types2.string,
+// src/models/appointment/TimeSlot.js
+import { types as types2 } from "mobx-state-tree";
+var TimeSlotModel = types2.model("TimeSlot", {
   startHour: types2.optional(types2.number, 0),
   startMinute: types2.optional(types2.number, 0),
   endHour: types2.optional(types2.number, 0),
   endMinute: types2.optional(types2.number, 0),
-  visitorName: types2.maybeNull(types2.string),
-  visitorEmail: types2.maybeNull(types2.string),
-  visitorPhone: types2.maybeNull(types2.string),
-  createdOn: types2.maybeNull(types2.string),
-  modifiedOn: types2.maybeNull(types2.string),
-  externalEventId: types2.maybeNull(types2.string),
-  attendeeStatus: types2.optional(types2.number, AttendeeStatus.Tentative),
-  rescheduleLink: types2.maybeNull(types2.string),
-  cancelLink: types2.maybeNull(types2.string),
-  timeZone: types2.maybeNull(types2.string),
-  offset: types2.optional(types2.number, 0)
+  startDate: types2.string,
+  endDate: types2.string,
+  participantId: types2.maybeNull(types2.string)
 }).actions((self) => ({
-  async get(params) {
-    const api = getEnv2(self).api;
-    const res = await api.getEvent(params);
-    if (res.status === "success" && res.data) applySnapshot2(self, { ...res.data, eventId: self.eventId });
-    return res;
-  },
-  async create(offsetMinutes) {
-    const api = getEnv2(self).api;
-    const payload = {
-      calendarId: self.calendarId,
-      participantId: self.participantId ?? void 0,
-      title: self.title ?? void 0,
-      description: self.description ?? void 0,
-      startDate: self.startDate,
-      endDate: self.endDate,
-      startHour: self.startHour,
-      startMinute: self.startMinute,
-      endHour: self.endHour,
-      endMinute: self.endMinute,
-      visitorName: self.visitorName ?? void 0,
-      visitorEmail: self.visitorEmail ?? void 0,
-      visitorPhone: self.visitorPhone ?? void 0
-    };
-    const res = await api.createEvent(payload, offsetMinutes);
-    if (res.status === "success" && res.data) applySnapshot2(self, { ...res.data, eventId: self.eventId });
-    return res;
-  },
-  async cancel() {
-    const api = getEnv2(self).api;
-    return api.cancelEvent(self.eventId);
-  },
-  async getCancellable() {
-    const api = getEnv2(self).api;
-    return api.getCancellable(self.eventId);
-  },
-  async getAvailability(params) {
-    const api = getEnv2(self).api;
-    return api.getAvailability({
-      calendarId: self.calendarId,
-      participantId: params.participantId ?? self.participantId ?? void 0,
-      year: params.year,
-      month: params.month,
-      day: params.day,
-      offset: params.offset
-    });
-  },
-  async setReminder() {
-    const api = getEnv2(self).api;
-    return api.setEventReminder(self.eventId);
+  setWithOffset(offsetMinutes) {
+    const start = new Date(self.startDate);
+    const end = new Date(self.endDate);
+    start.setMinutes(start.getMinutes() + offsetMinutes);
+    end.setMinutes(end.getMinutes() + offsetMinutes);
+    self.startDate = start.toISOString();
+    self.endDate = end.toISOString();
+    self.startHour = start.getHours();
+    self.startMinute = start.getMinutes();
+    self.endHour = end.getHours();
+    self.endMinute = end.getMinutes();
   }
 }));
-var Event_default = EventModel;
+var TimeSlot_default = TimeSlotModel;
 
-// src/models/appointment/Availability.ts
-import { types as types3 } from "mobx-state-tree";
-var AvailabilityModel = types3.model("Availability", {
-  id: types3.maybeNull(types3.number),
-  availabilityId: types3.string,
-  calendarId: types3.string,
-  participantId: types3.string,
-  createdOn: types3.maybeNull(types3.string),
-  modifiedOn: types3.maybeNull(types3.string)
+// src/models/appointment/Event.js
+function getDefaultOffset() {
+  var _a;
+  const cfg = getConfig();
+  return ((_a = cfg == null ? void 0 : cfg.getDefaultOffset) == null ? void 0 : _a.call(cfg)) ?? -(/* @__PURE__ */ new Date()).getTimezoneOffset();
+}
+var EventModel = types3.model("Event", {
+  id: types3.optional(types3.maybeNull(types3.number), null),
+  eventId: types3.identifier,
+  calendarId: types3.optional(types3.string, ""),
+  participantId: types3.optional(types3.maybeNull(types3.string), null),
+  title: types3.optional(types3.maybeNull(types3.string), null),
+  description: types3.optional(types3.maybeNull(types3.string), null),
+  isRecurring: types3.optional(types3.boolean, false),
+  recurringFrequency: types3.optional(types3.number, RecurringFrequency.None),
+  startDate: types3.optional(types3.string, ""),
+  endDate: types3.optional(types3.string, ""),
+  startHour: types3.optional(types3.number, 0),
+  startMinute: types3.optional(types3.number, 0),
+  endHour: types3.optional(types3.number, 0),
+  endMinute: types3.optional(types3.number, 0),
+  visitorName: types3.optional(types3.maybeNull(types3.string), null),
+  visitorEmail: types3.optional(types3.maybeNull(types3.string), null),
+  visitorPhone: types3.optional(types3.maybeNull(types3.string), null),
+  createdOn: types3.optional(types3.maybeNull(types3.string), null),
+  modifiedOn: types3.optional(types3.maybeNull(types3.string), null),
+  externalEventId: types3.optional(types3.maybeNull(types3.string), null),
+  attendeeStatus: types3.optional(types3.number, AttendeeStatus.Tentative),
+  rescheduleLink: types3.optional(types3.maybeNull(types3.string), null),
+  cancelLink: types3.optional(types3.maybeNull(types3.string), null),
+  timeZone: types3.optional(types3.maybeNull(types3.string), null),
+  offset: types3.optional(types3.number, 0)
+}).actions((self) => {
+  const { req, reqGet, reqPost } = createRequestHelpers(self, getEnv);
+  const getOffset = () => {
+    var _a, _b;
+    return ((_b = (_a = getEnv(self)).getDefaultOffset) == null ? void 0 : _b.call(_a)) ?? getDefaultOffset();
+  };
+  return {
+    /** GET /event/get – fetch this event by eventId or externalEventId */
+    async get(params) {
+      if ((params == null ? void 0 : params.eventId) ?? (params == null ? void 0 : params.event_id)) {
+        const res = await reqGet("/event/get", { event_id: params.eventId ?? params.event_id });
+        if (res.status === "success" && res.data) applySnapshot(self, { ...res.data, eventId: self.eventId });
+        return res;
+      }
+      if ((params == null ? void 0 : params.externalEventId) ?? (params == null ? void 0 : params.externalevent_id)) {
+        const res = await reqGet("/event/get", { externalevent_id: params.externalEventId ?? params.externalevent_id });
+        if (res.status === "success" && res.data) applySnapshot(self, { ...res.data, eventId: self.eventId });
+        return res;
+      }
+      return { status: "failure", message: "Provide eventId or externalEventId" };
+    },
+    /** POST /event/create – create event */
+    async create(offsetMinutes) {
+      const offset = offsetMinutes ?? getOffset();
+      const payload = {
+        calendarId: self.calendarId,
+        participantId: self.participantId ?? void 0,
+        title: self.title ?? void 0,
+        description: self.description ?? void 0,
+        startDate: self.startDate,
+        endDate: self.endDate,
+        startHour: self.startHour,
+        startMinute: self.startMinute,
+        endHour: self.endHour,
+        endMinute: self.endMinute,
+        visitorName: self.visitorName ?? void 0,
+        visitorEmail: self.visitorEmail ?? void 0,
+        visitorPhone: self.visitorPhone ?? void 0
+      };
+      const res = await reqPost("/event/create", payload, null, { headers: { offset: String(offset) } });
+      if (res.status === "success" && res.data) applySnapshot(self, { ...res.data, eventId: self.eventId });
+      return res;
+    },
+    /** POST /event/update – update event */
+    async update() {
+      const payload = {
+        eventId: self.eventId,
+        calendarId: self.calendarId,
+        participantId: self.participantId ?? void 0,
+        title: self.title ?? void 0,
+        description: self.description ?? void 0,
+        startDate: self.startDate,
+        endDate: self.endDate,
+        startHour: self.startHour,
+        startMinute: self.startMinute,
+        endHour: self.endHour,
+        endMinute: self.endMinute,
+        visitorName: self.visitorName ?? void 0,
+        visitorEmail: self.visitorEmail ?? void 0,
+        visitorPhone: self.visitorPhone ?? void 0
+      };
+      return reqPost("/event/update", payload);
+    },
+    /** POST /event/reschedule – reschedule event */
+    async reschedule(offsetMinutes) {
+      const offset = offsetMinutes ?? getOffset();
+      const payload = {
+        eventId: self.eventId,
+        calendarId: self.calendarId,
+        participantId: self.participantId ?? void 0,
+        title: self.title ?? void 0,
+        description: self.description ?? void 0,
+        startDate: self.startDate,
+        endDate: self.endDate,
+        startHour: self.startHour,
+        startMinute: self.startMinute,
+        endHour: self.endHour,
+        endMinute: self.endMinute,
+        visitorName: self.visitorName ?? void 0,
+        visitorEmail: self.visitorEmail ?? void 0,
+        visitorPhone: self.visitorPhone ?? void 0
+      };
+      const res = await reqPost("/event/reschedule", payload, null, { headers: { offset: String(offset) } });
+      if (res.status === "success" && res.data) applySnapshot(self, { ...res.data, eventId: self.eventId });
+      return res;
+    },
+    /** GET /event/cancel – cancel this event */
+    async cancel() {
+      return reqGet("/event/cancel", { event_id: self.eventId });
+    },
+    /** GET /event/cancellable – check if this event is cancellable */
+    async getCancellable() {
+      const res = await reqGet("/event/cancellable", { event_id: self.eventId });
+      if (res.data !== void 0) return { ...res, data: Boolean(res.data) };
+      return res;
+    },
+    /** GET /event/availability/get – get availability slots for a day */
+    async getAvailability(params) {
+      const query = {
+        calendar_id: self.calendarId,
+        year: params.year,
+        month: params.month,
+        day: params.day
+      };
+      if (params.participantId ?? self.participantId) query.participant_id = params.participantId ?? self.participantId;
+      return reqGet("/event/availability/get", query, { headers: { offset: String(params.offset ?? getOffset()) } });
+    },
+    /** GET /event/seteventreminder/{event_id} – set SMS reminder */
+    async setReminder() {
+      return req(`/event/seteventreminder/${encodeURIComponent(self.eventId)}`, { method: "GET" });
+    },
+    /** GET /event/{eventId}/{attendeeStatus} – set attendee status */
+    async setAttendeeStatus(status) {
+      const statusName = typeof status === "number" ? Object.keys(AttendeeStatus).find((k) => AttendeeStatus[k] === status) ?? "None" : status;
+      return reqGet(`/event/${encodeURIComponent(self.eventId)}/${encodeURIComponent(statusName)}`);
+    }
+  };
 });
-var Availability_default = AvailabilityModel;
+function mapEventFromApi(d) {
+  if (!d) return d;
+  const pick = (...keys) => keys.reduce((v, k) => v ?? d[k], void 0);
+  const n = (v) => v != null && v !== "" ? Number(v) : void 0;
+  return {
+    eventId: String(pick("eventId", "EventId", "event_id") ?? ""),
+    calendarId: String(pick("calendarId", "CalendarId", "calendar_id") ?? ""),
+    participantId: pick("participantId", "ParticipantId", "participant_id") ?? null,
+    title: pick("title", "Title"),
+    description: pick("description", "Description"),
+    startDate: pick("startDate", "StartDate", "start_date"),
+    endDate: pick("endDate", "EndDate", "end_date"),
+    startHour: n(pick("startHour", "StartHour", "start_hour")),
+    startMinute: n(pick("startMinute", "StartMinute", "start_minute")),
+    endHour: n(pick("endHour", "EndHour", "end_hour")),
+    endMinute: n(pick("endMinute", "EndMinute", "end_minute")),
+    visitorName: pick("visitorName", "VisitorName", "visitor_name"),
+    visitorEmail: pick("visitorEmail", "VisitorEmail", "visitor_email"),
+    visitorPhone: pick("visitorPhone", "VisitorPhone", "visitor_phone"),
+    externalEventId: pick("externalEventId", "ExternalEventId", "external_event_id"),
+    attendeeStatus: n(pick("attendeeStatus", "AttendeeStatus", "attendee_status")),
+    rescheduleLink: pick("rescheduleLink", "RescheduleLink", "reschedule_link"),
+    cancelLink: pick("cancelLink", "CancelLink", "cancel_link"),
+    timeZone: pick("timeZone", "TimeZone", "time_zone"),
+    createdOn: pick("createdOn", "CreatedOn", "created_on"),
+    modifiedOn: pick("modifiedOn", "ModifiedOn", "modified_on")
+  };
+}
+EventModel.get = async (eventId) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqGet("/event/get", { event_id: eventId });
+  if (res.status === "success" && res.data) {
+    return EventModel.create(mapEventFromApi(res.data), { env: getConfig() });
+  }
+  return null;
+};
+EventModel.getByExternalId = async (externalEventId) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqGet("/event/get", { externalevent_id: externalEventId });
+  if (res.status === "success" && res.data) {
+    return EventModel.create(mapEventFromApi(res.data), { env: getConfig() });
+  }
+  return null;
+};
+EventModel.getRoundRobinParticipant = async (calendarId) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqGet("/event/participant/roundrobin/get", { calendar_id: calendarId });
+  return res.status === "success" ? res.data : null;
+};
+EventModel.getEarliestAvailableDays = async (calendarId, count, opts = {}) => {
+  const { req } = createRequestHelpersFromEnv(getConfig());
+  const query = { calendar_id: calendarId, count };
+  if (opts.year != null) query.year = opts.year;
+  if (opts.month != null) query.month = opts.month;
+  if (opts.day != null) query.day = opts.day;
+  const offset = opts.offset ?? getDefaultOffset();
+  const res = await req("/event/days/available/get", { method: "GET", query, headers: { offset: String(offset) } });
+  return res.status === "success" && Array.isArray(res.data) ? res.data : null;
+};
+EventModel.getDaySelectable = async (calendarId, year, month, day, opts = {}) => {
+  const { req } = createRequestHelpersFromEnv(getConfig());
+  const query = { calendar_id: calendarId, year, month, day };
+  if (opts.participantId) query.participant_id = opts.participantId;
+  const offset = opts.offset ?? getDefaultOffset();
+  const res = await req("/event/day/selectable/get", { method: "GET", query, headers: { offset: String(offset) } });
+  return res.status === "success" ? Boolean(res.data) : false;
+};
+EventModel.getByVisitorEmail = async (email, opts = {}) => {
+  const { req } = createRequestHelpersFromEnv(getConfig());
+  const query = { email };
+  if (opts.companyKey) query.company_key = opts.companyKey;
+  else if (opts.calendarId) query.calendar_id = opts.calendarId;
+  else throw new Error("companyKey or calendarId required");
+  const offset = opts.offset ?? getDefaultOffset();
+  const res = await req("/event/existing/getbyvisitoremail", { method: "GET", query, headers: { offset: String(offset) } });
+  if (res.status === "success" && Array.isArray(res.data)) {
+    return res.data.map((e) => EventModel.create(mapEventFromApi(e), { env: getConfig() }));
+  }
+  return null;
+};
+EventModel.getByVisitorPhone = async (phone, opts = {}) => {
+  const { req } = createRequestHelpersFromEnv(getConfig());
+  const query = { phone };
+  if (opts.companyKey) query.company_key = opts.companyKey;
+  else if (opts.calendarId) query.calendar_id = opts.calendarId;
+  else throw new Error("companyKey or calendarId required");
+  const offset = opts.offset ?? getDefaultOffset();
+  const res = await req("/event/existing/getbyvisitorphone", { method: "GET", query, headers: { offset: String(offset) } });
+  if (res.status === "success" && Array.isArray(res.data)) {
+    return res.data.map((e) => EventModel.create(mapEventFromApi(e), { env: getConfig() }));
+  }
+  return null;
+};
+EventModel.getAvailability = async (calendarId, year, month, day, opts = {}) => {
+  const { req } = createRequestHelpersFromEnv(getConfig());
+  const query = { calendar_id: calendarId, year, month, day };
+  if (opts.participantId) query.participant_id = opts.participantId;
+  const offset = opts.offset ?? getDefaultOffset();
+  const res = await req("/event/availability/get", { method: "GET", query, headers: { offset: String(offset) } });
+  if (res.status === "success" && Array.isArray(res.data)) {
+    return res.data.map((s) => TimeSlot_default.create({
+      startHour: s.startHour ?? s.StartHour,
+      startMinute: s.startMinute ?? s.StartMinute,
+      endHour: s.endHour ?? s.EndHour,
+      endMinute: s.endMinute ?? s.EndMinute,
+      startDate: s.startDate ?? s.StartDate,
+      endDate: s.endDate ?? s.EndDate,
+      participantId: s.participantId ?? s.ParticipantId ?? null
+    }));
+  }
+  return [];
+};
+EventModel.cancel = async (eventId) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  return reqGet("/event/cancel", { event_id: eventId });
+};
+EventModel.getCancellable = async (eventId) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqGet("/event/cancellable", { event_id: eventId });
+  return res.status === "success" ? Boolean(res.data) : false;
+};
+EventModel.createEvent = async (payload, offsetMinutes) => {
+  const { reqPost } = createRequestHelpersFromEnv(getConfig());
+  const offset = offsetMinutes ?? getDefaultOffset();
+  const res = await reqPost("/event/create", payload, null, { headers: { offset: String(offset) } });
+  if (res.status === "success" && res.data) {
+    return EventModel.create(mapEventFromApi(res.data), { env: getConfig() });
+  }
+  return null;
+};
+EventModel.reschedule = async (payload, offsetMinutes) => {
+  const { reqPost } = createRequestHelpersFromEnv(getConfig());
+  const offset = offsetMinutes ?? getDefaultOffset();
+  const res = await reqPost("/event/reschedule", payload, null, { headers: { offset: String(offset) } });
+  if (res.status === "success" && res.data) {
+    return EventModel.create(mapEventFromApi(res.data), { env: getConfig() });
+  }
+  return null;
+};
+EventModel.updateEvent = async (payload) => {
+  const { reqPost } = createRequestHelpersFromEnv(getConfig());
+  return reqPost("/event/update", payload);
+};
+EventModel.createTest = async (payload, offsetMinutes) => {
+  const { reqPost } = createRequestHelpersFromEnv(getConfig());
+  const offset = offsetMinutes ?? getDefaultOffset();
+  return reqPost("/event/testcreate", payload, null, { headers: { offset: String(offset) } });
+};
+EventModel.getCustomData = async (calendarId, eventId) => {
+  const { reqPost } = createRequestHelpersFromEnv(getConfig());
+  const query = { calendar_id: calendarId };
+  if (eventId) query.event_id = eventId;
+  const res = await reqPost("/event/customdata/get", {}, query);
+  if (res.status === "success" && typeof res.data === "string") {
+    try {
+      return JSON.parse(res.data);
+    } catch {
+      return res.data;
+    }
+  }
+  return res.status === "success" ? res.data : null;
+};
+EventModel.setReminder = async (eventId) => {
+  const { req } = createRequestHelpersFromEnv(getConfig());
+  return req(`/event/seteventreminder/${encodeURIComponent(eventId)}`, { method: "GET" });
+};
+EventModel.setAttendeeStatus = async (eventId, attendeeStatus) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const statusName = typeof attendeeStatus === "number" ? Object.keys(AttendeeStatus).find((k) => AttendeeStatus[k] === attendeeStatus) ?? "None" : attendeeStatus;
+  return reqGet(`/event/${encodeURIComponent(eventId)}/${encodeURIComponent(statusName)}`);
+};
+var Event_default = EventModel;
+
+// src/models/appointment/CalendarParticipant.js
+import { types as types5 } from "mobx-state-tree";
 
-// src/models/appointment/AvailabilityDetail.ts
+// src/models/appointment/ParticipantInfo.js
 import { types as types4 } from "mobx-state-tree";
-var AvailabilityDetailModel = types4.model("AvailabilityDetail", {
-  id: types4.maybeNull(types4.number),
-  availabilityId: types4.string,
-  sunday: types4.optional(types4.boolean, false),
-  monday: types4.optional(types4.boolean, false),
-  tuesday: types4.optional(types4.boolean, false),
-  wednesday: types4.optional(types4.boolean, false),
-  thursday: types4.optional(types4.boolean, false),
-  friday: types4.optional(types4.boolean, false),
-  saturday: types4.optional(types4.boolean, false),
-  startHour: types4.optional(types4.number, 0),
-  startMinute: types4.optional(types4.number, 0),
-  endHour: types4.optional(types4.number, 0),
-  endMinute: types4.optional(types4.number, 0),
-  createdOn: types4.maybeNull(types4.string),
-  modifiedOn: types4.maybeNull(types4.string)
+var ParticipantInfoModel = types4.model("ParticipantInfo", {
+  participantId: types4.optional(types4.string, ""),
+  calendarParticipantId: types4.optional(types4.string, ""),
+  alias: types4.maybeNull(types4.string),
+  email: types4.maybeNull(types4.string),
+  isApproved: types4.optional(types4.boolean, false),
+  emailProvider: types4.optional(types4.number, 0),
+  isAvailable: types4.optional(types4.boolean, false)
 });
-var AvailabilityDetail_default = AvailabilityDetailModel;
+var ParticipantInfo_default = ParticipantInfoModel;
 
-// src/models/appointment/CalendarParticipant.ts
-import { types as types5 } from "mobx-state-tree";
+// src/models/appointment/CalendarParticipant.js
 var CalendarParticipantModel = types5.model("CalendarParticipant", {
-  id: types5.maybeNull(types5.number),
+  id: types5.optional(types5.maybeNull(types5.number), null),
   calendarParticipantId: types5.optional(types5.string, ""),
-  participantId: types5.string,
-  calendarId: types5.string,
-  createdOn: types5.maybeNull(types5.string),
-  modifiedOn: types5.maybeNull(types5.string)
+  participantId: types5.optional(types5.string, ""),
+  calendarId: types5.optional(types5.string, ""),
+  createdOn: types5.optional(types5.maybeNull(types5.string), null),
+  modifiedOn: types5.optional(types5.maybeNull(types5.string), null)
 });
+function mapFromApi(d) {
+  if (!d) return d;
+  const pick = (...keys) => keys.reduce((v, k) => v ?? d[k], void 0);
+  return {
+    id: pick("id", "Id"),
+    calendarParticipantId: String(pick("calendarParticipantId", "CalendarParticipantId", "calendarparticipant_id") ?? ""),
+    participantId: String(pick("participantId", "ParticipantId", "participant_id") ?? ""),
+    calendarId: String(pick("calendarId", "CalendarId", "calendar_id") ?? ""),
+    createdOn: pick("createdOn", "CreatedOn", "created_on") ?? null,
+    modifiedOn: pick("modifiedOn", "ModifiedOn", "modified_on") ?? null
+  };
+}
+CalendarParticipantModel.getByCalendar = async (calendarId) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqGet("/Calendar/Participant/Get", { calendar_id: calendarId });
+  if (res.status === "success" && res.data != null) {
+    const arr = Array.isArray(res.data) ? res.data : typeof res.data === "string" ? JSON.parse(res.data) : [];
+    return arr.map((p) => CalendarParticipantModel.create(mapFromApi({ ...p, calendar_id: calendarId })));
+  }
+  return null;
+};
+CalendarParticipantModel.getInfoByCalendar = async (calendarId) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqGet("/Calendar/Participants/GetInfo", { calendar_id: calendarId });
+  if (res.status === "success" && Array.isArray(res.data)) {
+    return res.data.map(
+      (p) => ParticipantInfo_default.create({
+        participantId: p.participantId ?? p.ParticipantId ?? p.participant_id ?? "",
+        calendarParticipantId: p.calendarParticipantId ?? p.CalendarParticipantId ?? p.calendarparticipant_id ?? "",
+        alias: p.alias ?? p.Alias ?? null,
+        email: p.email ?? p.Email ?? null,
+        isApproved: p.isApproved ?? p.IsApproved ?? p.is_approved ?? false,
+        emailProvider: p.emailProvider ?? p.EmailProvider ?? p.email_provider ?? 0,
+        isAvailable: p.isAvailable ?? p.IsAvailable ?? p.is_available ?? false
+      })
+    );
+  }
+  return null;
+};
+CalendarParticipantModel.getByParticipant = async (participantId) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqGet("/Participant/calendar/get", { participant_id: participantId });
+  if (res.status === "success" && res.data != null) {
+    const arr = Array.isArray(res.data) ? res.data : typeof res.data === "string" ? JSON.parse(res.data) : [];
+    return arr.map((p) => CalendarParticipantModel.create(mapFromApi({ ...p, participant_id: participantId })));
+  }
+  return null;
+};
 var CalendarParticipant_default = CalendarParticipantModel;
 
-// src/models/appointment/Participant.ts
+// src/models/appointment/CalendarDay.js
 import { types as types6 } from "mobx-state-tree";
-var ParticipantModel = types6.model("Participant", {
-  id: types6.maybeNull(types6.number),
-  participantId: types6.identifier,
-  companyKey: types6.maybeNull(types6.string),
-  alias: types6.optional(types6.string, ""),
-  email: types6.optional(types6.string, ""),
-  isApproved: types6.optional(types6.boolean, false),
-  isAvailable: types6.optional(types6.boolean, false),
-  provider: types6.optional(types6.number, 0),
-  createdOn: types6.maybeNull(types6.string),
-  modifiedOn: types6.maybeNull(types6.string),
-  isDeleted: types6.optional(types6.boolean, false)
+var CalendarDayModel = types6.model("CalendarDay", {
+  date: types6.optional(types6.string, "")
 });
-var Participant_default = ParticipantModel;
+var CalendarDay_default = CalendarDayModel;
 
-// src/models/appointment/OpeningHour.ts
-import { types as types7 } from "mobx-state-tree";
-var OpeningHourModel = types7.model("OpeningHour", {
+// src/models/appointment/Calendar.js
+var CalendarModel = types7.model("Calendar", {
   id: types7.maybeNull(types7.number),
-  openingHourId: types7.optional(types7.string, ""),
-  calendarId: types7.string,
-  participantId: types7.string,
-  day: types7.optional(types7.number, 0),
-  startHour: types7.optional(types7.number, 0),
-  startMinute: types7.optional(types7.number, 0),
-  endHour: types7.optional(types7.number, 0),
-  endMinute: types7.optional(types7.number, 0),
-  off: types7.optional(types7.boolean, false),
+  companyKey: types7.maybeNull(types7.string),
+  calendarId: types7.optional(types7.identifier, "new"),
+  name: types7.maybeNull(types7.string),
+  //    location: types.maybeNull(types.string),
+  timeZoneId: types7.maybeNull(types7.string),
+  purpose: types7.optional(types7.string, ""),
+  description: types7.maybeNull(types7.string),
+  assignmentMethod: types7.optional(types7.number, AssignmentMethod.RoundRobin),
+  duration: types7.optional(types7.number, 0),
+  durationUnit: types7.optional(types7.number, Unit.Minutes),
+  minimumBookingNotice: types7.optional(types7.number, 0),
+  minimumBookingNoticeUnit: types7.optional(types7.number, Unit.Minutes),
+  minimumCancelationNotice: types7.optional(types7.number, 0),
+  minimumCancelationNoticeUnit: types7.optional(types7.number, Unit.Minutes),
+  futureLimit: types7.optional(types7.number, 0),
+  futureLimitUnit: types7.optional(types7.number, Unit.Days),
+  bufferTime: types7.optional(types7.number, 0),
+  bufferTimeUnit: types7.optional(types7.number, Unit.Minutes),
+  bookingLimit: types7.optional(types7.number, 0),
   createdOn: types7.maybeNull(types7.string),
   modifiedOn: types7.maybeNull(types7.string)
+}).actions((self) => {
+  const { req, reqGet, reqPost } = createRequestHelpers(self, getEnv2);
+  return {
+    /** GET Calendar/Get – fetch this calendar by calendarId */
+    async get() {
+      if (!self.calendarId) return { status: "failure", message: "calendarId required" };
+      const res = await reqGet("/Calendar/Get", { calendar_id: self.calendarId });
+      if (res.status === "success" && res.data) {
+        applySnapshot2(self, { ...res.data, calendarId: self.calendarId });
+      }
+      return res;
+    },
+    /** POST Calendar/Create – create or update calendar */
+    async create() {
+      const payload = {
+        calendarId: self.calendarId || void 0,
+        companyKey: self.companyKey ?? void 0,
+        name: self.name ?? void 0,
+        timeZoneId: self.timeZoneId ?? void 0,
+        purpose: self.purpose,
+        description: self.description ?? void 0,
+        assignmentMethod: self.assignmentMethod,
+        duration: self.duration,
+        durationUnit: self.durationUnit,
+        minimumBookingNotice: self.minimumBookingNotice,
+        minimumBookingNoticeUnit: self.minimumBookingNoticeUnit,
+        minimumCancelationNotice: self.minimumCancelationNotice,
+        minimumCancelationNoticeUnit: self.minimumCancelationNoticeUnit,
+        futureLimit: self.futureLimit,
+        futureLimitUnit: self.futureLimitUnit,
+        bufferTime: self.bufferTime,
+        bufferTimeUnit: self.bufferTimeUnit,
+        bookingLimit: self.bookingLimit
+      };
+      const res = await reqPost("/Calendar/Create", payload);
+      if (res.status === "success" && res.data) {
+        applySnapshot2(self, { ...res.data, calendarId: res.data.calendarId || self.calendarId });
+      }
+      return res;
+    },
+    /** GET Calendar/Remove */
+    async remove() {
+      if (!self.calendarId) return { status: "failure", message: "calendarId required" };
+      return reqGet("/Calendar/Remove", { calendar_id: self.calendarId });
+    },
+    /** POST Calendar/Event/Update */
+    async update() {
+      const payload = {
+        calendarId: self.calendarId,
+        companyKey: self.companyKey ?? void 0,
+        name: self.name ?? void 0,
+        timeZoneId: self.timeZoneId ?? void 0,
+        purpose: self.purpose,
+        description: self.description ?? void 0,
+        assignmentMethod: self.assignmentMethod,
+        duration: self.duration,
+        durationUnit: self.durationUnit,
+        minimumBookingNotice: self.minimumBookingNotice,
+        minimumBookingNoticeUnit: self.minimumBookingNoticeUnit,
+        minimumCancelationNotice: self.minimumCancelationNotice,
+        minimumCancelationNoticeUnit: self.minimumCancelationNoticeUnit,
+        futureLimit: self.futureLimit,
+        futureLimitUnit: self.futureLimitUnit,
+        bufferTime: self.bufferTime,
+        bufferTimeUnit: self.bufferTimeUnit,
+        bookingLimit: self.bookingLimit
+      };
+      return reqPost("/Calendar/Event/Update", payload);
+    },
+    /** GET Calendar/Participant/Add */
+    async addParticipant(participantId) {
+      if (!self.calendarId) return { status: "failure", message: "calendarId required" };
+      return reqGet("/Calendar/Participant/Add", { calendar_id: self.calendarId, participant_id: participantId });
+    },
+    /** GET Calendar/Participant/Remove */
+    async removeParticipant(participantId) {
+      if (!self.calendarId) return { status: "failure", message: "calendarId required" };
+      return reqGet("/Calendar/Participant/Remove", { calendar_id: self.calendarId, participant_id: participantId });
+    },
+    /** GET Calendar/Participant/OpeningHours/Get */
+    async getParticipantOpeningHours(params = {}) {
+      if (!self.calendarId && !params.calendarParticipantId) {
+        return { status: "failure", message: "calendarId or calendarParticipantId required" };
+      }
+      const q = {};
+      if (params.calendarParticipantId) q.calendarparticipant_id = params.calendarParticipantId;
+      if (params.participantId) q.participant_id = params.participantId;
+      if (params.calendarId) q.calendar_id = params.calendarId;
+      else if (self.calendarId) q.calendar_id = self.calendarId;
+      return reqGet("/Calendar/Participant/OpeningHours/Get", q);
+    },
+    /** POST Calendar/Participant/Availability/OpeningHour/Save */
+    async saveOpeningHour(payload) {
+      return reqPost("/Calendar/Participant/Availability/OpeningHour/Save", payload);
+    },
+    /** POST Calendar/Participant/Availability/OpeningHours/Save */
+    async saveOpeningHours(payload) {
+      return reqPost("/Calendar/Participant/Availability/OpeningHours/Save", payload);
+    },
+    /** GET Calendar/Participant/OpeningHour/Remove */
+    async removeParticipantOpeningHours(participantId) {
+      if (!self.calendarId) return { status: "failure", message: "calendarId required" };
+      return reqGet("/Calendar/Participant/OpeningHour/Remove", { calendar_id: self.calendarId, participant_id: participantId });
+    },
+    /** GET Calendar/Participant/Availability/Add */
+    async addParticipantAvailability(participantId, detail) {
+      if (!self.calendarId) return { status: "failure", message: "calendarId required" };
+      return req("/Calendar/Participant/Availability/Add", {
+        method: "GET",
+        query: { calendar_id: self.calendarId, participant_id: participantId },
+        body: JSON.stringify(detail)
+      });
+    },
+    /** GET Calendar/Participant/All */
+    async getParticipants() {
+      if (!self.calendarId) return { status: "failure", message: "calendarId required" };
+      return reqGet("/Calendar/Participant/All", { calendar_id: self.calendarId });
+    },
+    /** GET Calendar/Month/Get */
+    async getMonth(year, month) {
+      if (!self.calendarId) return { status: "failure", message: "calendarId required" };
+      return reqGet("/Calendar/Month/Get", { calendar_id: self.calendarId, year, month });
+    },
+    /** GET Calendar/Events/Get */
+    async getEvents() {
+      if (!self.calendarId) return { status: "failure", message: "calendarId required" };
+      return reqGet("/Calendar/Events/Get", { calendar_id: self.calendarId });
+    },
+    /** GET Calendar/Participant/Get */
+    async getCalendarParticipant() {
+      if (!self.calendarId) return { status: "failure", message: "calendarId required" };
+      return reqGet("/Calendar/Participant/Get", { calendar_id: self.calendarId });
+    },
+    /** GET Calendar/Participants/GetInfo */
+    async getParticipantsInfo() {
+      if (!self.calendarId) return { status: "failure", message: "calendarId required" };
+      return reqGet("/Calendar/Participants/GetInfo", { calendar_id: self.calendarId });
+    },
+    /** GET Calendar/All – calendars by company_key */
+    async getByCompany(companyKey) {
+      return reqGet("/Calendar/All", { company_key: companyKey || self.companyKey });
+    },
+    /** GET Calendar/TimeZones/Get */
+    async getTimeZones() {
+      return reqGet("/Calendar/TimeZones/Get");
+    },
+    /** GET Calendar/TimeZone/Get – display name for timezone_id */
+    async getTimeZone(timezoneId) {
+      return reqGet("/Calendar/TimeZone/Get", { timezone_id: timezoneId || self.timeZoneId });
+    },
+    /** GET Calendar/CreateWithParticipants */
+    async createWithParticipants(name, companyKey, participantIds, description) {
+      const q = {
+        name,
+        company_key: companyKey,
+        participantids: Array.isArray(participantIds) ? participantIds.join(",") : String(participantIds)
+      };
+      if (description) q.description = description;
+      return reqGet("/Calendar/CreateWithParticipants", q);
+    },
+    /** GET Calendar/EditWithParticipants */
+    async editWithParticipants(calendarId, name, participantIds, description) {
+      const q = {
+        calendar_id: calendarId,
+        name,
+        participantids: Array.isArray(participantIds) ? participantIds.join(",") : String(participantIds)
+      };
+      if (description) q.description = description;
+      return reqGet("/Calendar/EditWithParticipants", q);
+    }
+  };
 });
-var OpeningHour_default = OpeningHourModel;
+function mapCalendarFromApi(d) {
+  if (!d) return d;
+  const pick = (...keys) => keys.reduce((v, k) => v ?? d[k], void 0);
+  const n = (v) => v != null && v !== "" ? Number(v) : void 0;
+  return {
+    id: pick("id", "Id"),
+    companyKey: pick("companyKey", "CompanyKey", "company_key"),
+    calendarId: pick("calendarId", "CalendarId", "calendar_id") ?? "",
+    name: pick("name", "Name"),
+    timeZoneId: pick("timeZoneId", "TimeZoneId", "time_zone_id"),
+    purpose: pick("purpose", "Purpose") ?? "",
+    description: pick("description", "Description"),
+    assignmentMethod: n(pick("assignmentMethod", "AssignmentMethod", "assignment_method")),
+    duration: n(pick("duration", "Duration")),
+    durationUnit: n(pick("durationUnit", "DurationUnit", "duration_unit")),
+    minimumBookingNotice: n(pick("minimumBookingNotice", "MinimumBookingNotice", "minimum_booking_notice")),
+    minimumBookingNoticeUnit: n(pick("minimumBookingNoticeUnit", "MinimumBookingNoticeUnit", "minimum_booking_notice_unit")),
+    minimumCancelationNotice: n(pick("minimumCancelationNotice", "MinimumCancelationNotice", "minimum_cancelation_notice")),
+    minimumCancelationNoticeUnit: n(pick("minimumCancelationNoticeUnit", "MinimumCancelationNoticeUnit", "minimum_cancelation_notice_unit")),
+    futureLimit: n(pick("futureLimit", "FutureLimit", "future_limit")),
+    futureLimitUnit: n(pick("futureLimitUnit", "FutureLimitUnit", "future_limit_unit")),
+    bufferTime: n(pick("bufferTime", "BufferTime", "buffer_time")),
+    bufferTimeUnit: n(pick("bufferTimeUnit", "BufferTimeUnit", "buffer_time_unit")),
+    bookingLimit: n(pick("bookingLimit", "BookingLimit", "booking_limit")),
+    createdOn: pick("createdOn", "CreatedOn", "created_on"),
+    modifiedOn: pick("modifiedOn", "ModifiedOn", "modified_on")
+  };
+}
+CalendarModel.getRaw = async (calendarId) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  return reqGet("/Calendar/Get", { calendar_id: calendarId });
+};
+CalendarModel.get = async (calendarId) => {
+  var _a, _b;
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqGet("/Calendar/Get", { calendar_id: calendarId });
+  if (res.status === "success" && res.data) {
+    const raw = ((_a = res.data) == null ? void 0 : _a.data) ?? ((_b = res.data) == null ? void 0 : _b.Data) ?? res.data;
+    const mapped = mapCalendarFromApi({ ...raw, calendar_id: calendarId });
+    return CalendarModel.create(mapped, { env: getConfig() });
+  }
+  return null;
+};
+CalendarModel.getByCompany = async (companyKey) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqGet("/Calendar/All", { company_key: companyKey });
+  if (res.status === "success" && Array.isArray(res.data)) {
+    return res.data.map(
+      (c) => CalendarModel.create(mapCalendarFromApi(c), { env: getConfig() })
+    );
+  }
+  return null;
+};
+CalendarModel.getTimeZones = async () => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqGet("/Calendar/TimeZones/Get");
+  return res.status === "success" && res.data != null ? res.data : null;
+};
+CalendarModel.getTimeZone = async (timezoneId) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqGet("/Calendar/TimeZone/Get", { timezone_id: timezoneId });
+  return res.status === "success" && res.data != null ? res.data : null;
+};
+CalendarModel.getParticipants = async (calendarId) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqGet("/Calendar/Participant/All", { calendar_id: calendarId });
+  if (res.status === "success" && Array.isArray(res.data)) {
+    return res.data.map(
+      (p) => CalendarParticipant_default.create({
+        ...p,
+        participantId: p.participantId ?? p.participant_id ?? "",
+        calendarId: p.calendarId ?? p.calendar_id ?? calendarId,
+        calendarParticipantId: p.calendarParticipantId ?? p.calendarparticipant_id ?? ""
+      })
+    );
+  }
+  return null;
+};
+CalendarModel.getCalendarParticipant = async (calendarId) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqGet("/Calendar/Participant/Get", { calendar_id: calendarId });
+  if (res.status === "success" && Array.isArray(res.data)) {
+    return res.data.map(
+      (p) => CalendarParticipant_default.create({
+        ...p,
+        participantId: p.participantId ?? p.participant_id ?? "",
+        calendarId: p.calendarId ?? p.calendar_id ?? calendarId,
+        calendarParticipantId: p.calendarParticipantId ?? p.calendarparticipant_id ?? ""
+      })
+    );
+  }
+  return null;
+};
+CalendarModel.getParticipantsInfo = async (calendarId) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqGet("/Calendar/Participants/GetInfo", { calendar_id: calendarId });
+  if (res.status === "success" && Array.isArray(res.data)) {
+    return res.data.map(
+      (p) => ParticipantInfo_default.create({
+        participantId: p.participantId ?? p.participant_id ?? "",
+        calendarParticipantId: p.calendarParticipantId ?? p.calendarparticipant_id ?? "",
+        alias: p.alias ?? null,
+        email: p.email ?? null,
+        isApproved: p.isApproved ?? p.is_approved ?? false,
+        emailProvider: p.emailProvider ?? p.email_provider ?? 0,
+        isAvailable: p.isAvailable ?? p.is_available ?? false
+      })
+    );
+  }
+  return null;
+};
+CalendarModel.getMonth = async (calendarId, year, month) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqGet("/Calendar/Month/Get", { calendar_id: calendarId, year, month });
+  if (res.status === "success" && Array.isArray(res.data)) {
+    return res.data.map((d) => CalendarDay_default.create({ date: d.date ?? d.Date ?? "" }));
+  }
+  return null;
+};
+CalendarModel.getEvents = async (calendarId) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqGet("/Calendar/Events/Get", { calendar_id: calendarId });
+  if (res.status === "success" && Array.isArray(res.data)) {
+    return res.data.map(
+      (ev) => Event_default.create(
+        {
+          ...ev,
+          eventId: ev.eventId ?? ev.event_id ?? "",
+          calendarId: ev.calendarId ?? ev.calendar_id ?? calendarId
+        },
+        { env: getConfig() }
+      )
+    );
+  }
+  return null;
+};
+CalendarModel.createWithParticipants = async (name, companyKey, participantIds, description, calendarId) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const q = {
+    name,
+    company_key: companyKey,
+    participantids: Array.isArray(participantIds) ? participantIds.join(",") : String(participantIds)
+  };
+  if (description) q.description = description;
+  if (calendarId) q.calendar_id = calendarId;
+  const res = await reqGet("/Calendar/CreateWithParticipants", q);
+  if (res.status === "success" && res.data) {
+    const id = typeof res.data === "string" ? res.data : res.data.calendarId ?? res.data.calendar_id;
+    return CalendarModel.get(id);
+  }
+  return null;
+};
+CalendarModel.editWithParticipants = async (calendarId, name, participantIds, description) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const q = {
+    calendar_id: calendarId,
+    name,
+    participantids: Array.isArray(participantIds) ? participantIds.join(",") : String(participantIds)
+  };
+  if (description) q.description = description;
+  const res = await reqGet("/Calendar/EditWithParticipants", q);
+  if (res.status === "success") {
+    return CalendarModel.get(calendarId);
+  }
+  return null;
+};
+var Calendar_default = CalendarModel;
 
-// src/models/appointment/TimeSlot.ts
+// src/models/appointment/Availability.js
 import { types as types8 } from "mobx-state-tree";
-var TimeSlotModel = types8.model("TimeSlot", {
-  startHour: types8.optional(types8.number, 0),
-  startMinute: types8.optional(types8.number, 0),
-  endHour: types8.optional(types8.number, 0),
-  endMinute: types8.optional(types8.number, 0),
-  startDate: types8.string,
-  endDate: types8.string,
-  participantId: types8.maybeNull(types8.string)
-}).actions((self) => ({
-  setWithOffset(offsetMinutes) {
-    const start = new Date(self.startDate);
-    const end = new Date(self.endDate);
-    start.setMinutes(start.getMinutes() + offsetMinutes);
-    end.setMinutes(end.getMinutes() + offsetMinutes);
-    self.startDate = start.toISOString();
-    self.endDate = end.toISOString();
-    self.startHour = start.getHours();
-    self.startMinute = start.getMinutes();
-    self.endHour = end.getHours();
-    self.endMinute = end.getMinutes();
-  }
-}));
-var TimeSlot_default = TimeSlotModel;
+var AvailabilityModel = types8.model("Availability", {
+  id: types8.maybeNull(types8.number),
+  availabilityId: types8.string,
+  calendarId: types8.string,
+  participantId: types8.string,
+  createdOn: types8.maybeNull(types8.string),
+  modifiedOn: types8.maybeNull(types8.string)
+});
+var Availability_default = AvailabilityModel;
 
-// src/models/appointment/TimeFrame.ts
+// src/models/appointment/AvailabilityDetail.js
 import { types as types9 } from "mobx-state-tree";
-var TimeFrameModel = types9.model("TimeFrame", {
-  start: types9.string,
-  end: types9.string
+var AvailabilityDetailModel = types9.model("AvailabilityDetail", {
+  id: types9.maybeNull(types9.number),
+  availabilityId: types9.string,
+  sunday: types9.optional(types9.boolean, false),
+  monday: types9.optional(types9.boolean, false),
+  tuesday: types9.optional(types9.boolean, false),
+  wednesday: types9.optional(types9.boolean, false),
+  thursday: types9.optional(types9.boolean, false),
+  friday: types9.optional(types9.boolean, false),
+  saturday: types9.optional(types9.boolean, false),
+  startHour: types9.optional(types9.number, 0),
+  startMinute: types9.optional(types9.number, 0),
+  endHour: types9.optional(types9.number, 0),
+  endMinute: types9.optional(types9.number, 0),
+  createdOn: types9.maybeNull(types9.string),
+  modifiedOn: types9.maybeNull(types9.string)
+});
+var AvailabilityDetail_default = AvailabilityDetailModel;
+
+// src/models/appointment/Participant.js
+import { types as types10, getEnv as getEnv3, applySnapshot as applySnapshot3 } from "mobx-state-tree";
+var ParticipantModel = types10.model("Participant", {
+  id: types10.optional(types10.maybeNull(types10.number), null),
+  participantId: types10.identifier,
+  companyKey: types10.optional(types10.maybeNull(types10.string), null),
+  alias: types10.optional(types10.string, ""),
+  email: types10.optional(types10.string, ""),
+  isApproved: types10.optional(types10.boolean, false),
+  isAvailable: types10.optional(types10.boolean, false),
+  provider: types10.optional(types10.number, 0),
+  createdOn: types10.optional(types10.maybeNull(types10.string), null),
+  modifiedOn: types10.optional(types10.maybeNull(types10.string), null),
+  isDeleted: types10.optional(types10.boolean, false)
+}).actions((self) => {
+  const { reqGet, reqPost } = createRequestHelpers(self, getEnv3);
+  return {
+    /** GET participant/get – fetch this participant */
+    async get() {
+      const res = await reqGet("/participant/get", { participant_id: self.participantId });
+      if (res.status === "success" && res.data) applySnapshot3(self, mapFromApi2(res.data));
+      return res;
+    },
+    /** POST participant/save – save participant (add or update) */
+    async save() {
+      const payload = toPayload(self);
+      const res = await reqPost("/participant/save", payload);
+      if (res.status === "success" && res.data) applySnapshot3(self, mapFromApi2(res.data));
+      return res;
+    },
+    /** POST participant/update – update participant */
+    async update() {
+      const payload = toPayload(self);
+      const res = await reqPost("/participant/update", payload);
+      if (res.status === "success" && res.data) applySnapshot3(self, mapFromApi2(res.data));
+      return res;
+    },
+    /** GET participant/remove – remove this participant */
+    async remove() {
+      return reqGet("/participant/remove", { participant_id: self.participantId });
+    },
+    /** GET participant/sendemail – send email to this participant */
+    async sendEmail() {
+      return reqGet("/participant/sendemail", { participant_id: self.participantId });
+    }
+  };
+});
+function mapFromApi2(d) {
+  if (!d) return d;
+  const pick = (...keys) => keys.reduce((v, k) => v ?? d[k], void 0);
+  const n = (v) => v != null && v !== "" ? Number(v) : void 0;
+  return {
+    participantId: String(pick("participantId", "ParticipantId", "participant_id") ?? ""),
+    companyKey: pick("companyKey", "CompanyKey", "company_key") ?? null,
+    alias: pick("alias", "Alias") ?? "",
+    email: pick("email", "Email") ?? "",
+    isApproved: Boolean(pick("isApproved", "IsApproved", "is_approved")),
+    isAvailable: Boolean(pick("isAvailable", "IsAvailable", "is_available")),
+    provider: n(pick("provider", "Provider")) ?? 0,
+    createdOn: pick("createdOn", "CreatedOn", "created_on") ?? null,
+    modifiedOn: pick("modifiedOn", "ModifiedOn", "modified_on") ?? null,
+    isDeleted: Boolean(pick("isDeleted", "IsDeleted", "is_deleted"))
+  };
+}
+function toPayload(self) {
+  return {
+    participantId: self.participantId,
+    companyKey: self.companyKey ?? void 0,
+    alias: self.alias,
+    email: self.email,
+    isApproved: self.isApproved,
+    isAvailable: self.isAvailable,
+    provider: self.provider
+  };
+}
+ParticipantModel.get = async (participantId) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqGet("/participant/get", { participant_id: participantId });
+  if (res.status === "success" && res.data) {
+    return ParticipantModel.create(mapFromApi2(res.data), { env: getConfig() });
+  }
+  return null;
+};
+ParticipantModel.getByIds = async (participantIds) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const ids = Array.isArray(participantIds) ? participantIds.join(",") : String(participantIds);
+  const res = await reqGet("/participant/participants/get", { participantids: ids });
+  if (res.status === "success" && Array.isArray(res.data)) {
+    return res.data.map((p) => ParticipantModel.create(mapFromApi2(p), { env: getConfig() }));
+  }
+  return null;
+};
+ParticipantModel.getAll = async (companyKey) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqGet("/Participant/All", { company_key: companyKey });
+  if (res.status === "success" && Array.isArray(res.data)) {
+    return res.data.map((p) => ParticipantModel.create(mapFromApi2(p), { env: getConfig() }));
+  }
+  return null;
+};
+ParticipantModel.add = async (payload, calendarId) => {
+  const { reqPost } = createRequestHelpersFromEnv(getConfig());
+  const query = calendarId ? { calendar_id: calendarId } : null;
+  const res = await reqPost("/Participant/Add", payload, query);
+  if (res.status === "success" && res.data) {
+    return ParticipantModel.create(mapFromApi2(res.data), { env: getConfig() });
+  }
+  return null;
+};
+ParticipantModel.remove = async (participantId) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  return reqGet("/participant/remove", { participant_id: participantId });
+};
+ParticipantModel.update = async (payload) => {
+  const { reqPost } = createRequestHelpersFromEnv(getConfig());
+  return reqPost("/participant/update", payload);
+};
+ParticipantModel.save = async (payload) => {
+  const { reqPost } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqPost("/participant/save", payload);
+  if (res.status === "success" && res.data) {
+    return ParticipantModel.create(mapFromApi2(res.data), { env: getConfig() });
+  }
+  return null;
+};
+ParticipantModel.sendEmail = async (participantId) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  return reqGet("/participant/sendemail", { participant_id: participantId });
+};
+var Participant_default = ParticipantModel;
+
+// src/models/appointment/OpeningHour.js
+import { types as types11 } from "mobx-state-tree";
+var OpeningHourModel = types11.model("OpeningHour", {
+  id: types11.maybeNull(types11.number),
+  openingHourId: types11.optional(types11.string, ""),
+  calendarId: types11.string,
+  participantId: types11.string,
+  day: types11.optional(types11.number, 0),
+  startHour: types11.optional(types11.number, 0),
+  startMinute: types11.optional(types11.number, 0),
+  endHour: types11.optional(types11.number, 0),
+  endMinute: types11.optional(types11.number, 0),
+  off: types11.optional(types11.boolean, false),
+  createdOn: types11.maybeNull(types11.string),
+  modifiedOn: types11.maybeNull(types11.string)
+});
+var OpeningHour_default = OpeningHourModel;
+
+// src/models/appointment/TimeFrame.js
+import { types as types12 } from "mobx-state-tree";
+var TimeFrameModel = types12.model("TimeFrame", {
+  start: types12.string,
+  end: types12.string
 }).actions((self) => ({
   buffer(bufferMinutes, unit) {
     const bfr = unit === Unit.Hours ? bufferMinutes * 60 : bufferMinutes;
@@ -1016,28 +1195,517 @@ var TimeFrameModel = types9.model("TimeFrame", {
 }));
 var TimeFrame_default = TimeFrameModel;
 
-// src/models/appointment/Setting.ts
-import { types as types10 } from "mobx-state-tree";
-var SettingModel = types10.model("Setting", {
-  id: types10.maybeNull(types10.number),
-  settingsId: types10.optional(types10.string, ""),
-  calendarId: types10.string,
-  logo: types10.maybeNull(types10.string),
-  theme: types10.maybeNull(types10.string),
-  schedulingButtonText: types10.maybeNull(types10.string),
-  scheduledMessage: types10.maybeNull(types10.string)
+// src/models/appointment/Setting.js
+import { types as types13, getEnv as getEnv4, applySnapshot as applySnapshot4 } from "mobx-state-tree";
+var SettingModel = types13.model("Setting", {
+  id: types13.optional(types13.maybeNull(types13.number), null),
+  settingsId: types13.optional(types13.string, ""),
+  calendarId: types13.optional(types13.string, ""),
+  logo: types13.optional(types13.maybeNull(types13.string), null),
+  theme: types13.optional(types13.maybeNull(types13.string), null),
+  schedulingButtonText: types13.optional(types13.maybeNull(types13.string), null),
+  scheduledMessage: types13.optional(types13.maybeNull(types13.string), null)
+}).actions((self) => {
+  const { reqGet, reqPost } = createRequestHelpers(self, getEnv4);
+  return {
+    /** GET setting/get – fetch setting for this calendar */
+    async get() {
+      const res = await reqGet("/setting/get", { calendar_id: self.calendarId });
+      if (res.status === "success" && res.data) applySnapshot4(self, mapFromApi3(res.data));
+      return res;
+    },
+    /** POST setting/save – save this setting */
+    async save() {
+      const payload = toPayload2(self);
+      const res = await reqPost("/setting/save", payload);
+      if (res.status === "success" && res.data) applySnapshot4(self, mapFromApi3(res.data));
+      return res;
+    },
+    /** POST setting/logo/upload – upload logo file for this calendar */
+    async uploadLogo(file) {
+      return SettingModel.uploadLogo(self.calendarId, file);
+    }
+  };
 });
+function mapFromApi3(d) {
+  if (!d) return d;
+  const pick = (...keys) => keys.reduce((v, k) => v ?? d[k], void 0);
+  return {
+    settingsId: String(pick("settingsId", "SettingsId", "settings_id") ?? ""),
+    calendarId: String(pick("calendarId", "CalendarId", "calendar_id") ?? ""),
+    logo: pick("logo", "Logo") ?? null,
+    theme: pick("theme", "Theme") ?? null,
+    schedulingButtonText: pick("schedulingButtonText", "SchedulingButtonText", "scheduling_button_text") ?? null,
+    scheduledMessage: pick("scheduledMessage", "ScheduledMessage", "scheduled_message") ?? null
+  };
+}
+function toPayload2(self) {
+  return {
+    settingsId: self.settingsId || void 0,
+    calendarId: self.calendarId,
+    logo: self.logo ?? void 0,
+    theme: self.theme ?? void 0,
+    schedulingButtonText: self.schedulingButtonText ?? void 0,
+    scheduledMessage: self.scheduledMessage ?? void 0
+  };
+}
+SettingModel.get = async (calendarId) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqGet("/setting/get", { calendar_id: calendarId });
+  if (res.status === "success" && res.data) {
+    return SettingModel.create(mapFromApi3(res.data), { env: getConfig() });
+  }
+  return null;
+};
+SettingModel.save = async (payload) => {
+  const { reqPost } = createRequestHelpersFromEnv(getConfig());
+  return reqPost("/setting/save", payload);
+};
+SettingModel.uploadLogo = async (calendarId, file) => {
+  const cfg = getConfig();
+  if (!(cfg == null ? void 0 : cfg.baseUrl)) throw new Error("Configure baseUrl before uploadLogo");
+  const fetchFn = cfg.fetch ?? (typeof fetch !== "undefined" ? fetch : () => {
+    throw new Error("fetch not available");
+  });
+  const baseUrl = String(cfg.baseUrl).replace(/\/+$/, "");
+  const url = `${baseUrl}/setting/logo/upload?calendar_id=${encodeURIComponent(calendarId)}`;
+  const formData = new FormData();
+  formData.append("file", file);
+  const res = await fetchFn(url, {
+    method: "POST",
+    body: formData
+  });
+  const text = await res.text();
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    data = { status: "failure", message: text || res.statusText };
+  }
+  if (!res.ok && data.status !== "failure") {
+    data.status = "failure";
+    data.message = data.message ?? `HTTP ${res.status}`;
+  }
+  return data;
+};
 var Setting_default = SettingModel;
 
-// src/models/appointment/index.ts
-import { types as types11, getEnv as getEnv3 } from "mobx-state-tree";
-var RootStore = types11.model("RootStore", {
-  calendars: types11.optional(types11.map(Calendar_default), {}),
-  events: types11.optional(types11.map(Event_default), {})
+// src/models/appointment/Company.js
+import { types as types14, getEnv as getEnv5, applySnapshot as applySnapshot5 } from "mobx-state-tree";
+var CompanyModel = types14.model("Company", {
+  id: types14.optional(types14.maybeNull(types14.number), null),
+  companyKey: types14.identifier,
+  companyName: types14.optional(types14.string, ""),
+  createdOn: types14.optional(types14.maybeNull(types14.string), null),
+  modifiedOn: types14.optional(types14.maybeNull(types14.string), null)
+}).actions((self) => {
+  const { reqGet, reqPost } = createRequestHelpers(self, getEnv5);
+  return {
+    /** GET Company/Get – fetch this company */
+    async get() {
+      const res = await reqGet("/Company/Get", { company_key: self.companyKey });
+      if (res.status === "success" && res.data) applySnapshot5(self, mapFromApi4(res.data));
+      return res;
+    },
+    /** POST Company/Save – save this company */
+    async save() {
+      const payload = toPayload3(self);
+      const res = await reqPost("/Company/Save", payload);
+      if (res.status === "success" && res.data) applySnapshot5(self, mapFromApi4(res.data));
+      return res;
+    }
+  };
+});
+function mapFromApi4(d) {
+  if (!d) return d;
+  const pick = (...keys) => keys.reduce((v, k) => v ?? d[k], void 0);
+  return {
+    companyKey: String(pick("companyKey", "CompanyKey", "company_key") ?? ""),
+    companyName: pick("companyName", "CompanyName", "company_name") ?? "",
+    createdOn: pick("createdOn", "CreatedOn", "created_on") ?? null,
+    modifiedOn: pick("modifiedOn", "ModifiedOn", "modified_on") ?? null
+  };
+}
+function toPayload3(self) {
+  return {
+    companyKey: self.companyKey,
+    companyName: self.companyName ?? void 0
+  };
+}
+CompanyModel.get = async (companyKey) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqGet("/Company/Get", { company_key: companyKey });
+  if (res.status === "success" && res.data) {
+    return CompanyModel.create(mapFromApi4(res.data), { env: getConfig() });
+  }
+  return null;
+};
+CompanyModel.getAll = async () => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqGet("/Company/All");
+  if (res.status === "success" && Array.isArray(res.data)) {
+    return res.data.map((c) => CompanyModel.create(mapFromApi4(c), { env: getConfig() }));
+  }
+  return null;
+};
+CompanyModel.save = async (payload) => {
+  const { reqPost } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqPost("/Company/Save", payload);
+  if (res.status === "success" && res.data) {
+    return CompanyModel.create(mapFromApi4(res.data), { env: getConfig() });
+  }
+  return null;
+};
+var Company_default = CompanyModel;
+
+// src/models/appointment/Preference.js
+import { types as types15 } from "mobx-state-tree";
+var PreferenceScope = {
+  Global: 0,
+  Consumer: 1,
+  Company: 2,
+  Calendar: 3,
+  Event: 4
+};
+var SCOPE_NAMES = ["Global", "Consumer", "Company", "Calendar", "Event"];
+var PreferenceModel = types15.model("Preference", {
+  id: types15.optional(types15.maybeNull(types15.number), null),
+  preferenceId: types15.optional(types15.maybeNull(types15.string), null),
+  level: types15.optional(types15.number, 0),
+  primaryKey: types15.optional(types15.string, ""),
+  preferenceOption: types15.optional(types15.string, ""),
+  optionsJson: types15.optional(types15.maybeNull(types15.string), null)
 }).actions((self) => ({
-  getApi() {
-    return getEnv3(self).api;
+  /** POST /preference/{scope}/{key}/{option} – save this preference to the API. */
+  async save() {
+    const scope = SCOPE_NAMES[self.level] ?? "Global";
+    return PreferenceModel.set(scope, self.primaryKey, self.preferenceOption, self.optionsJson ?? "{}");
   },
+  /** GET /preference/remove?preference_id={id} – remove this preference from the API. Requires preferenceId from a prior get. */
+  async delete() {
+    if (!self.preferenceId) throw new Error("preferenceId required for delete; use PreferenceModel.delete(preferenceId) or load preference from get first.");
+    return PreferenceModel.delete(self.preferenceId);
+  }
+}));
+PreferenceModel.getScopes = async () => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqGet("/preference/scopes");
+  return res.status === "success" && res.data != null ? res.data : null;
+};
+PreferenceModel.getOptions = async () => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqGet("/preference/options");
+  return res.status === "success" && res.data != null ? res.data : null;
+};
+PreferenceModel.getOptionTemplate = async (option) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqGet(`/preference/options/${encodeURIComponent(option)}`);
+  return res.status === "success" && res.data != null ? res.data : null;
+};
+PreferenceModel.get = async (option, keys) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const keysArr = Array.isArray(keys) ? keys : keys != null ? [String(keys)] : [];
+  const query = keysArr.length ? { keys: keysArr } : {};
+  const res = await reqGet(`/preference/${encodeURIComponent(option)}`, query);
+  return res.status === "success" && res.data != null ? res.data : null;
+};
+PreferenceModel.set = async (scope, key, option, body) => {
+  const { req } = createRequestHelpersFromEnv(getConfig());
+  const path = `/preference/${encodeURIComponent(scope)}/${encodeURIComponent(key)}/${encodeURIComponent(option)}`;
+  const payload = typeof body === "string" ? body : JSON.stringify(body ?? {});
+  return req(path, { method: "POST", body: payload });
+};
+PreferenceModel.delete = async (preferenceId) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  return reqGet("/preference/remove", { preference_id: preferenceId });
+};
+var Preference_default = PreferenceModel;
+
+// src/models/appointment/Flow.js
+import { types as types16, getEnv as getEnv6, applySnapshot as applySnapshot6 } from "mobx-state-tree";
+function mapFlowFromApi(d) {
+  if (!d) return d;
+  const pick = (...keys) => keys.reduce((v, k) => v ?? d[k], void 0);
+  const b = (v) => v === true || v === "true" || v === 1;
+  return {
+    id: pick("id", "Id") ?? null,
+    flowId: pick("flowId", "FlowId", "flow_id") ?? "",
+    companyKey: pick("companyKey", "CompanyKey", "company_key") ?? "",
+    name: pick("name", "Name") ?? "",
+    description: pick("description", "Description") ?? null,
+    flowJson: pick("flowJson", "FlowJson", "flow_json") ?? "",
+    isActive: b(pick("isActive", "IsActive", "is_active")) ?? true,
+    isDeleted: b(pick("isDeleted", "IsDeleted", "is_deleted")) ?? false,
+    createdOn: pick("createdOn", "CreatedOn", "created_on") ?? null,
+    modifiedOn: pick("modifiedOn", "ModifiedOn", "modified_on") ?? null
+  };
+}
+var FlowModel = types16.model("Flow", {
+  id: types16.maybeNull(types16.number),
+  flowId: types16.optional(types16.identifier, "new"),
+  companyKey: types16.maybeNull(types16.string),
+  name: types16.maybeNull(types16.string),
+  description: types16.maybeNull(types16.string),
+  flowJson: types16.optional(types16.string, ""),
+  isActive: types16.optional(types16.boolean, true),
+  isDeleted: types16.optional(types16.boolean, false),
+  createdOn: types16.maybeNull(types16.string),
+  modifiedOn: types16.maybeNull(types16.string)
+}).actions((self) => {
+  const { reqGet, reqPost } = createRequestHelpers(self, getEnv6);
+  return {
+    /** GET flow/get – fetch this flow by flowId */
+    async get() {
+      if (!self.flowId || self.flowId === "new") return { status: "failure", message: "flowId required" };
+      const res = await reqGet("/flow/get", { flow_id: self.flowId });
+      if (res.status === "success" && res.data) {
+        applySnapshot6(self, mapFlowFromApi(res.data));
+      }
+      return res;
+    },
+    /** POST flow/create – create flow */
+    async create() {
+      const payload = {
+        companyKey: self.companyKey ?? void 0,
+        name: self.name ?? void 0,
+        description: self.description ?? void 0,
+        flowJson: self.flowJson || void 0,
+        isActive: self.isActive
+      };
+      const res = await reqPost("/flow/create", payload);
+      if (res.status === "success" && res.data) {
+        applySnapshot6(self, mapFlowFromApi(res.data));
+      }
+      return res;
+    },
+    /** POST flow/update – update flow */
+    async update() {
+      const payload = {
+        flowId: self.flowId,
+        name: self.name ?? void 0,
+        description: self.description ?? void 0,
+        flowJson: self.flowJson || void 0,
+        isActive: self.isActive
+      };
+      const res = await reqPost("/flow/update", payload);
+      if (res.status === "success" && res.data) {
+        applySnapshot6(self, mapFlowFromApi(res.data));
+      }
+      return res;
+    },
+    /** POST flow/delete – soft delete flow */
+    async delete() {
+      if (!self.flowId || self.flowId === "new") return { status: "failure", message: "flowId required" };
+      return reqPost("/flow/delete", { flow_id: self.flowId });
+    },
+    /** POST flow/duplicate – duplicate flow */
+    async duplicate(newName) {
+      if (!self.flowId || self.flowId === "new") return { status: "failure", message: "flowId required" };
+      const res = await reqPost("/flow/duplicate", { flow_id: self.flowId, new_name: newName ?? void 0 });
+      return res;
+    }
+  };
+});
+FlowModel.list = async (companyKey, includeDeleted = false) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const query = { company_key: companyKey };
+  if (includeDeleted) query.include_deleted = "true";
+  const res = await reqGet("/flow/list", query);
+  if (res.status === "success" && Array.isArray(res.data)) {
+    return res.data.map((f) => FlowModel.create(mapFlowFromApi(f), { env: getConfig() }));
+  }
+  return null;
+};
+FlowModel.get = async (flowId) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqGet("/flow/get", { flow_id: flowId });
+  if (res.status === "success" && res.data) {
+    return FlowModel.create(mapFlowFromApi(res.data), { env: getConfig() });
+  }
+  return null;
+};
+FlowModel.createFlow = async (payload) => {
+  const { reqPost } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqPost("/flow/create", payload);
+  if (res.status === "success" && res.data) {
+    return FlowModel.create(mapFlowFromApi(res.data), { env: getConfig() });
+  }
+  return null;
+};
+FlowModel.updateFlow = async (payload) => {
+  const { reqPost } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqPost("/flow/update", payload);
+  if (res.status === "success" && res.data) {
+    return FlowModel.create(mapFlowFromApi(res.data), { env: getConfig() });
+  }
+  return null;
+};
+FlowModel.delete = async (flowId) => {
+  const { reqPost } = createRequestHelpersFromEnv(getConfig());
+  return reqPost("/flow/delete", { flow_id: flowId });
+};
+FlowModel.duplicate = async (flowId, newName) => {
+  const { reqPost } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqPost("/flow/duplicate", { flow_id: flowId, new_name: newName ?? void 0 });
+  if (res.status === "success" && res.data) {
+    return FlowModel.create(mapFlowFromApi(res.data), { env: getConfig() });
+  }
+  return null;
+};
+FlowModel.getAppearance = async (flowId) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqGet("/flow/appearance/get", { flow_id: flowId });
+  if (res.status === "success" && res.data != null) {
+    const d = res.data;
+    return {
+      id: d.id ?? d.Id ?? null,
+      flowId: d.flowId ?? d.FlowId ?? d.flow_id ?? flowId,
+      appearanceJson: d.appearanceJson ?? d.AppearanceJson ?? d.appearance_json ?? "",
+      createdOn: d.createdOn ?? d.CreatedOn ?? d.created_on ?? null,
+      modifiedOn: d.modifiedOn ?? d.ModifiedOn ?? d.modified_on ?? null
+    };
+  }
+  return null;
+};
+FlowModel.saveAppearance = async (payload) => {
+  const { reqPost } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqPost("/flow/appearance/save", payload);
+  if (res.status === "success" && res.data) {
+    const d = res.data;
+    return {
+      id: d.id ?? d.Id ?? null,
+      flowId: d.flowId ?? d.FlowId ?? d.flow_id ?? payload.flowId ?? payload.flow_id,
+      appearanceJson: d.appearanceJson ?? d.AppearanceJson ?? d.appearance_json ?? "",
+      createdOn: d.createdOn ?? d.CreatedOn ?? d.created_on ?? null,
+      modifiedOn: d.modifiedOn ?? d.ModifiedOn ?? d.modified_on ?? null
+    };
+  }
+  return null;
+};
+FlowModel.getEmbed = async (flowId) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqGet("/flow/embed/get", { flow_id: flowId });
+  if (res.status === "success" && res.data != null) {
+    const d = res.data;
+    return {
+      id: d.id ?? d.Id ?? null,
+      flowId: d.flowId ?? d.FlowId ?? d.flow_id ?? flowId,
+      embedJson: d.embedJson ?? d.EmbedJson ?? d.embed_json ?? "",
+      createdOn: d.createdOn ?? d.CreatedOn ?? d.created_on ?? null,
+      modifiedOn: d.modifiedOn ?? d.ModifiedOn ?? d.modified_on ?? null
+    };
+  }
+  return null;
+};
+FlowModel.saveEmbed = async (payload) => {
+  const { reqPost } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqPost("/flow/embed/save", payload);
+  if (res.status === "success" && res.data) {
+    const d = res.data;
+    return {
+      id: d.id ?? d.Id ?? null,
+      flowId: d.flowId ?? d.FlowId ?? d.flow_id ?? payload.flowId ?? payload.flow_id,
+      embedJson: d.embedJson ?? d.EmbedJson ?? d.embed_json ?? "",
+      createdOn: d.createdOn ?? d.CreatedOn ?? d.created_on ?? null,
+      modifiedOn: d.modifiedOn ?? d.ModifiedOn ?? d.modified_on ?? null
+    };
+  }
+  return null;
+};
+FlowModel.getPublic = async (flowId) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqGet("/flow/public/get", { flow_id: flowId });
+  if (res.status === "success" && res.data) {
+    const d = res.data;
+    return {
+      flow: d.flow ? mapFlowFromApi(d.flow) : null,
+      appearance: d.appearance ?? null,
+      embed: d.embed ?? null
+    };
+  }
+  return null;
+};
+FlowModel.getPreview = async (flowId) => {
+  return FlowModel.getPublic(flowId);
+};
+var Flow_default = FlowModel;
+
+// src/models/appointment/Lead.js
+import { types as types17, getEnv as getEnv7, applySnapshot as applySnapshot7 } from "mobx-state-tree";
+function mapLeadFromApi(d) {
+  if (!d) return d;
+  const pick = (...keys) => keys.reduce((v, k) => v ?? d[k], void 0);
+  return {
+    id: pick("id", "Id") ?? null,
+    leadId: pick("leadId", "LeadId", "lead_id") ?? "",
+    email: pick("email", "Email") ?? "",
+    name: pick("name", "Name") ?? "",
+    phone: pick("phone", "Phone") ?? "",
+    companyKey: pick("companyKey", "CompanyKey", "company_key") ?? "",
+    source: pick("source", "Source") ?? "",
+    createdOn: pick("createdOn", "CreatedOn", "created_on") ?? null,
+    modifiedOn: pick("modifiedOn", "ModifiedOn", "modified_on") ?? null
+  };
+}
+var LeadModel = types17.model("Lead", {
+  id: types17.maybeNull(types17.number),
+  leadId: types17.optional(types17.identifier, "new"),
+  email: types17.optional(types17.string, ""),
+  name: types17.optional(types17.string, ""),
+  phone: types17.optional(types17.string, ""),
+  companyKey: types17.optional(types17.string, ""),
+  source: types17.optional(types17.string, ""),
+  createdOn: types17.maybeNull(types17.string),
+  modifiedOn: types17.maybeNull(types17.string)
+}).actions((self) => {
+  const { reqGet } = createRequestHelpers(self, getEnv7);
+  return {
+    /** GET /lead/get – fetch this lead by leadId */
+    async get() {
+      if (!self.leadId || self.leadId === "new") return { status: "failure", message: "leadId required" };
+      const res = await reqGet("/lead/get", { lead_id: self.leadId });
+      if (res.status === "success" && res.data) {
+        applySnapshot7(self, mapLeadFromApi(res.data));
+      }
+      return res;
+    }
+  };
+});
+LeadModel.get = async (leadId) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqGet("/lead/get", { lead_id: leadId });
+  if (res.status === "success" && res.data) {
+    return LeadModel.create(mapLeadFromApi(res.data), { env: getConfig() });
+  }
+  return null;
+};
+LeadModel.getByEmail = async (email, companyKey) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const res = await reqGet("/lead/getbyemail", { email, company_key: companyKey });
+  if (res.status === "success" && res.data) {
+    return LeadModel.create(mapLeadFromApi(res.data), { env: getConfig() });
+  }
+  return null;
+};
+LeadModel.getByCompany = async (companyKey, opts = {}) => {
+  const { reqGet } = createRequestHelpersFromEnv(getConfig());
+  const query = { company_key: companyKey };
+  if (opts.skip != null) query.skip = opts.skip;
+  if (opts.take != null) query.take = opts.take;
+  const res = await reqGet("/lead/company/get", query);
+  if (res.status === "success" && Array.isArray(res.data)) {
+    return res.data.map((l) => LeadModel.create(mapLeadFromApi(l), { env: getConfig() }));
+  }
+  return null;
+};
+var Lead_default = LeadModel;
+
+// src/models/appointment/index.js
+import { types as types18, getEnv as getEnv8 } from "mobx-state-tree";
+var RootStore = types18.model("RootStore", {
+  calendars: types18.optional(types18.map(Calendar_default), {}),
+  events: types18.optional(types18.map(Event_default), {})
+}).actions((self) => ({
   addCalendar(snapshot) {
     const cal = Calendar_default.create(snapshot);
     self.calendars.set(cal.calendarId, cal);
@@ -1049,23 +1717,39 @@ var RootStore = types11.model("RootStore", {
     return ev;
   }
 }));
+function createRootStore(initialState = {}) {
+  const env = getConfig();
+  if (!env) throw new Error("Call configure({ baseUrl }) before createRootStore()");
+  return RootStore.create(initialState, { env });
+}
 export {
-  AppointmentClient,
   AssignmentMethod,
   AttendeeStatus,
   AvailabilityDetail_default as AvailabilityDetailModel,
   Availability_default as AvailabilityModel,
+  CalendarDay_default as CalendarDayModel,
   Calendar_default as CalendarModel,
   CalendarParticipant_default as CalendarParticipantModel,
+  Company_default as CompanyModel,
+  ConfigModel_default as ConfigModel,
   DayOfWeek,
   Event_default as EventModel,
+  Flow_default as FlowModel,
+  Lead_default as LeadModel,
   OpeningHour_default as OpeningHourModel,
+  ParticipantInfo_default as ParticipantInfoModel,
   Participant_default as ParticipantModel,
+  Preference_default as PreferenceModel,
+  PreferenceScope,
   RecurringFrequency,
   RootStore,
   Setting_default as SettingModel,
   TimeFrame_default as TimeFrameModel,
   TimeSlot_default as TimeSlotModel,
   Unit,
-  mapCreateEventInputToEvent
+  configure,
+  createRootStore,
+  getConfig,
+  getConfigStore,
+  setBaseUrl
 };