@royalschedule/maps 4.0.32 → 4.1.0-beta.0

package/dist/core/interfaces/vertices/groups.d.mts

@@ -0,0 +1,51 @@
+import { VertexFactory } from "./util/vertex.mjs";
+import { EdgeWrapper, Plain, Wrapped } from "./util/edges.mjs";
+import "./util/index.mjs";
+import { Day } from "./properties/days.mjs";
+import { Interval } from "./properties/intervals.mjs";
+import { Tag } from "./properties/tags.mjs";
+import { MaximumScheduleSpan } from "./properties/maximum-schedule-span.mjs";
+import { RootIntervalVertex } from "./root-intervals.mjs";
+import { BelongsTo } from "./properties/belongs-to.mjs";
+import { PersonVertex } from "./persons.mjs";
+import { ExceptionVertex } from "./exceptions.mjs";
+import { LockedTimeVertex } from "./locked-times.mjs";
+
+//#region src/core/interfaces/vertices/groups.d.ts
+type DerivedParentGroupOpts = {
+  implicit?: boolean;
+  /**
+   * If the group is explicitly defined as a parent group.
+   */
+  explicit?: boolean;
+};
+type GroupVertex = VertexFactory<'groups', BelongsTo & {
+  tags?: Tag[];
+  minBreakLength?: number; /** @deprecated replaced by maximumScheduleSpan */
+  maxNumWorkingHours?: number | false; /** @deprecated replaced by maximumScheduleSpan */
+  maxNumDailyWorkingHours?: number | number[] | false;
+  maximumScheduleSpan?: MaximumScheduleSpan;
+  forbidOverlappingEvents?: boolean;
+  disableDayLengthPunishment?: boolean;
+  weight?: number;
+  species?: 'class';
+  /**
+   * @note an empty array is the same as undefined
+   */
+  intervals?: Interval[];
+  days?: Day[];
+  parentGroups?: EdgeWrapper<'array', Plain.Edge<GroupVertex>>;
+  subGroups?: EdgeWrapper<'array', Plain.Edge<GroupVertex>>;
+  lockedTimes?: EdgeWrapper<'array', Plain.Edge<LockedTimeVertex>>;
+  lunch?: EdgeWrapper<'array', Plain.Edge<LockedTimeVertex>>;
+  exceptions?: EdgeWrapper<'array', Plain.Edge<ExceptionVertex>>;
+  members?: EdgeWrapper<'array', Plain.Edge<PersonVertex>>;
+  rootInterval?: EdgeWrapper<'single', Plain.Edge<RootIntervalVertex>>;
+  /**
+   * Source only?
+   */
+  derivedParentGroups?: EdgeWrapper<'array', Wrapped.Edge<'group', GroupVertex, DerivedParentGroupOpts>>;
+}>;
+//#endregion
+export { GroupVertex };
+//# sourceMappingURL=groups.d.mts.map

package/dist/core/interfaces/vertices/index.d.mts

