@royalschedule/maps 3.3.17 → 4.0.1

package/dist/core/types/divisions.d.ts

@@ -0,0 +1,24 @@
+import { DateType } from "../../common/types.js";
+import { Vertex } from "./common/index.js";
+import { DivisionSettings } from "./division-settings.js";
+import { Meta } from "./common/meta.js";
+
+//#region src/core/types/divisions.d.ts
+
+type StepGuideProgress = {
+  checked: string[];
+  completed: boolean;
+  updatedAt?: DateType;
+};
+type Division = Vertex & {
+  settings?: DivisionSettings;
+  stepGuideProgress?: StepGuideProgress;
+  displayName?: string;
+  start?: DateType;
+  end?: DateType;
+  editedAt?: DateType;
+  meta?: Meta;
+};
+//#endregion
+export { Division };
+//# sourceMappingURL=divisions.d.ts.map

package/dist/core/types/events.d.ts

@@ -0,0 +1,54 @@
+import { DateType } from "../../common/types.js";
+import { AvailableLocation, GroupReference, PersonReference, Vertex } from "./common/index.js";
+import { BreakLength } from "./common/break-lengths.js";
+import { AllowedInterval } from "./common/intervals.js";
+import { Day } from "./common/days.js";
+import { Tag } from "./common/tag.js";
+import { Group } from "./groups.js";
+import { Person } from "./persons.js";
+import { Teacher } from "./teachers.js";
+import { Location } from "./locations.js";
+import { LockedTime } from "./locked-times.js";
+import { OverlapGroup } from "./overlap-groups.js";
+import { Period } from "./periods.js";
+import { Exception } from "./exceptions.js";
+import { Course } from "./courses.js";
+import { Division } from "./divisions.js";
+
+//#region src/core/types/events.d.ts
+type Event = Vertex & {
+  belongsTo?: Division;
+  course?: Course;
+  period?: Period | null;
+  groups?: GroupReference<Group, Person>[] | null;
+  teachers?: PersonReference<Teacher>[] | null;
+  participants?: PersonReference<Person>[] | null;
+  locations?: AvailableLocation<Location>[] | null;
+  inLocations?: (Location | null)[];
+  exceptions?: Exception[];
+  density?: number;
+  weight?: number;
+  parked?: boolean;
+  color?: string;
+  fixedStart?: boolean;
+  start?: DateType;
+  end?: DateType;
+  minBreakLength?: BreakLength;
+  weeks?: number[];
+  type?: string;
+  displayName?: string;
+  visible?: boolean;
+  duration?: number;
+  preferredDuration?: number;
+  durationVariance?: number;
+  lockedTimes?: LockedTime[] | null;
+  intervals?: AllowedInterval[];
+  centerOfAttraction?: string | null;
+  days?: Day[] | null;
+  overlapGroup?: OverlapGroup | null;
+  overlapSpecies?: OverlapGroup | null;
+  tags?: Tag[];
+};
+//#endregion
+export { Event };
+//# sourceMappingURL=events.d.ts.map

package/dist/core/{v2/types → types}/exceptions.d.ts

@@ -1,4 +1,5 @@
-import { Coalesced } from "./common/coalesced.js";
+import { DateType } from "../../common/types.js";
+import { Coalesced, Vertex } from "./common/index.js";
 import { Group } from "./groups.js";
 import { Person } from "./persons.js";
 import { Teacher } from "./teachers.js";
@@ -6,39 +7,29 @@ import { Location } from "./locations.js";
 import { Event } from "./events.js";
 import { Course } from "./courses.js";
 import { Division } from "./divisions.js";
-import { Edge } from "../../types/index.js";
-import { Types } from "mongoose";
 
-//#region src/core/v2/types/exceptions.d.ts
+//#region src/core/types/exceptions.d.ts
 declare const exceptionStatus: readonly ["pending", "failed", "completed", "rejected", "approved"];
 type ExceptionStatus = typeof exceptionStatus[number];
