@blazeo.com/calendar-client 1.0.0 → 1.0.1

package/dist/index.js

@@ -0,0 +1,707 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AppointmentClient: () => AppointmentClient,
+  AssignmentMethod: () => AssignmentMethod,
+  AttendeeStatus: () => AttendeeStatus,
+  AvailabilityDetailModel: () => AvailabilityDetail_default,
+  AvailabilityModel: () => Availability_default,
+  CalendarModel: () => Calendar_default,
+  CalendarParticipantModel: () => CalendarParticipant_default,
+  DayOfWeek: () => DayOfWeek,
+  EventModel: () => Event_default,
+  OpeningHourModel: () => OpeningHour_default,
+  ParticipantModel: () => Participant_default,
+  RecurringFrequency: () => RecurringFrequency,
+  RootStore: () => RootStore,
+  SettingModel: () => Setting_default,
+  TimeFrameModel: () => TimeFrame_default,
+  TimeSlotModel: () => TimeSlot_default,
+  Unit: () => Unit,
+  mapCreateEventInputToEvent: () => mapCreateEventInputToEvent
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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 } = options;
+    const url = `${this.baseUrl}${path}${buildQuery(query ?? {})}`;
+    const reqHeaders = {
+      "Content-Type": "application/json",
+      ...headers
+    };
+    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)}`);
+  }
+  // ---------- 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 } });
+  }
+};
+
+// src/models/appointment/Calendar.ts
+var import_mobx_state_tree = require("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 = import_mobx_state_tree.types.model("Calendar", {
+  id: import_mobx_state_tree.types.maybeNull(import_mobx_state_tree.types.number),
+  companyKey: import_mobx_state_tree.types.maybeNull(import_mobx_state_tree.types.string),
+  calendarId: import_mobx_state_tree.types.identifier,
+  name: import_mobx_state_tree.types.maybeNull(import_mobx_state_tree.types.string),
+  location: import_mobx_state_tree.types.maybeNull(import_mobx_state_tree.types.string),
+  timeZoneId: import_mobx_state_tree.types.maybeNull(import_mobx_state_tree.types.string),
+  purpose: import_mobx_state_tree.types.optional(import_mobx_state_tree.types.string, ""),
+  description: import_mobx_state_tree.types.maybeNull(import_mobx_state_tree.types.string),
+  assignmentMethod: import_mobx_state_tree.types.optional(import_mobx_state_tree.types.number, AssignmentMethod.RoundRobin),
+  duration: import_mobx_state_tree.types.optional(import_mobx_state_tree.types.number, 0),
+  durationUnit: import_mobx_state_tree.types.optional(import_mobx_state_tree.types.number, Unit.Minutes),
+  minimumBookingNotice: import_mobx_state_tree.types.optional(import_mobx_state_tree.types.number, 0),
+  minimumBookingNoticeUnit: import_mobx_state_tree.types.optional(import_mobx_state_tree.types.number, Unit.Minutes),
+  minimumCancelationNotice: import_mobx_state_tree.types.optional(import_mobx_state_tree.types.number, 0),
+  minimumCancelationNoticeUnit: import_mobx_state_tree.types.optional(import_mobx_state_tree.types.number, Unit.Minutes),
+  futureLimit: import_mobx_state_tree.types.optional(import_mobx_state_tree.types.number, 0),
+  futureLimitUnit: import_mobx_state_tree.types.optional(import_mobx_state_tree.types.number, Unit.Days),
+  bufferTime: import_mobx_state_tree.types.optional(import_mobx_state_tree.types.number, 0),
+  bufferTimeUnit: import_mobx_state_tree.types.optional(import_mobx_state_tree.types.number, Unit.Minutes),
+  bookingLimit: import_mobx_state_tree.types.optional(import_mobx_state_tree.types.number, 0),
+  createdOn: import_mobx_state_tree.types.maybeNull(import_mobx_state_tree.types.string),
+  modifiedOn: import_mobx_state_tree.types.maybeNull(import_mobx_state_tree.types.string)
+}).actions((self) => ({
+  async create() {
+    const api = (0, import_mobx_state_tree.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) (0, import_mobx_state_tree.applySnapshot)(self, { ...res.data, calendarId: self.calendarId });
+    return res;
+  },
+  async get() {
+    const api = (0, import_mobx_state_tree.getEnv)(self).api;
+    const res = await api.getCalendar(self.calendarId);
+    if (res.status === "success" && res.data) (0, import_mobx_state_tree.applySnapshot)(self, { ...res.data, calendarId: self.calendarId });
+    return res;
+  },
+  async remove() {
+    const api = (0, import_mobx_state_tree.getEnv)(self).api;
+    return api.removeCalendar(self.calendarId);
+  }
+}));
+var Calendar_default = CalendarModel;
+
+// src/models/appointment/Event.ts
+var import_mobx_state_tree2 = require("mobx-state-tree");
+var EventModel = import_mobx_state_tree2.types.model("Event", {
+  id: import_mobx_state_tree2.types.maybeNull(import_mobx_state_tree2.types.number),
+  eventId: import_mobx_state_tree2.types.identifier,
+  calendarId: import_mobx_state_tree2.types.string,
+  participantId: import_mobx_state_tree2.types.maybeNull(import_mobx_state_tree2.types.string),
+  title: import_mobx_state_tree2.types.maybeNull(import_mobx_state_tree2.types.string),
+  description: import_mobx_state_tree2.types.maybeNull(import_mobx_state_tree2.types.string),
+  isRecurring: import_mobx_state_tree2.types.optional(import_mobx_state_tree2.types.boolean, false),
+  recurringFrequency: import_mobx_state_tree2.types.optional(import_mobx_state_tree2.types.number, RecurringFrequency.None),
+  startDate: import_mobx_state_tree2.types.string,
+  endDate: import_mobx_state_tree2.types.string,
+  startHour: import_mobx_state_tree2.types.optional(import_mobx_state_tree2.types.number, 0),
+  startMinute: import_mobx_state_tree2.types.optional(import_mobx_state_tree2.types.number, 0),
+  endHour: import_mobx_state_tree2.types.optional(import_mobx_state_tree2.types.number, 0),
+  endMinute: import_mobx_state_tree2.types.optional(import_mobx_state_tree2.types.number, 0),
+  visitorName: import_mobx_state_tree2.types.maybeNull(import_mobx_state_tree2.types.string),
+  visitorEmail: import_mobx_state_tree2.types.maybeNull(import_mobx_state_tree2.types.string),
+  visitorPhone: import_mobx_state_tree2.types.maybeNull(import_mobx_state_tree2.types.string),
+  createdOn: import_mobx_state_tree2.types.maybeNull(import_mobx_state_tree2.types.string),
+  modifiedOn: import_mobx_state_tree2.types.maybeNull(import_mobx_state_tree2.types.string),
+  externalEventId: import_mobx_state_tree2.types.maybeNull(import_mobx_state_tree2.types.string),
+  attendeeStatus: import_mobx_state_tree2.types.optional(import_mobx_state_tree2.types.number, AttendeeStatus.Tentative),
+  rescheduleLink: import_mobx_state_tree2.types.maybeNull(import_mobx_state_tree2.types.string),
+  cancelLink: import_mobx_state_tree2.types.maybeNull(import_mobx_state_tree2.types.string),
+  timeZone: import_mobx_state_tree2.types.maybeNull(import_mobx_state_tree2.types.string),
+  offset: import_mobx_state_tree2.types.optional(import_mobx_state_tree2.types.number, 0)
+}).actions((self) => ({
+  async get(params) {
+    const api = (0, import_mobx_state_tree2.getEnv)(self).api;
+    const res = await api.getEvent(params);
+    if (res.status === "success" && res.data) (0, import_mobx_state_tree2.applySnapshot)(self, { ...res.data, eventId: self.eventId });
+    return res;
+  },
+  async create(offsetMinutes) {
+    const api = (0, import_mobx_state_tree2.getEnv)(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) (0, import_mobx_state_tree2.applySnapshot)(self, { ...res.data, eventId: self.eventId });
+    return res;
+  },
+  async cancel() {
+    const api = (0, import_mobx_state_tree2.getEnv)(self).api;
+    return api.cancelEvent(self.eventId);
+  },
+  async getCancellable() {
+    const api = (0, import_mobx_state_tree2.getEnv)(self).api;
+    return api.getCancellable(self.eventId);
+  },
+  async getAvailability(params) {
+    const api = (0, import_mobx_state_tree2.getEnv)(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 = (0, import_mobx_state_tree2.getEnv)(self).api;
+    return api.setEventReminder(self.eventId);
+  }
+}));
+var Event_default = EventModel;
+
+// src/models/appointment/Availability.ts
+var import_mobx_state_tree3 = require("mobx-state-tree");
+var AvailabilityModel = import_mobx_state_tree3.types.model("Availability", {
+  id: import_mobx_state_tree3.types.maybeNull(import_mobx_state_tree3.types.number),
+  availabilityId: import_mobx_state_tree3.types.string,
+  calendarId: import_mobx_state_tree3.types.string,
+  participantId: import_mobx_state_tree3.types.string,
+  createdOn: import_mobx_state_tree3.types.maybeNull(import_mobx_state_tree3.types.string),
+  modifiedOn: import_mobx_state_tree3.types.maybeNull(import_mobx_state_tree3.types.string)
+});
+var Availability_default = AvailabilityModel;
+
+// src/models/appointment/AvailabilityDetail.ts
+var import_mobx_state_tree4 = require("mobx-state-tree");
+var AvailabilityDetailModel = import_mobx_state_tree4.types.model("AvailabilityDetail", {
+  id: import_mobx_state_tree4.types.maybeNull(import_mobx_state_tree4.types.number),
+  availabilityId: import_mobx_state_tree4.types.string,
+  sunday: import_mobx_state_tree4.types.optional(import_mobx_state_tree4.types.boolean, false),
+  monday: import_mobx_state_tree4.types.optional(import_mobx_state_tree4.types.boolean, false),
+  tuesday: import_mobx_state_tree4.types.optional(import_mobx_state_tree4.types.boolean, false),
+  wednesday: import_mobx_state_tree4.types.optional(import_mobx_state_tree4.types.boolean, false),
+  thursday: import_mobx_state_tree4.types.optional(import_mobx_state_tree4.types.boolean, false),
+  friday: import_mobx_state_tree4.types.optional(import_mobx_state_tree4.types.boolean, false),
+  saturday: import_mobx_state_tree4.types.optional(import_mobx_state_tree4.types.boolean, false),
+  startHour: import_mobx_state_tree4.types.optional(import_mobx_state_tree4.types.number, 0),
+  startMinute: import_mobx_state_tree4.types.optional(import_mobx_state_tree4.types.number, 0),
+  endHour: import_mobx_state_tree4.types.optional(import_mobx_state_tree4.types.number, 0),
+  endMinute: import_mobx_state_tree4.types.optional(import_mobx_state_tree4.types.number, 0),
+  createdOn: import_mobx_state_tree4.types.maybeNull(import_mobx_state_tree4.types.string),
+  modifiedOn: import_mobx_state_tree4.types.maybeNull(import_mobx_state_tree4.types.string)
+});
+var AvailabilityDetail_default = AvailabilityDetailModel;
+
+// src/models/appointment/CalendarParticipant.ts
+var import_mobx_state_tree5 = require("mobx-state-tree");
+var CalendarParticipantModel = import_mobx_state_tree5.types.model("CalendarParticipant", {
+  id: import_mobx_state_tree5.types.maybeNull(import_mobx_state_tree5.types.number),
+  calendarParticipantId: import_mobx_state_tree5.types.optional(import_mobx_state_tree5.types.string, ""),
+  participantId: import_mobx_state_tree5.types.string,
+  calendarId: import_mobx_state_tree5.types.string,
+  createdOn: import_mobx_state_tree5.types.maybeNull(import_mobx_state_tree5.types.string),
+  modifiedOn: import_mobx_state_tree5.types.maybeNull(import_mobx_state_tree5.types.string)
+});
+var CalendarParticipant_default = CalendarParticipantModel;
+
+// src/models/appointment/Participant.ts
+var import_mobx_state_tree6 = require("mobx-state-tree");
+var ParticipantModel = import_mobx_state_tree6.types.model("Participant", {
+  id: import_mobx_state_tree6.types.maybeNull(import_mobx_state_tree6.types.number),
+  participantId: import_mobx_state_tree6.types.identifier,
+  companyKey: import_mobx_state_tree6.types.maybeNull(import_mobx_state_tree6.types.string),
+  alias: import_mobx_state_tree6.types.optional(import_mobx_state_tree6.types.string, ""),
+  email: import_mobx_state_tree6.types.optional(import_mobx_state_tree6.types.string, ""),
+  isApproved: import_mobx_state_tree6.types.optional(import_mobx_state_tree6.types.boolean, false),
+  isAvailable: import_mobx_state_tree6.types.optional(import_mobx_state_tree6.types.boolean, false),
+  provider: import_mobx_state_tree6.types.optional(import_mobx_state_tree6.types.number, 0),
+  createdOn: import_mobx_state_tree6.types.maybeNull(import_mobx_state_tree6.types.string),
+  modifiedOn: import_mobx_state_tree6.types.maybeNull(import_mobx_state_tree6.types.string),
+  isDeleted: import_mobx_state_tree6.types.optional(import_mobx_state_tree6.types.boolean, false)
+});
+var Participant_default = ParticipantModel;
+
+// src/models/appointment/OpeningHour.ts
+var import_mobx_state_tree7 = require("mobx-state-tree");
+var OpeningHourModel = import_mobx_state_tree7.types.model("OpeningHour", {
+  id: import_mobx_state_tree7.types.maybeNull(import_mobx_state_tree7.types.number),
+  openingHourId: import_mobx_state_tree7.types.optional(import_mobx_state_tree7.types.string, ""),
+  calendarId: import_mobx_state_tree7.types.string,
+  participantId: import_mobx_state_tree7.types.string,
+  day: import_mobx_state_tree7.types.optional(import_mobx_state_tree7.types.number, 0),
+  startHour: import_mobx_state_tree7.types.optional(import_mobx_state_tree7.types.number, 0),
+  startMinute: import_mobx_state_tree7.types.optional(import_mobx_state_tree7.types.number, 0),
+  endHour: import_mobx_state_tree7.types.optional(import_mobx_state_tree7.types.number, 0),
+  endMinute: import_mobx_state_tree7.types.optional(import_mobx_state_tree7.types.number, 0),
+  off: import_mobx_state_tree7.types.optional(import_mobx_state_tree7.types.boolean, false),
+  createdOn: import_mobx_state_tree7.types.maybeNull(import_mobx_state_tree7.types.string),
+  modifiedOn: import_mobx_state_tree7.types.maybeNull(import_mobx_state_tree7.types.string)
+});
+var OpeningHour_default = OpeningHourModel;
+
+// src/models/appointment/TimeSlot.ts
+var import_mobx_state_tree8 = require("mobx-state-tree");
+var TimeSlotModel = import_mobx_state_tree8.types.model("TimeSlot", {
+  startHour: import_mobx_state_tree8.types.optional(import_mobx_state_tree8.types.number, 0),
+  startMinute: import_mobx_state_tree8.types.optional(import_mobx_state_tree8.types.number, 0),
+  endHour: import_mobx_state_tree8.types.optional(import_mobx_state_tree8.types.number, 0),
+  endMinute: import_mobx_state_tree8.types.optional(import_mobx_state_tree8.types.number, 0),
+  startDate: import_mobx_state_tree8.types.string,
+  endDate: import_mobx_state_tree8.types.string,
+  participantId: import_mobx_state_tree8.types.maybeNull(import_mobx_state_tree8.types.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
+var import_mobx_state_tree9 = require("mobx-state-tree");
+var TimeFrameModel = import_mobx_state_tree9.types.model("TimeFrame", {
+  start: import_mobx_state_tree9.types.string,
+  end: import_mobx_state_tree9.types.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
+var import_mobx_state_tree10 = require("mobx-state-tree");
+var SettingModel = import_mobx_state_tree10.types.model("Setting", {
+  id: import_mobx_state_tree10.types.maybeNull(import_mobx_state_tree10.types.number),
+  settingsId: import_mobx_state_tree10.types.optional(import_mobx_state_tree10.types.string, ""),
+  calendarId: import_mobx_state_tree10.types.string,
+  logo: import_mobx_state_tree10.types.maybeNull(import_mobx_state_tree10.types.string),
+  theme: import_mobx_state_tree10.types.maybeNull(import_mobx_state_tree10.types.string),
+  schedulingButtonText: import_mobx_state_tree10.types.maybeNull(import_mobx_state_tree10.types.string),
+  scheduledMessage: import_mobx_state_tree10.types.maybeNull(import_mobx_state_tree10.types.string)
+});
+var Setting_default = SettingModel;
+
+// src/models/appointment/index.ts
+var import_mobx_state_tree11 = require("mobx-state-tree");
+var RootStore = import_mobx_state_tree11.types.model("RootStore", {
+  calendars: import_mobx_state_tree11.types.optional(import_mobx_state_tree11.types.map(Calendar_default), {}),
+  events: import_mobx_state_tree11.types.optional(import_mobx_state_tree11.types.map(Event_default), {})
+}).actions((self) => ({
+  getApi() {
+    return (0, import_mobx_state_tree11.getEnv)(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;
+  }
+}));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AppointmentClient,
+  AssignmentMethod,
+  AttendeeStatus,
+  AvailabilityDetailModel,
+  AvailabilityModel,
+  CalendarModel,
+  CalendarParticipantModel,
+  DayOfWeek,
+  EventModel,
+  OpeningHourModel,
+  ParticipantModel,
+  RecurringFrequency,
+  RootStore,
+  SettingModel,
+  TimeFrameModel,
+  TimeSlotModel,
+  Unit,
+  mapCreateEventInputToEvent
+});