@@ -0,0 +1,231 @@
+import { Collection, Vertex } from "./util/vertex.mjs";
+import { IdKey, InternalIdKey } from "../../types/common/index.mjs";
+import { DeepVertexExport, DeepVertexExportOmitPrivateId, MixedVertexExport, MixedWithOptionalIdVertexExport } from "./util/deep-vertex-export/index.mjs";
+import { SerializedVertexExport } from "./util/serialized-vertex-export.mjs";
+import "./util/index.mjs";
+import { PeriodVertex } from "./periods.mjs";
+import { RootIntervalVertex } from "./root-intervals.mjs";
+import { CalendarException, DivisionSettingsVertex } from "./division-settings.mjs";
+import { GenerationVertex } from "./generations.mjs";
+import { DivisionVertex, StepGuideProgress } from "./divisions.mjs";
+import { PersonVertex } from "./persons.mjs";
+import { LocationVertex } from "./locations.mjs";
+import { LinkedEventsSetVertex } from "./linked-events-sets.mjs";
+import { UserVertex } from "./users.mjs";
+import { ThreadVertex } from "./threads.mjs";
+import { CalendarEventVertex, EventVertex, ScheduleEventVertex } from "./events.mjs";
+import { OverlapGroupVertex } from "./overlap-groups.mjs";
+import { SyllabusVertex } from "./syllabuses.mjs";
+import { CourseVertex } from "./courses.mjs";
+import { CalendarExceptionAction, ExceptionStatus, ExceptionVertex } from "./exceptions.mjs";
+import { GroupVertex } from "./groups.mjs";
+import { LockedTimeType, LockedTimeVertex } from "./locked-times.mjs";
+import { TeacherVertex } from "./teachers.mjs";
+import { ConfigurationFilterVertex, ConfigurationRuleVertex, ConfigurationTemplateVertex, ConfigurationVertex } from "./configurations.mjs";
+import { Infer, VertexQuery, createVertexQuery } from "./vertex-query.mjs";
+
+//#region src/core/interfaces/vertices/index.d.ts
+type Is<C extends Collection> = Pick<Vertex<C>, 'is'>;
+type ScheduleOf<TDivision extends Is<'divisions'>, TSettings extends Is<'settings'>, TException extends Is<'exceptions'>, TGroup extends Is<'groups'>, TTeacher extends Is<'teachers'>, TLocation extends Is<'locations'>, TCourse extends Is<'courses'>, TEvent extends Is<'events'>, TOverlapGroup extends Is<'overlapGroups'>, TPeriod extends Is<'periods'>, TPerson extends Is<'persons'>, TLockedTime extends Is<'lockedTimes'>, TRootInterval extends Is<'rootIntervals'>, TSyllabus extends Is<'syllabuses'>, TConfiguration extends Is<'configurations'>, TLinkedEventsSet extends Is<'linkedEventsSets'>> = {
+  divisions: TDivision;
+  settings: TSettings;
+  exceptions: TException[];
+  groups: TGroup[];
+  teachers: TTeacher[];
+  locations: TLocation[];
+  courses: TCourse[];
+  events: TEvent[];
+  overlapGroups: TOverlapGroup[];
+  periods: TPeriod[];
+  persons: TPerson[];
+  lockedTimes: TLockedTime[];
+  rootIntervals: TRootInterval[];
+  syllabuses: TSyllabus[];
+  configurations: TConfiguration[];
+  linkedEventsSets: TLinkedEventsSet[];
+};
+declare namespace Serialized {
+  type Teacher = SerializedVertexExport<TeacherVertex>;
+  type Exception = SerializedVertexExport<ExceptionVertex>;
+  type Event = SerializedVertexExport<EventVertex>;
+  type ScheduleEvent = SerializedVertexExport<ScheduleEventVertex>;
+  type CalendarEvent = SerializedVertexExport<CalendarEventVertex>;
+  type Course = SerializedVertexExport<CourseVertex>;
+  type Settings = SerializedVertexExport<DivisionSettingsVertex>;
+  type Division = SerializedVertexExport<DivisionVertex>;
+  type Generation = SerializedVertexExport<GenerationVertex>;
+  type Group = SerializedVertexExport<GroupVertex>;
+  type Location = SerializedVertexExport<LocationVertex>;
+  type LockedTime = SerializedVertexExport<LockedTimeVertex>;
+  type OverlapGroup = SerializedVertexExport<OverlapGroupVertex>;
+  type LinkedEventsSet = SerializedVertexExport<LinkedEventsSetVertex>;
+  type Period = SerializedVertexExport<PeriodVertex>;
+  type Person = SerializedVertexExport<PersonVertex>;
+  type RootInterval = SerializedVertexExport<RootIntervalVertex>;
+  type Syllabus = SerializedVertexExport<SyllabusVertex>;
+  type Thread = SerializedVertexExport<ThreadVertex>;
+  type User = SerializedVertexExport<UserVertex>;
+  namespace Configuration {
+    type Base = SerializedVertexExport<ConfigurationVertex>;
+    type Filter = SerializedVertexExport<ConfigurationFilterVertex>;
+    type Template = SerializedVertexExport<ConfigurationTemplateVertex>;
+    type Rule = SerializedVertexExport<ConfigurationRuleVertex>;
+    type Mixed = Filter | Template | Rule;
+  }
+  type Schedule = ScheduleOf<Division, Settings, Exception, Group, Teacher, Location, Course, Event, OverlapGroup, Period, Person, LockedTime, RootInterval, Syllabus, Configuration.Base, LinkedEventsSet>;
+}
+declare namespace Deep {
+  type Teacher = DeepVertexExport<TeacherVertex>;
+  type Exception = DeepVertexExport<ExceptionVertex>;
+  type Event = DeepVertexExport<EventVertex>;
+  type ScheduleEvent = DeepVertexExport<ScheduleEventVertex>;
+  type CalendarEvent = DeepVertexExport<CalendarEventVertex>;
+  type Course = DeepVertexExport<CourseVertex>;
+  type Settings = DeepVertexExport<DivisionSettingsVertex>;
+  type Division = DeepVertexExport<DivisionVertex>;
+  type Generation = DeepVertexExport<GenerationVertex>;
+  type Group = DeepVertexExport<GroupVertex>;
+  type Location = DeepVertexExport<LocationVertex>;
+  type LockedTime = DeepVertexExport<LockedTimeVertex>;
+  type OverlapGroup = DeepVertexExport<OverlapGroupVertex>;
+  type LinkedEventsSet = DeepVertexExport<LinkedEventsSetVertex>;
+  type Period = DeepVertexExport<PeriodVertex>;
+  type Person = DeepVertexExport<PersonVertex>;
+  type RootInterval = DeepVertexExport<RootIntervalVertex>;
+  type Syllabus = DeepVertexExport<SyllabusVertex>;
+  type Thread = DeepVertexExport<ThreadVertex>;
+  type User = DeepVertexExport<UserVertex>;
+  namespace Configuration {
+    type Base = DeepVertexExport<ConfigurationVertex>;
+    type Filter = DeepVertexExport<ConfigurationFilterVertex>;
+    type Template = DeepVertexExport<ConfigurationTemplateVertex>;
+    type Rule = DeepVertexExport<ConfigurationRuleVertex>;
+    type Mixed = Filter | Template | Rule;
+  }
+  type Schedule = ScheduleOf<Division, Settings, Exception, Group, Teacher, Location, Course, Event, OverlapGroup, Period, Person, LockedTime, RootInterval, Syllabus, Configuration.Base, LinkedEventsSet>;
+}
+declare namespace DeepWithoutPrivateId {
+  type Teacher = DeepVertexExportOmitPrivateId<TeacherVertex>;
+  type Exception = DeepVertexExportOmitPrivateId<ExceptionVertex>;
+  type Event = DeepVertexExportOmitPrivateId<EventVertex>;
+  type ScheduleEvent = DeepVertexExportOmitPrivateId<ScheduleEventVertex>;
+  type CalendarEvent = DeepVertexExportOmitPrivateId<CalendarEventVertex>;
+  type Course = DeepVertexExportOmitPrivateId<CourseVertex>;
+  type Settings = DeepVertexExportOmitPrivateId<DivisionSettingsVertex>;
+  type Division = DeepVertexExportOmitPrivateId<DivisionVertex>;
+  type Generation = DeepVertexExportOmitPrivateId<GenerationVertex>;
+  type Group = DeepVertexExportOmitPrivateId<GroupVertex>;
+  type Location = DeepVertexExportOmitPrivateId<LocationVertex>;
+  type LockedTime = DeepVertexExportOmitPrivateId<LockedTimeVertex>;
+  type OverlapGroup = DeepVertexExportOmitPrivateId<OverlapGroupVertex>;
+  type LinkedEventsSet = DeepVertexExportOmitPrivateId<LinkedEventsSetVertex>;
+  type Period = DeepVertexExportOmitPrivateId<PeriodVertex>;
+  type Person = DeepVertexExportOmitPrivateId<PersonVertex>;
+  type RootInterval = DeepVertexExportOmitPrivateId<RootIntervalVertex>;
+  type Syllabus = DeepVertexExportOmitPrivateId<SyllabusVertex>;
+  type Thread = DeepVertexExportOmitPrivateId<ThreadVertex>;
+  type User = DeepVertexExportOmitPrivateId<UserVertex>;
+  namespace Configuration {
+    type Base = DeepVertexExport<ConfigurationVertex>;
+    type Filter = DeepVertexExport<ConfigurationFilterVertex>;
+    type Template = DeepVertexExport<ConfigurationTemplateVertex>;
+    type Rule = DeepVertexExport<ConfigurationRuleVertex>;
+    type Mixed = Filter | Template | Rule;
+  }
+  type Schedule = ScheduleOf<Division, Settings, Exception, Group, Teacher, Location, Course, Event, OverlapGroup, Period, Person, LockedTime, RootInterval, Syllabus, Configuration.Base, LinkedEventsSet>;
+}
+declare namespace Mixed {
+  type Teacher = MixedVertexExport<TeacherVertex>;
+  type Exception = MixedVertexExport<ExceptionVertex>;
+  type Event = MixedVertexExport<EventVertex>;
+  type ScheduleEvent = MixedVertexExport<ScheduleEventVertex>;
+  type CalendarEvent = MixedVertexExport<CalendarEventVertex>;
+  type Course = MixedVertexExport<CourseVertex>;
+  type Settings = MixedVertexExport<DivisionSettingsVertex>;
+  type Division = MixedVertexExport<DivisionVertex>;
+  type Generation = MixedVertexExport<GenerationVertex>;
+  type Group = MixedVertexExport<GroupVertex>;
+  type Location = MixedVertexExport<LocationVertex>;
+  type LockedTime = MixedVertexExport<LockedTimeVertex>;
+  type OverlapGroup = MixedVertexExport<OverlapGroupVertex>;
+  type LinkedEventsSet = MixedVertexExport<LinkedEventsSetVertex>;
+  type Period = MixedVertexExport<PeriodVertex>;
+  type Person = MixedVertexExport<PersonVertex>;
+  type RootInterval = MixedVertexExport<RootIntervalVertex>;
+  type Syllabus = MixedVertexExport<SyllabusVertex>;
+  type Thread = MixedVertexExport<ThreadVertex>;
+  type User = MixedVertexExport<UserVertex>;
+  namespace Configuration {
+    type Base = MixedVertexExport<ConfigurationVertex>;
+    type Filter = MixedVertexExport<ConfigurationFilterVertex>;
+    type Template = MixedVertexExport<ConfigurationTemplateVertex>;
+    type Rule = MixedVertexExport<ConfigurationRuleVertex>;
+    type Mixed = Filter | Template | Rule;
+  }
+  type Schedule = ScheduleOf<Division, Settings, Exception, Group, Teacher, Location, Course, Event, OverlapGroup, Period, Person, LockedTime, RootInterval, Syllabus, Configuration.Base, LinkedEventsSet>;
+}
+declare namespace MixedWithOptionalId {
+  type Teacher = MixedWithOptionalIdVertexExport<TeacherVertex>;
+  type Exception = MixedWithOptionalIdVertexExport<ExceptionVertex>;
+  type Event = MixedWithOptionalIdVertexExport<EventVertex>;
+  type ScheduleEvent = MixedWithOptionalIdVertexExport<ScheduleEventVertex>;
+  type CalendarEvent = MixedWithOptionalIdVertexExport<CalendarEventVertex>;
+  type Course = MixedWithOptionalIdVertexExport<CourseVertex>;
+  type Settings = MixedWithOptionalIdVertexExport<DivisionSettingsVertex>;
+  type Division = MixedWithOptionalIdVertexExport<DivisionVertex>;
+  type Generation = MixedWithOptionalIdVertexExport<GenerationVertex>;
+  type Group = MixedWithOptionalIdVertexExport<GroupVertex>;
+  type Location = MixedWithOptionalIdVertexExport<LocationVertex>;
+  type LockedTime = MixedWithOptionalIdVertexExport<LockedTimeVertex>;
+  type OverlapGroup = MixedWithOptionalIdVertexExport<OverlapGroupVertex>;
+  type LinkedEventsSet = MixedWithOptionalIdVertexExport<LinkedEventsSetVertex>;
+  type Period = MixedWithOptionalIdVertexExport<PeriodVertex>;
+  type Person = MixedWithOptionalIdVertexExport<PersonVertex>;
+  type RootInterval = MixedWithOptionalIdVertexExport<RootIntervalVertex>;
+  type Syllabus = MixedWithOptionalIdVertexExport<SyllabusVertex>;
+  type Thread = MixedWithOptionalIdVertexExport<ThreadVertex>;
+  type User = MixedWithOptionalIdVertexExport<UserVertex>;
+  namespace Configuration {
+    type Base = MixedWithOptionalIdVertexExport<ConfigurationVertex>;
+    type Filter = MixedWithOptionalIdVertexExport<ConfigurationFilterVertex>;
+    type Template = MixedWithOptionalIdVertexExport<ConfigurationTemplateVertex>;
+    type Rule = MixedWithOptionalIdVertexExport<ConfigurationRuleVertex>;
+    type Mixed = Filter | Template | Rule;
+  }
+  type Schedule = ScheduleOf<Division, Settings, Exception, Group, Teacher, Location, Course, Event, OverlapGroup, Period, Person, LockedTime, RootInterval, Syllabus, Configuration.Base, LinkedEventsSet>;
+}
+declare namespace SerializedWithOptionalId {
+  type MakeIdsOptional<T extends Pick<Vertex<Collection>, IdKey | InternalIdKey>> = Omit<T, IdKey | InternalIdKey> & Partial<Pick<T, IdKey | InternalIdKey>>;
+  export type Teacher = MakeIdsOptional<Serialized.Teacher>;
+  export type Exception = MakeIdsOptional<Serialized.Exception>;
+  export type Event = MakeIdsOptional<Serialized.Event>;
+  export type ScheduleEvent = MakeIdsOptional<Serialized.ScheduleEvent>;
+  export type CalendarEvent = MakeIdsOptional<Serialized.CalendarEvent>;
+  export type Course = MakeIdsOptional<Serialized.Course>;
+  export type Settings = MakeIdsOptional<Serialized.Settings>;
+  export type Division = MakeIdsOptional<Serialized.Division>;
+  export type Generation = MakeIdsOptional<Serialized.Generation>;
+  export type Group = MakeIdsOptional<Serialized.Group>;
+  export type Location = MakeIdsOptional<Serialized.Location>;
+  export type LockedTime = MakeIdsOptional<Serialized.LockedTime>;
+  export type OverlapGroup = MakeIdsOptional<Serialized.OverlapGroup>;
+  export type LinkedEventsSet = MakeIdsOptional<Serialized.LinkedEventsSet>;
+  export type Period = MakeIdsOptional<Serialized.Period>;
+  export type Person = MakeIdsOptional<Serialized.Person>;
+  export type RootInterval = MakeIdsOptional<Serialized.RootInterval>;
+  export type Syllabus = MakeIdsOptional<Serialized.Syllabus>;
+  export type Thread = MakeIdsOptional<Serialized.Thread>;
+  export type User = MakeIdsOptional<Serialized.User>;
+  export namespace Configuration {
+    type Base = MakeIdsOptional<Serialized.Configuration.Base>;
+    type Filter = MakeIdsOptional<Serialized.Configuration.Filter>;
+    type Template = MakeIdsOptional<Serialized.Configuration.Template>;
+    type Rule = MakeIdsOptional<Serialized.Configuration.Rule>;
+    type Mixed = Filter | Template | Rule;
+  }
+  export type Schedule = ScheduleOf<Division, Settings, Exception, Group, Teacher, Location, Course, Event, OverlapGroup, Period, Person, LockedTime, RootInterval, Syllabus, Configuration.Base, LinkedEventsSet>;
+  export {};
+}
+//#endregion
+export { Deep, DeepWithoutPrivateId, Mixed, MixedWithOptionalId, Serialized, SerializedWithOptionalId };
+//# sourceMappingURL=index.d.mts.map