-interface ExceptionBare {
-  belongsTo?: Edge<Division>;
+type _Exception = Coalesced<Group, 'groups'> | Coalesced<Course, 'courses'> | Coalesced<Teacher, 'teachers'> | Coalesced<Location, 'locations'> | Coalesced<Person, 'persons'>;
+type Exception = Vertex & {
+  belongsTo?: Division;
   reason?: string;
   description?: string;
   sources?: Coalesced<Event | Course | Group | Teacher | Location | Person>[];
-  exceptions?: Edge<Exception[]>;
-  parentExceptions?: Edge<Exception[]>;
-  start?: Date;
-  end?: Date;
+  exceptions?: Exception[];
+  parentExceptions?: Exception[];
+  start?: DateType;
+  end?: DateType;
   type?: 'absence' | 'calendar';
   action?: 'cancel' | 'remove' | 'reschedule' | 'add' | 'substitute';
   handleStatus?: ExceptionStatus;
-  exception?: {
-    to?: Edge<Group | Course | Teacher | Location | Person>;
-    toModel?: 'groups' | 'courses' | 'teachers' | 'locations' | 'persons';
+  exception?: _Exception & {
     include?: boolean;
-    start?: Date;
-    end?: Date;
+    start?: DateType;
+    end?: DateType;
   };
-  lastModifiedBy?: unknown;
-  createdAt?: string;
-  updatedAt?: string;
-}
-interface Exception extends ExceptionBare {
-  _id?: Types.ObjectId;
-  id?: string;
-}
+};
 //#endregion
 export { Exception };
 //# sourceMappingURL=exceptions.d.ts.map

package/dist/core/types/groups.d.ts

@@ -0,0 +1,41 @@
+import { Vertex } from "./common/index.js";
+import { BreakLength } from "./common/break-lengths.js";
+import { AllowedInterval } from "./common/intervals.js";
+import { Day } from "./common/days.js";
+import { RootInterval } from "./root-intervals.js";
+import { MaximumScheduleSpan } from "./common/maximum-schedule-span.js";
+import { Tag } from "./common/tag.js";
+import { Person } from "./persons.js";
+import { LockedTime } from "./locked-times.js";
+import { Exception } from "./exceptions.js";
+import { Division } from "./divisions.js";
+
+//#region src/core/types/groups.d.ts
+type Group = Vertex & {
+  belongsTo?: Division;
+  displayName?: string;
+  minBreakLength?: BreakLength;
+  maximumScheduleSpan?: MaximumScheduleSpan;
+  forbidOverlappingEvents?: boolean;
+  disableDayLengthPunishment?: boolean;
+  weight?: number;
+  rank?: number;
+  species?: 'class';
+  exceptions?: Exception[];
+  parentGroups?: Group[];
+  subGroups?: Group[];
+  lockedTimes?: LockedTime[];
+  lunch?: LockedTime[];
+  members?: Person[];
+  intervals?: AllowedInterval[];
+  rootInterval?: RootInterval;
+  days?: Day[];
+  tags?: Tag[];
+  /** @deprecated replaced by maximumScheduleSpan */
+  maxNumWorkingHours?: number | boolean;
+  /** @deprecated replaced by maximumScheduleSpan */
+  maxNumDailyWorkingHours?: number | number[] | boolean;
+};
+//#endregion
+export { Group };
+//# sourceMappingURL=groups.d.ts.map

package/dist/core/types/index.d.ts

@@ -1,19 +1,121 @@
-import { Types as Types$1 } from "../v2/types/index.js";
-import { Types } from "mongoose";
+import { InternalIdKey } from "./common/index.js";
+import { Mixed, MixedWithoutInternalId, Serialized } from "../vertex-mapping.js";
+import { BreakLength } from "./common/break-lengths.js";
+import { AllowedInterval } from "./common/intervals.js";
+import { Day } from "./common/days.js";
+import { RootInterval } from "./root-intervals.js";
+import { Group } from "./groups.js";
+import { Person } from "./persons.js";
+import { Teacher } from "./teachers.js";
+import { Location } from "./locations.js";
+import { LockedTime } from "./locked-times.js";
+import { OverlapGroup } from "./overlap-groups.js";
+import { Period } from "./periods.js";
+import { Event } from "./events.js";
+import { Exception } from "./exceptions.js";
+import { Syllabus } from "./syllabus.js";
+import { Course } from "./courses.js";
+import { DivisionSettings } from "./division-settings.js";
+import { Meta } from "./common/meta.js";
+import { Division } from "./divisions.js";
+import { Area } from "./areas.js";
+import { MixedSchedule, MixedScheduleWithoutInternalId, Schedule, SerializedSchedule, SerializedScheduleWithoutInternalId } from "./schedules.js";
 
 //#region src/core/types/index.d.ts
-
-type ID = string;
-type Vertex = {
-  _id?: Types.ObjectId;
-  id?: ID;
-};
-type Edge<T extends Vertex | Vertex[]> = T extends Vertex[] ? T | Types.ObjectId[] | ID[] : T | Types.ObjectId | ID;
-type NullableEdge<T extends Vertex | Vertex[]> = T extends Vertex[] ? (null | T[number])[] | (null | Types.ObjectId)[] | (null | ID)[] : null | T | Types.ObjectId | ID;
-type ExtractEdge<T> = T extends Vertex[] ? Exclude<T, Types.ObjectId[] | ID[]> : (T extends Vertex ? Exclude<T, Types.ObjectId | ID> : never);
-type ArrayType<T> = T extends object[] ? T[0] : never;
-type Deserialized<ObjectType> = { [Key in keyof ObjectType]: (ExtractEdge<ObjectType[Key]> extends never ? (ArrayType<ObjectType[Key]> extends never ? ObjectType[Key] : (ArrayType<ObjectType[Key]> extends object ? Deserialized<ArrayType<ObjectType[Key]>>[] : ObjectType[Key])) : Deserialized<ExtractEdge<ObjectType[Key]>>) };
-type Serialized<ObjectType> = { [Key in keyof ObjectType]: (Edge<Vertex> extends ObjectType[Key] ? Extract<ObjectType[Key], string> : (Edge<Vertex[]> extends ObjectType[Key] ? Extract<ObjectType[Key], string[]> : (ObjectType[Key] extends Exclude<{}, Types.ObjectId | Types.ObjectId[]> ? Serialized<ObjectType[Key]> : ObjectType[Key]))) };
+declare namespace Types {
+  type area = Area;
+  type event = Event;
+  type exception = Exception;
+  type course = Course;
+  type location = Location;
+  type group = Group;
+  type lockedTime = LockedTime;
+  type division = Division;
+  type divisionSettings = DivisionSettings;
+  type overlapGroup = OverlapGroup;
+  type period = Period;
+  type person = Person;
+  type rootInterval = RootInterval;
+  type teacher = Teacher;
+  type syllabus = Syllabus;
+  type schedule = Schedule;
+  type breakLength = BreakLength;
+  type day = Day;
+  type interval = AllowedInterval;
+  type meta = Meta;
+  namespace serialized {
+    type area = Serialized<Area>;
+    type event = Serialized<Event>;
+    type exception = Serialized<Exception>;
+    type course = Serialized<Course>;
+    type location = Serialized<Location>;
+    type group = Serialized<Group>;
+    type lockedTime = Serialized<LockedTime>;
+    type division = Serialized<Division>;
+    type divisionSettings = Serialized<DivisionSettings>;
+    type overlapGroup = Serialized<OverlapGroup>;
+    type period = Serialized<Period>;
+    type person = Serialized<Person>;
+    type rootInterval = Serialized<RootInterval>;
+    type teacher = Serialized<Teacher>;
+    type syllabus = Serialized<Syllabus>;
+    type schedule = SerializedSchedule;
+  }
+  namespace mixed {
+    type area = Mixed<Area>;
+    type event = Mixed<Event>;
+    type exception = Mixed<Exception>;
+    type course = Mixed<Course>;
+    type location = Mixed<Location>;
+    type group = Mixed<Group>;
+    type lockedTime = Mixed<LockedTime>;
+    type division = Mixed<Division>;
+    type divisionSettings = Mixed<DivisionSettings>;
+    type overlapGroup = Mixed<OverlapGroup>;
+    type period = Mixed<Period>;
+    type person = Mixed<Person>;
+    type rootInterval = Mixed<RootInterval>;
+    type teacher = Mixed<Teacher>;
+    type syllabus = Mixed<Syllabus>;
+    type schedule = MixedSchedule;
+  }
+  namespace mixedWithoutInternalId {
+    type area = MixedWithoutInternalId<Area>;
+    type event = MixedWithoutInternalId<Event>;
+    type exception = MixedWithoutInternalId<Exception>;
+    type course = MixedWithoutInternalId<Course>;
+    type location = MixedWithoutInternalId<Location>;
+    type group = MixedWithoutInternalId<Group>;
+    type lockedTime = MixedWithoutInternalId<LockedTime>;
+    type division = MixedWithoutInternalId<Division>;
+    type divisionSettings = MixedWithoutInternalId<DivisionSettings>;
+    type overlapGroup = MixedWithoutInternalId<OverlapGroup>;
+    type period = MixedWithoutInternalId<Period>;
+    type person = MixedWithoutInternalId<Person>;
+    type rootInterval = MixedWithoutInternalId<RootInterval>;
+    type teacher = MixedWithoutInternalId<Teacher>;
+    type syllabus = MixedWithoutInternalId<Syllabus>;
+    type schedule = MixedScheduleWithoutInternalId;
+  }
+  namespace serializedWithoutInternalId {
+    type area = Omit<Serialized<Area>, InternalIdKey>;
+    type event = Omit<Serialized<Event>, InternalIdKey>;
+    type exception = Omit<Serialized<Exception>, InternalIdKey>;
+    type course = Omit<Serialized<Course>, InternalIdKey>;
+    type location = Omit<Serialized<Location>, InternalIdKey>;
+    type group = Omit<Serialized<Group>, InternalIdKey>;
+    type lockedTime = Omit<Serialized<LockedTime>, InternalIdKey>;
+    type division = Omit<Serialized<Division>, InternalIdKey>;
+    type divisionSettings = Omit<Serialized<DivisionSettings>, InternalIdKey>;
+    type overlapGroup = Omit<Serialized<OverlapGroup>, InternalIdKey>;
+    type period = Omit<Serialized<Period>, InternalIdKey>;
+    type person = Omit<Serialized<Person>, InternalIdKey>;
+    type rootInterval = Omit<Serialized<RootInterval>, InternalIdKey>;
+    type teacher = Omit<Serialized<Teacher>, InternalIdKey>;
+    type syllabus = Omit<Serialized<Syllabus>, InternalIdKey>;
+    type schedule = SerializedScheduleWithoutInternalId;
+  }
+}
 //#endregion
-export { Deserialized, Edge, NullableEdge, Serialized, Vertex };
+export { Types };
 //# sourceMappingURL=index.d.ts.map

package/dist/core/types/locations.d.ts

@@ -0,0 +1,27 @@
+import { Vertex } from "./common/index.js";
+import { AllowedInterval } from "./common/intervals.js";
+import { Day } from "./common/days.js";
+import { Tag } from "./common/tag.js";
+import { LockedTime } from "./locked-times.js";
+import { Exception } from "./exceptions.js";
+import { Division } from "./divisions.js";
+
+//#region src/core/types/locations.d.ts
+type Location = Vertex & {
+  belongsTo?: Division;
+  rank?: number;
+  maximumCapacity?: number;
+  displayName?: string;
+  text?: string;
+  exceptions?: Exception[];
+  lockedTimes?: LockedTime[];
+  lunch?: LockedTime[];
+  intervals?: AllowedInterval[];
+  days?: Day[];
+  area?: string;
+  minBreakLength?: number;
+  tags?: Tag[];
+};
+//#endregion
+export { Location };
+//# sourceMappingURL=locations.d.ts.map

package/dist/core/types/locked-times.d.ts

@@ -0,0 +1,33 @@
+import { DateType } from "../../common/types.js";
+import { Coalesced, Vertex } from "./common/index.js";
+import { AllowedInterval } from "./common/intervals.js";
+import { Day } from "./common/days.js";
+import { Tag } from "./common/tag.js";
+import { Group } from "./groups.js";
+import { Teacher } from "./teachers.js";
+import { Location } from "./locations.js";
+import { Event } from "./events.js";
+import { Course } from "./courses.js";
+import { Division } from "./divisions.js";
+
+//#region src/core/types/locked-times.d.ts
+type Type = /* 'ANY' | */'LUNCH' | 'COMPLEMENTARY_TIME';
+type LockedTime = Vertex & {
+  belongsTo?: Division;
+  displayName?: string;
+  color?: string;
+  type?: Type;
+  start?: DateType;
+  end?: DateType;
+  visible?: boolean;
+  parked?: boolean;
+  duration?: number;
+  durationVariance?: number;
+  coalesced?: (Coalesced<Group, 'groups'> | Coalesced<Teacher, 'teachers'> | Coalesced<Course, 'courses'> | Coalesced<Event, 'events'> | Coalesced<Event, 'courseevents'> | Coalesced<Location, 'locations'>)[];
+  intervals?: AllowedInterval[];
+  days?: Day[];
+  tags?: Tag[];
+};
+//#endregion
+export { LockedTime };
+//# sourceMappingURL=locked-times.d.ts.map

package/dist/core/types/overlap-groups.d.ts

@@ -0,0 +1,14 @@
+import { Coalesced, Species, Vertex } from "./common/index.js";
+import { Event } from "./events.js";
+import { Course } from "./courses.js";
+import { Division } from "./divisions.js";
+
+//#region src/core/types/overlap-groups.d.ts
+type OverlapGroup = Vertex & {
+  belongsTo?: Division;
+  coalesced?: Coalesced<Course, 'courses'>[];
+  species?: Species<Event, 'events' | 'courseevents'>[];
+};
+//#endregion
+export { OverlapGroup };
+//# sourceMappingURL=overlap-groups.d.ts.map

package/dist/core/types/periods.d.ts

@@ -0,0 +1,14 @@
+import { Vertex } from "./common/index.js";
+import { Interval } from "./common/intervals.js";
+import { Division } from "./divisions.js";
+
+//#region src/core/types/periods.d.ts
+type Period = Vertex & {
+  belongsTo?: Division;
+  displayIndex?: number;
+  displayName?: string;
+  ranges: Partial<Interval>[];
+};
+//#endregion
+export { Period };
+//# sourceMappingURL=periods.d.ts.map

package/dist/core/{v2/types → types}/persons.d.ts

@@ -1,18 +1,18 @@
+import { DateType } from "../../common/types.js";
+import { Vertex } from "./common/index.js";
+import { Tag } from "./common/tag.js";
 import { Group } from "./groups.js";
 import { LockedTime } from "./locked-times.js";
 import { Exception } from "./exceptions.js";
 import { Division } from "./divisions.js";
-import { Edge } from "../../types/index.js";
-import { Types } from "mongoose";
 
-//#region src/core/v2/types/persons.d.ts
-interface PersonBare {
-  belongsTo?: Edge<Division>;
-  ids?: string;
+//#region src/core/types/persons.d.ts
+type Person = Vertex & {
+  belongsTo?: Division;
   displayName?: string;
   lastName?: string;
   firstName?: string;
-  birthDate?: Date;
+  birthDate?: DateType;
   sex?: 'Man' | 'Woman';
   type?: 'Student' | 'Teacher' | 'Other';
   SSN?: {
@@ -27,21 +27,12 @@ interface PersonBare {
     value: string;
     type: 'private' | 'organization';
   }[];
-  tags?: {
-    type?: string;
-    value: string;
-  }[];
-  exceptions?: Edge<Exception[]>;
-  lockedTimes?: Edge<LockedTime[]>;
-  lunch?: Edge<LockedTime[]>;
-  group?: Edge<Group>;
-  createdAt?: string;
-  updatedAt?: string;
-}
-interface Person extends PersonBare {
-  _id?: Types.ObjectId;
-  id?: string;
-}
+  tags?: Tag[];
+  exceptions?: Exception[];
+  lockedTimes?: LockedTime[];
+  lunch?: LockedTime[];
+  group?: Group;
+};
 //#endregion
 export { Person };
 //# sourceMappingURL=persons.d.ts.map

package/dist/core/types/root-intervals.d.ts

@@ -0,0 +1,13 @@
+import { Vertex } from "./common/index.js";
+import { Interval } from "./common/intervals.js";
+import { Division } from "./divisions.js";
+
+//#region src/core/types/root-intervals.d.ts
+type RootInterval = Vertex & {
+  belongsTo?: Division;
+  displayName?: string;
+  intervals: Interval[];
+};
+//#endregion
+export { RootInterval };
+//# sourceMappingURL=root-intervals.d.ts.map

package/dist/core/types/schedules.d.ts

@@ -0,0 +1,44 @@
+import { InternalIdKey, Vertex } from "./common/index.js";
+import { Mixed, MixedWithoutInternalId, Serialized } from "../vertex-mapping.js";
+import { RootInterval } from "./root-intervals.js";
+import { Group } from "./groups.js";
+import { Person } from "./persons.js";
+import { Teacher } from "./teachers.js";
+import { Location } from "./locations.js";
+import { LockedTime } from "./locked-times.js";
+import { OverlapGroup } from "./overlap-groups.js";
+import { Period } from "./periods.js";
+import { Event } from "./events.js";
+import { Exception } from "./exceptions.js";
+import { Syllabus } from "./syllabus.js";
+import { Course } from "./courses.js";
+import { DivisionSettings } from "./division-settings.js";
+import { Division } from "./divisions.js";
+import { Area } from "./areas.js";
+
+//#region src/core/types/schedules.d.ts
+type ScheduleShape = {
+  divisions: Division;
+  exceptions: Exception[];
+  settings: DivisionSettings;
+  groups: Group[];
+  teachers: Teacher[];
+  locations: Location[];
+  courses: Course[];
+  events: Event[];
+  overlapGroups: OverlapGroup[];
+  periods: Period[];
+  persons: Person[];
+  lockedTimes: LockedTime[];
+  rootIntervals: RootInterval[];
+  areas: Area[];
+  syllabuses: Syllabus[];
+};
+type Schedule = ScheduleShape;
+type SerializedSchedule = { [K in keyof ScheduleShape]: ScheduleShape[K] extends Array<infer U extends Vertex> ? Serialized<U>[] : ScheduleShape[K] extends Vertex ? Serialized<ScheduleShape[K]> : never };
+type MixedSchedule = { [K in keyof ScheduleShape]: ScheduleShape[K] extends Array<infer U extends Vertex> ? Mixed<U>[] : ScheduleShape[K] extends Vertex ? Mixed<ScheduleShape[K]> : never };
+type MixedScheduleWithoutInternalId = { [K in keyof ScheduleShape]: ScheduleShape[K] extends Array<infer U extends Vertex> ? MixedWithoutInternalId<U>[] : ScheduleShape[K] extends Vertex ? MixedWithoutInternalId<ScheduleShape[K]> : never };
+type SerializedScheduleWithoutInternalId = { [K in keyof ScheduleShape]: ScheduleShape[K] extends Array<infer U extends Vertex> ? Omit<Serialized<U>, InternalIdKey>[] : ScheduleShape[K] extends Vertex ? Omit<Serialized<ScheduleShape[K]>, InternalIdKey> : never };
+//#endregion
+export { MixedSchedule, MixedScheduleWithoutInternalId, Schedule, SerializedSchedule, SerializedScheduleWithoutInternalId };
+//# sourceMappingURL=schedules.d.ts.map

package/dist/core/types/syllabus.d.ts

@@ -0,0 +1,18 @@
+import { Vertex } from "./common/index.js";
+import { Division } from "./divisions.js";
+
+//#region src/core/types/syllabus.d.ts
+type Syllabus = Vertex & {
+  belongsTo?: Division;
+  schoolType: string;
+  subjectCode?: string;
+  subjectName: string;
+  subjectDesignation?: string;
+  courseCode?: string;
+  courseName?: string;
+  points?: number;
+  official: boolean;
+};
+//#endregion
+export { Syllabus };
+//# sourceMappingURL=syllabus.d.ts.map

package/dist/core/{v2/types → types}/teachers.d.ts

@@ -1,51 +1,41 @@
-import { BreakLength } from "./break-lengths.js";
-import { Interval } from "./intervals.js";
-import { Day } from "./days.js";
+import { Vertex } from "./common/index.js";
+import { BreakLength } from "./common/break-lengths.js";
+import { AllowedInterval } from "./common/intervals.js";
+import { Day } from "./common/days.js";
 import { RootInterval } from "./root-intervals.js";
 import { MaximumScheduleSpan } from "./common/maximum-schedule-span.js";
+import { Tag } from "./common/tag.js";
 import { Person } from "./persons.js";
 import { PlannedScheduledDuration } from "./common/planned-schedule-duration.js";
 import { LockedTime } from "./locked-times.js";
 import { Exception } from "./exceptions.js";
 import { Division } from "./divisions.js";
-import { Edge } from "../../types/index.js";
-import { Types } from "mongoose";
 
-//#region src/core/v2/types/teachers.d.ts
-interface TeacherBare {
-  belongsTo?: Edge<Division>;
-  ids?: string;
+//#region src/core/types/teachers.d.ts
+type Teacher = Vertex & {
+  belongsTo?: Division;
   displayName?: string;
   minBreakLength?: BreakLength;
-  maxNumWorkingHours?: number | boolean;
-  maxNumDailyWorkingHours?: number | number[] | boolean;
   plannedScheduledDuration?: PlannedScheduledDuration;
   maximumScheduleSpan?: MaximumScheduleSpan;
   forbidOverlappingEvents?: boolean;
   disableDayLengthPunishment?: boolean;
   weight?: number;
-  person?: Edge<Person>;
-  exceptions?: Edge<Exception[]>;
-  lockedTimes?: Edge<LockedTime[]>;
-  lunch?: Edge<LockedTime[]>;
-  complementaryTimes?: Edge<LockedTime[]>;
-  intervals?: Interval[];
-  rootInterval?: Edge<RootInterval>;
+  person?: Person;
+  exceptions?: Exception[];
+  lockedTimes?: LockedTime[];
+  lunch?: LockedTime[];
+  intervals?: AllowedInterval[];
+  rootInterval?: RootInterval;
   days?: Day[];
   signature?: string;
   rank?: number;
-  tags?: {
-    type?: string;
-    value: string;
-  }[];
-  createdAt?: string;
-  updatedAt?: string;
-  lastModifiedBy?: unknown;
-}
-interface Teacher extends TeacherBare {
-  _id?: Types.ObjectId;
-  id?: string;
-}
+  tags?: Tag[];
+  /** @deprecated replaced by maximumScheduleSpan */
+  maxNumWorkingHours?: number | boolean;
+  /** @deprecated replaced by maximumScheduleSpan */
+  maxNumDailyWorkingHours?: number | number[] | boolean;
+};
 //#endregion
 export { Teacher };
 //# sourceMappingURL=teachers.d.ts.map

package/dist/core/util.js

@@ -0,0 +1,46 @@
+import moment from "moment";
+import { Types } from "mongoose";
+
+//#region src/core/util.ts
+/**
+* Returns the ID key to use for vertices, which can be either `id`, `_id`, or `ids`.
+*/
+function getIdKey({ idKey }) {
+	return idKey ?? "id";
+}
+/**
+* Returns the ID of a vertex, which can be either `_id`, `id`, or `ids`.
+*/
+function getVertexId(edge, _idKey) {
+	if (typeof edge === "string") return edge;
+	if (edge instanceof Types.ObjectId) return edge.toString();
+	const idKey = typeof _idKey === "string" ? _idKey : getIdKey(_idKey);
+	if (idKey == "_id" && idKey in edge) return edge._id.toString();
+	if (idKey == "id" && idKey in edge) return edge.id;
+	if (idKey == "ids" && edge.ids) return edge.ids;
+	throw new Error(`Unable to get vertex ID "${idKey}" from edge: ${JSON.stringify(edge)}`);
+}
+/**
+* Returns the day index in the range 0-6, where 0 is Monday and 6 is Sunday.
+*/
+function getDayIndex(value) {
+	const day = typeof value === "number" ? value : moment.utc(value).day();
+	return (day + 6) % 7;
+}
+function parseDateInterval(interval, type) {
+	if (!interval.start) throw new Error(`(RS::V3::To::validateInterval) The interval ${type ? `"${type}"` : ""} is missing a start time`);
+	if (!interval.end) throw new Error(`(RS::V3::To::validateInterval) The interval ${type ? `"${type}"` : ""} is missing an end time`);
+	const start = moment.utc(interval.start);
+	const end = moment.utc(interval.end);
+	if (!start.isValid()) throw new Error(`(RS::V3::To::validateInterval) The interval ${type ? `"${type}"` : ""} has an invalid start time`);
+	if (!end.isValid()) throw new Error(`(RS::V3::To::validateInterval) The interval ${type ? `"${type}"` : ""} has an invalid end time`);
+	if (end.isSameOrBefore(start)) throw new Error(`(RS::V3::To::validateInterval) The interval ${type ? `"${type}"` : ""} is invalid: end time is before or equal to start time`);
+	return {
+		start,
+		end
+	};
+}
+
+//#endregion
+export { getDayIndex, getIdKey, getVertexId, parseDateInterval };
+//# sourceMappingURL=util.js.map