@blazeo.com/calendar-client 1.0.0 → 1.0.2

package/dist/index.mjs

@@ -0,0 +1,1071 @@
+// src/mapper.ts
+function pickStr(obj, ...keys) {
+  for (const k of keys) {
+    const v = obj[k];
+    if (v != null && typeof v === "string") return v;
+  }
+  return void 0;
+}
+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;
+}
+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 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
+  };
+}
+
+// src/client.ts
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.replace(/\/+$/, "");
+}
+function buildQuery(params) {
+  const search = new URLSearchParams();
+  for (const [k, v] of Object.entries(params)) {
+    if (v === void 0 || v === null) continue;
+    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";
+
+// src/models/appointment/enums.ts
+var Unit = {
+  Minutes: 1,
+  Hours: 2,
+  Days: 3,
+  Months: 4,
+  Year: 5,
+  Week: 6
+};
+var AssignmentMethod = {
+  RoundRobin: 1,
+  MaximizeAvailability: 2
+};
+var AttendeeStatus = {
+  None: 0,
+  Accepted: 1,
+  Declined: 2,
+  Tentative: 3,
+  NeedsAction: 4,
+  Canceled: 5
+};
+var RecurringFrequency = {
+  None: 0,
+  Daily: 1,
+  Weekly: 2,
+  Monthly: 3,
+  Yearly: 4
+};
+var DayOfWeek = {
+  Sunday: 0,
+  Monday: 1,
+  Tuesday: 2,
+  Wednesday: 3,
+  Thursday: 4,
+  Friday: 5,
+  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.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,
+  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)
+}).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);
+  }
+}));
+var Event_default = EventModel;
+
+// 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)
+});
+var Availability_default = AvailabilityModel;
+
+// src/models/appointment/AvailabilityDetail.ts
+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 AvailabilityDetail_default = AvailabilityDetailModel;
+
+// src/models/appointment/CalendarParticipant.ts
+import { types as types5 } from "mobx-state-tree";
+var CalendarParticipantModel = types5.model("CalendarParticipant", {
+  id: types5.maybeNull(types5.number),
+  calendarParticipantId: types5.optional(types5.string, ""),
+  participantId: types5.string,
+  calendarId: types5.string,
+  createdOn: types5.maybeNull(types5.string),
+  modifiedOn: types5.maybeNull(types5.string)
+});
+var CalendarParticipant_default = CalendarParticipantModel;
+
+// src/models/appointment/Participant.ts
+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 Participant_default = ParticipantModel;
+
+// src/models/appointment/OpeningHour.ts
+import { types as types7 } from "mobx-state-tree";
+var OpeningHourModel = types7.model("OpeningHour", {
+  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),
+  createdOn: types7.maybeNull(types7.string),
+  modifiedOn: types7.maybeNull(types7.string)
+});
+var OpeningHour_default = OpeningHourModel;
+
+// src/models/appointment/TimeSlot.ts
+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;
+
+// src/models/appointment/TimeFrame.ts
+import { types as types9 } from "mobx-state-tree";
+var TimeFrameModel = types9.model("TimeFrame", {
+  start: types9.string,
+  end: types9.string
+}).actions((self) => ({
+  buffer(bufferMinutes, unit) {
+    const bfr = unit === Unit.Hours ? bufferMinutes * 60 : bufferMinutes;
+    const s = new Date(self.start);
+    const e = new Date(self.end);
+    s.setMinutes(s.getMinutes() - bfr);
+    e.setMinutes(e.getMinutes() + bfr);
+    self.start = s.toISOString();
+    self.end = e.toISOString();
+  },
+  conflicts(start, end) {
+    const thisStart = new Date(self.start).getTime();
+    const thisEnd = new Date(self.end).getTime();
+    const startT = start.getTime();
+    const endT = end.getTime();
+    return startT >= thisStart && startT <= thisEnd || endT >= thisStart && endT <= thisEnd || startT <= thisStart && endT >= thisEnd;
+  },
+  breakIntoSlots(slotDurationMinutes) {
+    const start = new Date(self.start);
+    const end = new Date(self.end);
+    const slots = [];
+    let current = new Date(start);
+    const align = (m) => {
+      if (m === 0 || m === 15 || m === 30 || m === 45) return m;
+      if (m > 0 && m < 15) return 15;
+      if (m > 15 && m < 30) return 30;
+      if (m > 30 && m < 45) return 45;
+      return 0;
+    };
+    current.setMinutes(align(current.getMinutes()), 0, 0);
+    let slotEnd = new Date(current.getTime());
+    slotEnd.setMinutes(slotEnd.getMinutes() + slotDurationMinutes);
+    while (slotEnd.getTime() <= end.getTime()) {
+      slots.push({
+        startHour: current.getHours(),
+        startMinute: current.getMinutes(),
+        endHour: slotEnd.getHours(),
+        endMinute: slotEnd.getMinutes(),
+        startDate: current.toISOString(),
+        endDate: slotEnd.toISOString()
+      });
+      current = new Date(slotEnd.getTime());
+      slotEnd.setMinutes(slotEnd.getMinutes() + slotDurationMinutes);
+    }
+    return slots;
+  }
+}));
+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)
+});
+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), {})
+}).actions((self) => ({
+  getApi() {
+    return getEnv3(self).api;
+  },
+  addCalendar(snapshot) {
+    const cal = Calendar_default.create(snapshot);
+    self.calendars.set(cal.calendarId, cal);
+    return cal;
+  },
+  addEvent(snapshot) {
+    const ev = Event_default.create(snapshot);
+    self.events.set(ev.eventId, ev);
+    return ev;
+  }
+}));
+export {
+  AppointmentClient,
+  AssignmentMethod,
+  AttendeeStatus,
+  AvailabilityDetail_default as AvailabilityDetailModel,
+  Availability_default as AvailabilityModel,
+  Calendar_default as CalendarModel,
+  CalendarParticipant_default as CalendarParticipantModel,
+  DayOfWeek,
+  Event_default as EventModel,
+  OpeningHour_default as OpeningHourModel,
+  Participant_default as ParticipantModel,
+  RecurringFrequency,
+  RootStore,
+  Setting_default as SettingModel,
+  TimeFrame_default as TimeFrameModel,
+  TimeSlot_default as TimeSlotModel,
+  Unit,
+  mapCreateEventInputToEvent
+};