package/dist/core/interfaces/vertices/index.mjs

@@ -0,0 +1,3 @@
+import { createVertexQuery } from "./vertex-query.mjs";
+
+export {  };

package/dist/core/interfaces/vertices/linked-events-sets.d.mts

@@ -0,0 +1,19 @@
+import { VertexFactory } from "./util/vertex.mjs";
+import { EdgeWrapper, Plain } from "./util/edges.mjs";
+import "./util/index.mjs";
+import { BelongsTo } from "./properties/belongs-to.mjs";
+import { EventVertex } from "./events.mjs";
+
+//#region src/core/interfaces/vertices/linked-events-sets.d.ts
+type LinkedEventsSetVertex = VertexFactory<'linkedEventsSets', BelongsTo & {
+  type?: 'parallel' | 'sequential' | 'custom';
+  anchor?: 'start' | 'middle' | 'end';
+  gap?: {
+    min: number;
+    max: number;
+  };
+  events: EdgeWrapper<'array', Plain.Edge<EventVertex>>;
+}>;
+//#endregion
+export { LinkedEventsSetVertex };
+//# sourceMappingURL=linked-events-sets.d.mts.map

package/dist/core/interfaces/vertices/locations.d.mts

@@ -0,0 +1,22 @@
+import { VertexFactory } from "./util/vertex.mjs";
+import { EdgeWrapper, Plain } from "./util/edges.mjs";
+import "./util/index.mjs";
+import { Day } from "./properties/days.mjs";
+import { Tag } from "./properties/tags.mjs";
+import { BelongsTo } from "./properties/belongs-to.mjs";
+import { ExceptionVertex } from "./exceptions.mjs";
+import { LockedTimeVertex } from "./locked-times.mjs";
+
+//#region src/core/interfaces/vertices/locations.d.ts
+type LocationVertex = VertexFactory<'locations', BelongsTo & {
+  tags?: Tag[];
+  minBreakLength?: number;
+  days?: Day[];
+  maximumCapacity?: number;
+  lockedTimes?: EdgeWrapper<'array', Plain.Edge<LockedTimeVertex>>;
+  lunch?: EdgeWrapper<'array', Plain.Edge<LockedTimeVertex>>;
+  exceptions?: EdgeWrapper<'array', Plain.Edge<ExceptionVertex>>;
+}>;
+//#endregion
+export { LocationVertex };
+//# sourceMappingURL=locations.d.mts.map

