new Class(id: string, company: Company);                                    // fetches lazily
new Class(data: LazyClassData | ClassData, company: Company, lazy?: boolean); // from known data

protected fetch(lazy?: boolean): Promise<SimpleResult<ClassData>>;   // GET .../classes?ids={id}&limit=1&lazy=...
save(): Promise<SimpleResult<EventData>>;                            // PATCH .../classes, body [this._data]
static create(company: Company, items: CreateClassData[]): Promise<EventData<string[]>>; // POST .../classes
delete(): Promise<SimpleResult<EventData>>;                          // DELETE .../classes?ids={id} — soft delete
static query(company: Company, data: QueryRequest): Promise<SimpleResult<Class[]>>; // POST .../classes/query

GetSchedulings({ limit = 100, offset = 0, lazy = true }): Promise<SimpleResult<ClassSchedule[]>>;
// ClassSchedule.query filtered by classID

GetListOfBookings({ limit = 100, offset = 0, lazy = true }): Promise<SimpleResult<Booking[]>>;
// Booking.query filtered by classID — every booking across every instance of this template

GetListOfTagAssignments({ limit = 100, offset = 0, lazy = true }): Promise<SimpleResult<TagAssignment[]>>;
// TagAssignment.query filtered by resourceType: "class", resourceID: this.id

AssignTag(tag: Tag): Promise<...>;
// TagAssignment.create({ tagID, resourceID: this.id, resourceType: "class" })

new ClassSchedule(id: string, company: Company);
new ClassSchedule(data: LazyClassScheduleData | ClassScheduleData, company: Company, lazy?: boolean);

protected fetch(lazy?: boolean): Promise<SimpleResult<ClassScheduleData>>; // GET .../schedules?ids={id}&limit=1&lazy=...

// Pass opts.regenerateFuture: true to cancel + regenerate future scheduled instances.
save(opts?: UpdateClassScheduleItem): Promise<SimpleResult<EventData>>;
// PATCH .../schedules?ids={id}, body = { ...currentData, ...opts }

static create(company: Company, items: CreateClassScheduleItem[]): Promise<EventData<string[]>>;
// POST .../schedules — each item generates its own ClassInstance rows

// Soft-deletes the schedule AND cancels all future `scheduled` instances it generated.
delete(): Promise<SimpleResult<EventData>>; // DELETE .../schedules?ids={id}

static query(company: Company, data: QueryRequest): Promise<SimpleResult<ClassSchedule[]>>; // POST .../schedules/query

ListOfDays(): string[];  // recurrenceDays mapped to short labels, e.g. ["Sun", "Wed"]
StartTime(): Date;       // startTime ("HH:MM:SS") parsed onto today's date
EndTime(): Date;         // endTime parsed the same way

new ClassInstance(id: string, company: Company);
new ClassInstance(data: LazyClassInstanceData | ClassInstanceData, company: Company, lazy?: boolean);

protected fetch(lazy?: boolean): Promise<SimpleResult<ClassInstanceData>>; // GET .../instances?ids={id}&limit=1&lazy=...
save(): Promise<SimpleResult<EventData>>;   // PATCH .../instances, body [this._data] — used for edits/cancellations
static create(company: Company, items: CreateClassInstanceData[]): Promise<SimpleResult<EventData>>;
// POST .../instances — prefer going through ClassSchedule so recurrence stays in sync
delete(): Promise<SimpleResult<EventData>>; // DELETE .../instances?ids={id} — soft delete
static query(company: Company, data: QueryRequest): Promise<SimpleResult<ClassInstance[]>>; // POST .../instances/query

new Service(id: string, company: Company);
new Service(data: LazyServiceData | ServiceData, company: Company, lazy?: boolean);

protected fetch(lazy?: boolean): Promise<SimpleResult<ServiceData>>; // GET .../services?ids={id}&limit=1&lazy=...
save(): Promise<SimpleResult<EventData>>;                            // PATCH .../services
static create(company: Company, items: CreateServiceData[]): Promise<EventData<string[]>>; // POST .../services
delete(): Promise<SimpleResult<EventData>>;                          // DELETE .../services?ids={id}
static query(company: Company, data: QueryRequest): Promise<SimpleResult<Service[]>>;       // POST .../services/query

GetListOfTagAssignments({ limit = 100, offset = 0, lazy = true }): Promise<SimpleResult<TagAssignment[]>>;
// TagAssignment.query filtered by resourceType: "service", resourceID: this.id

AssignTag(tag: Tag): Promise<...>;

GetListOfAppointments({ limit = 100, offset = 0, lazy = true }): Promise<SimpleResult<Appointment[]>>;
// Appointment.query filtered by serviceID

new Appointment(id: string, company: Company);
new Appointment(data: LazyAppointmentData | AppointmentData, company: Company, lazy?: boolean);

protected fetch(): Promise<SimpleResult<AppointmentData>>; // GET .../appointments?id={id}
save(): Promise<SimpleResult<EventData>>;                  // PATCH .../appointments?id={id}, body = data (single object, not an array)

// For a priced service, the backend first tries to consume an eligible
// service-scoped or fully generic Credit; with none available, the
// appointment is created as "unpaid" instead of requiring payment up front.
static create(company: Company, items: CreateAppointmentItem[]): Promise<EventData<string[]>>; // POST .../appointments

delete(): Promise<SimpleResult<EventData>>; // DELETE .../appointments?id={id}
static query(company: Company, data: QueryRequest): Promise<SimpleResult<Appointment[]>>; // POST .../appointments/query

/** Sets status = "completed" and checkedInAt = NOW(). Returns 202 if the user has an alert. */
CheckIn(): Promise<SimpleResult<CheckInResponse & { appointmentID?: string }>>;
// POST .../appointments/{id}/check-in

new Booking(id: string, company: Company);
new Booking(data: LazyBookingData | BookingData, company: Company, lazy?: boolean);

protected fetch(): Promise<SimpleResult<BookingData>>; // GET .../bookings?ids={id}
save(): Promise<SimpleResult<EventData>>;               // PATCH .../bookings, body [data]
static create(company: Company, items: CreateBookingData[]): Promise<SimpleResult<EventData>>; // POST .../bookings
delete(): Promise<SimpleResult<EventData>>;              // DELETE .../bookings?ids={id}
static query(company: Company, data: QueryRequest): Promise<SimpleResult<Booking[]>>; // POST .../bookings/query

/** Sets status = "attended" and checkedInAt = NOW(). Returns 202 if the user has an alert. */
CheckIn(): Promise<SimpleResult<CheckInResponse>>;
// POST .../bookings/checkIn, body { bookingIDs: [this.id] }

new TimeSlot(id: string, company: Company);
new TimeSlot(data: LazyTimeSlotData | TimeSlotData, company: Company, lazy?: boolean);

protected fetch(lazy?: boolean): Promise<SimpleResult<TimeSlotData>>;
save(): Promise<SimpleResult<EventData>>;                 // PATCH .../timeSlots
static create(company: Company, items: CreateTimeSlotItem[]): Promise<SimpleResult<EventData>>; // POST .../timeSlots
delete(): Promise<SimpleResult<EventData>>;                // via deleteTimeSlots — DELETE .../timeSlots, body { ids: [this.id] }
static deleteMany(company: Company, ids: string[]): Promise<SimpleResult<EventData>>; // batch delete, same endpoint
static query(company: Company, data: QueryRequest): Promise<SimpleResult<TimeSlot[]>>; // POST .../timeSlots/query

GetTimeSlot({ company, ids?, limit?, offset?, lazy? }: GetTimeSlotRequest): Promise<SimpleResult<TimeSlot[]>>;