package/dist/core/interfaces/vertices/locked-times.d.mts

@@ -0,0 +1,37 @@
+import { VertexFactory } from "./util/vertex.mjs";
+import { Coalesced, EdgeWrapper } from "./util/edges.mjs";
+import "./util/index.mjs";
+import { Interval } from "./properties/intervals.mjs";
+import { Tag } from "./properties/tags.mjs";
+import "./properties/index.mjs";
+import { BelongsTo } from "./properties/belongs-to.mjs";
+import { LocationVertex } from "./locations.mjs";
+import { EventVertex } from "./events.mjs";
+import { CourseVertex } from "./courses.mjs";
+import { GroupVertex } from "./groups.mjs";
+import { TeacherVertex } from "./teachers.mjs";
+import { Moment } from "moment";
+
+//#region src/core/interfaces/vertices/locked-times.d.ts
+/**
+ * TODO: remove the `ANY` type
+ */
+type LockedTimeType = 'ANY' | 'LUNCH' | 'COMPLEMENTARY_TIME';
+type LockedTimeVertex = VertexFactory<'lockedTimes', BelongsTo & {
+  start?: Moment | string;
+  end?: Moment | string;
+  visible?: boolean;
+  parked?: boolean;
+  duration?: number;
+  durationVariance?: number;
+  type?: LockedTimeType;
+  /**
+   * @note an empty array is the same as undefined
+   */
+  intervals?: Interval[];
+  tags?: Tag[];
+  coalesced?: EdgeWrapper<'array', Coalesced.Edge<GroupVertex> | Coalesced.Edge<CourseVertex> | Coalesced.Edge<TeacherVertex> | Coalesced.Edge<LocationVertex> | Coalesced.Edge<EventVertex>>;
+}>;
+//#endregion
+export { LockedTimeType, LockedTimeVertex };
+//# sourceMappingURL=locked-times.d.mts.map

package/dist/core/interfaces/vertices/overlap-groups.d.mts

@@ -0,0 +1,17 @@
+import { VertexFactory } from "./util/vertex.mjs";
+import { Coalesced, EdgeWrapper } from "./util/edges.mjs";
+import "./util/index.mjs";
+import { BelongsTo } from "./properties/belongs-to.mjs";
+import { EventVertex } from "./events.mjs";
+import { CourseVertex } from "./courses.mjs";
+
+//#region src/core/interfaces/vertices/overlap-groups.d.ts
+type OverlapGroupVertex = VertexFactory<'overlapGroups', BelongsTo & {
+  coalesced?: EdgeWrapper<'array', Coalesced.Edge<CourseVertex>>;
+  species?: EdgeWrapper<'array', Coalesced.Edge<EventVertex, object, {
+    id: string;
+  }>>;
+}>;
+//#endregion
+export { OverlapGroupVertex };
+//# sourceMappingURL=overlap-groups.d.mts.map

package/dist/core/interfaces/vertices/periods.d.mts

@@ -0,0 +1,15 @@
+import { VertexFactory } from "./util/vertex.mjs";
+import "./util/index.mjs";
+import { Interval } from "./properties/intervals.mjs";
+import "./properties/index.mjs";
+import { BelongsTo } from "./properties/belongs-to.mjs";
+import { Moment } from "moment";
+
+//#region src/core/interfaces/vertices/periods.d.ts
+type PeriodVertex = VertexFactory<'periods', BelongsTo & {
+  ranges: Interval<string | Moment | Date>[];
+  displayIndex?: number;
+}>;
+//#endregion
+export { PeriodVertex };
+//# sourceMappingURL=periods.d.mts.map

package/dist/core/interfaces/vertices/persons.d.mts

@@ -0,0 +1,32 @@
+import { VertexFactory } from "./util/vertex.mjs";
+import { EdgeWrapper, Plain } from "./util/edges.mjs";
+import "./util/index.mjs";
+import { Tag } from "./properties/tags.mjs";
+import { BelongsTo } from "./properties/belongs-to.mjs";
+import { GroupVertex } from "./groups.mjs";
+
+//#region src/core/interfaces/vertices/persons.d.ts
+type PersonVertex = VertexFactory<'persons', BelongsTo & {
+  lastName?: string;
+  firstName?: string;
+  birthDate?: Date;
+  sex?: 'Man' | 'Woman';
+  type?: 'Student' | 'Teacher' | 'Other';
+  tags?: Tag[];
+  SSN?: {
+    value: string;
+    nationality?: string;
+  };
+  emails?: {
+    value: string;
+    type?: string;
+  }[];
+  phoneNumbers?: {
+    value: string;
+    type: string;
+  }[];
+  group?: EdgeWrapper<'single', Plain.Edge<GroupVertex>>;
+}>;
+//#endregion
+export { PersonVertex };
+//# sourceMappingURL=persons.d.mts.map

package/dist/core/interfaces/vertices/properties/belongs-to.d.mts

@@ -0,0 +1,11 @@
+import { EdgeWrapper, Plain } from "../util/edges.mjs";
+import "../util/index.mjs";
+import { DivisionVertex } from "../divisions.mjs";
+
+//#region src/core/interfaces/vertices/properties/belongs-to.d.ts
+type BelongsTo = {
+  belongsTo?: EdgeWrapper<'single', Plain.Edge<DivisionVertex>>;
+};
+//#endregion
+export { BelongsTo };
+//# sourceMappingURL=belongs-to.d.mts.map

package/dist/core/interfaces/vertices/properties/coalesced.d.mts

@@ -0,0 +1,8 @@
+import { Coalesced as Coalesced$1 } from "../util/edges.mjs";
+import "../util/index.mjs";
+
+//#region src/core/interfaces/vertices/properties/coalesced.d.ts
+type Coalesced<T, M = string> = Coalesced$1.Util.Value<T, M>;
+//#endregion
+export { Coalesced };
+//# sourceMappingURL=coalesced.d.mts.map

package/dist/core/interfaces/vertices/properties/days.d.mts

@@ -0,0 +1,9 @@
+//#region src/core/interfaces/vertices/properties/days.d.ts
+interface Day {
+  is?: 'day';
+  day: number;
+  rank?: number;
+}
+//#endregion
+export { Day };
+//# sourceMappingURL=days.d.mts.map

package/dist/core/interfaces/vertices/properties/index.d.mts

@@ -0,0 +1,15 @@
+import { Coalesced } from "./coalesced.mjs";
+import { Species } from "./species.mjs";
+import { AllWeeks, Week, allWeeks } from "./week.mjs";
+import { Day } from "./days.mjs";
+import { Interval } from "./intervals.mjs";
+import { Tag, TagType } from "./tags.mjs";
+import { MaximumScheduleSpan } from "./maximum-schedule-span.mjs";
+import { PlannedScheduledDuration } from "./planned-scheduled-duration.mjs";
+import { MinBreakLength } from "./min-break-length.mjs";
+
+//#region src/core/interfaces/vertices/properties/index.d.ts
+type PublicId = string;
+//#endregion
+export { PublicId };
+//# sourceMappingURL=index.d.mts.map

package/dist/core/interfaces/vertices/properties/intervals.d.mts

@@ -0,0 +1,10 @@
+import { DateType } from "../../other/etc.mjs";
+
+//#region src/core/interfaces/vertices/properties/intervals.d.ts
+type Interval<T extends DateType = DateType> = {
+  start: T;
+  end: T;
+};
+//#endregion
+export { Interval };
+//# sourceMappingURL=intervals.d.mts.map

package/dist/core/interfaces/vertices/properties/maximum-schedule-span.d.mts

@@ -0,0 +1,19 @@
+//#region src/core/interfaces/vertices/properties/maximum-schedule-span.d.ts
+/**
+ * The maximum number of minutes a schedule is allowed to span over a day and week
+ */
+type MaximumScheduleSpan = {
+  /**
+   * The maximum number of minutes a schedule is allowed to span over a day.
+   * The daily schedule span is the duration between the start of the first event and the end of the last event that day.
+   */
+  daily?: number | null;
+  /**
+   * The maximum number of minutes a schedule is allowed to span over a week.
+   * The weekly schedule span is the sum of the daily schedule spans for each day of the week.
+   */
+  weekly?: number | null;
+};
+//#endregion
+export { MaximumScheduleSpan };
+//# sourceMappingURL=maximum-schedule-span.d.mts.map

package/dist/core/interfaces/vertices/properties/min-break-length.d.mts

@@ -0,0 +1,5 @@
+//#region src/core/interfaces/vertices/properties/min-break-length.d.ts
+type MinBreakLength = number | [number, number] | false;
+//#endregion
+export { MinBreakLength };
+//# sourceMappingURL=min-break-length.d.mts.map

package/dist/core/interfaces/vertices/properties/planned-scheduled-duration.d.mts

@@ -0,0 +1,13 @@
+//#region src/core/interfaces/vertices/properties/planned-scheduled-duration.d.ts
+/**
+ * The planned/expected total weekly minutes of schedule events assigned to a teacher
+ */
+type PlannedScheduledDuration = {
+  /**
+   * The planned/expected total weekly minutes of schedule events assigned to a teacher
+   */
+  weekly?: number | null;
+};
+//#endregion
+export { PlannedScheduledDuration };
+//# sourceMappingURL=planned-scheduled-duration.d.mts.map

package/dist/core/interfaces/vertices/properties/species.d.mts

@@ -0,0 +1,9 @@
+//#region src/core/interfaces/vertices/properties/species.d.ts
+interface Species<T, M = string> {
+  to: T;
+  toModel: M;
+  id: string;
+}
+//#endregion
+export { Species };
+//# sourceMappingURL=species.d.mts.map

package/dist/core/interfaces/vertices/properties/tags.d.mts

@@ -0,0 +1,9 @@
+//#region src/core/interfaces/vertices/properties/tags.d.ts
+type TagType = 'COMPLEMENTARY_TIME' | 'category';
+type Tag = {
+  type?: TagType;
+  value: string;
+};
+//#endregion
+export { Tag, TagType };
+//# sourceMappingURL=tags.d.mts.map

package/dist/core/interfaces/vertices/properties/week.d.mts

@@ -0,0 +1,22 @@
+import { Moment } from "moment";
+
+//#region src/core/interfaces/vertices/properties/week.d.ts
+type Week = {
+  id: string;
+  range: {
+    start: Moment;
+    end: Moment;
+  };
+  number: number;
+  string: string;
+  excludedDays: {
+    date: string;
+    day: number;
+    reason?: string;
+  }[];
+};
+declare const allWeeks = "all";
+type AllWeeks = typeof allWeeks;
+//#endregion
+export { AllWeeks, Week, allWeeks };
+//# sourceMappingURL=week.d.mts.map

package/dist/core/interfaces/vertices/properties/week.mjs

@@ -0,0 +1,6 @@
+//#region src/core/interfaces/vertices/properties/week.ts
+const allWeeks = "all";
+
+//#endregion
+export { allWeeks };
+//# sourceMappingURL=week.mjs.map

package/dist/core/interfaces/vertices/properties/week.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"week.mjs","names":[],"sources":["../../../../../src/core/interfaces/vertices/properties/week.ts"],"sourcesContent":["import type { Moment } from 'moment';\n\nexport type Week = {\n  id:           string;\n  range:        { start: Moment; end: Moment };\n  number:       number;\n  string:       string;\n  excludedDays: { date: string, day: number, reason?: string }[];\n};\n\nexport const allWeeks = 'all';\nexport type AllWeeks = typeof allWeeks;"],"mappings":";AAUA,MAAa,WAAW"}

package/dist/core/interfaces/vertices/root-intervals.d.mts

@@ -0,0 +1,14 @@
+import { VertexFactory } from "./util/vertex.mjs";
+import "./util/index.mjs";
+import { Interval } from "./properties/intervals.mjs";
+import "./properties/index.mjs";
+import { BelongsTo } from "./properties/belongs-to.mjs";
+import { Moment } from "moment";
+
+//#region src/core/interfaces/vertices/root-intervals.d.ts
+type RootIntervalVertex = VertexFactory<'rootIntervals', BelongsTo & {
+  intervals: Interval<string | Moment>[];
+}>;
+//#endregion
+export { RootIntervalVertex };
+//# sourceMappingURL=root-intervals.d.mts.map

package/dist/core/interfaces/vertices/syllabuses.d.mts

@@ -0,0 +1,18 @@
+import { VertexFactory } from "./util/vertex.mjs";
+import "./util/index.mjs";
+import { BelongsTo } from "./properties/belongs-to.mjs";
+
+//#region src/core/interfaces/vertices/syllabuses.d.ts
+type SyllabusVertex = VertexFactory<'syllabuses', BelongsTo & {
+  schoolType: string;
+  subjectCode?: string;
+  subjectName: string;
+  subjectDesignation?: string;
+  courseCode?: string;
+  courseName?: string;
+  points?: number;
+  official: boolean;
+}>;
+//#endregion
+export { SyllabusVertex };
+//# sourceMappingURL=syllabuses.d.mts.map