@royalschedule/maps 4.1.3 → 4.1.5

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

@@ -0,0 +1,106 @@
+import { VertexFactory } from "./util/vertex.mjs";
+import { AvailableLocation, EdgeWrapper, GroupWithExclude, 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 { MinBreakLength } from "./properties/min-break-length.mjs";
+import { PeriodVertex } from "./periods.mjs";
+import { BelongsTo } from "./properties/belongs-to.mjs";
+import { PersonVertex } from "./persons.mjs";
+import { LocationVertex } from "./locations.mjs";
+import { LinkedEventsSetVertex } from "./linked-events-sets.mjs";
+import { ThreadVertex } from "./threads.mjs";
+import { SyllabusVertex } from "./syllabuses.mjs";
+import { CourseVertex } from "./courses.mjs";
+import { ExceptionVertex } from "./exceptions.mjs";
+import { GroupVertex } from "./groups.mjs";
+import { LockedTimeVertex } from "./locked-times.mjs";
+import { TeacherVertex } from "./teachers.mjs";
+import { Moment } from "moment";
+
+//#region src/core/interfaces/vertices/events.d.ts
+type BasicSharedProperties = BelongsTo & {
+  color?: string | null;
+  tags?: Tag[];
+  fixedStart?: boolean;
+  visible?: boolean;
+};
+type EventProperties = BasicSharedProperties & {
+  density?: number;
+  weight?: number;
+  potentialCenter?: string;
+  parked?: boolean;
+  minBreakLength?: MinBreakLength | null;
+  preferredDuration: number;
+  durationVariance?: number;
+  duration?: number;
+  centerOfAttraction?: string | null;
+  /**
+   * @note an empty array is the same as undefined
+   */
+  intervals?: Interval[] | null;
+  days?: Day[] | null;
+  start?: Moment | string;
+  end?: Moment | string;
+  weeks?: number[];
+  type?: string;
+  course?: EdgeWrapper<'single', Plain.Edge<CourseVertex>>;
+  period?: EdgeWrapper<'single', Plain.Edge<PeriodVertex>>;
+  linkedEventsSet?: EdgeWrapper<'single', Plain.Edge<LinkedEventsSetVertex>>;
+  lockedTimes?: EdgeWrapper<'array', Plain.Edge<LockedTimeVertex>>;
+  exceptions?: EdgeWrapper<'array', Plain.Edge<ExceptionVertex>>;
+  inLocations?: EdgeWrapper<'array', Plain.Edge<LocationVertex> | null>;
+  participants?: EdgeWrapper<'array', Wrapped.Edge<'to', PersonVertex, {
+    groupIndex?: number;
+  }>>;
+  teachers?: EdgeWrapper<'array', Wrapped.Edge<'to', TeacherVertex, {
+    groupIndex?: number;
+  }>>;
+  groups?: EdgeWrapper<'array', GroupWithExclude.Edge<GroupVertex, PersonVertex, {
+    groupIndex?: number;
+  }>>;
+  locations?: EdgeWrapper<'array', AvailableLocation.Edge<LocationVertex, {
+    groupIndex?: number;
+    rank?: number;
+  }>>;
+  threads?: EdgeWrapper<'array', Plain.Edge<ThreadVertex>>;
+};
+type EventVertex = VertexFactory<'events', EventProperties>;
+type ScheduleEventVertex = VertexFactory<'scheduleEvents', EventProperties & {
+  subject?: string;
+  start?: Moment | string;
+  end?: Moment | string;
+  persons?: EdgeWrapper<'array', Plain.Edge<PersonVertex>>;
+  syllabus?: EdgeWrapper<'single', Plain.Edge<SyllabusVertex>>;
+}>;
+type CalendarEventVertex = VertexFactory<'calendarEvents', BasicSharedProperties & {
+  meta: {
+    createdAt: string;
+    updatedAt: string;
+    type: 'event' | 'lockedtime' | 'exception';
+    subType?: string;
+  };
+  subject?: string;
+  canceled?: boolean;
+  start: number;
+  end: number;
+  exceptions?: EdgeWrapper<'array', Plain.Edge<ExceptionVertex>>;
+  syllabus?: EdgeWrapper<'single', Plain.Edge<SyllabusVertex>>;
+  inLocations?: EdgeWrapper<'array', Plain.Edge<LocationVertex> | null>;
+  participants?: EdgeWrapper<'array', Wrapped.Edge<'to', PersonVertex, {
+    groupIndex?: number;
+  }>>;
+  teachers?: EdgeWrapper<'array', Wrapped.Edge<'to', TeacherVertex, {
+    groupIndex?: number;
+    participates?: boolean;
+  }>>;
+  groups?: EdgeWrapper<'array', GroupWithExclude.Edge<GroupVertex, PersonVertex, {
+    groupIndex?: number;
+    participates?: boolean;
+  }>>;
+  linkedEventsSet?: EdgeWrapper<'single', Plain.Edge<LinkedEventsSetVertex>>;
+}>;
+//#endregion
+export { CalendarEventVertex, EventVertex, ScheduleEventVertex };
+//# sourceMappingURL=events.d.mts.map

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

@@ -0,0 +1,74 @@
+import { Collection, Vertex, VertexFactory } from "./util/vertex.mjs";
+import { Coalesced, EdgeWrapper, Plain } from "./util/edges.mjs";
+import "./util/index.mjs";
+import { PersonVertex } from "./persons.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 { Deep } from "./index.mjs";
+import { Moment } from "moment";
+
+//#region src/core/interfaces/vertices/exceptions.d.ts
+declare const exceptionStatus: readonly ["pending", "failed", "completed", "rejected", "approved"];
+type ExceptionStatus = typeof exceptionStatus[number];
+type CalendarException<T> = {
+  to?: T;
+  toModel?: 'groups' | 'courses' | 'teachers' | 'locations' | 'persons' | string;
+  include?: boolean;
+  start?: Date | string;
+  end?: Date | string;
+  displayName?: string;
+  comment?: string;
+};
+type CalendarExceptionAction = ({
+  action: 'cancel' | 'remove';
+} | {
+  action: 'reschedule';
+  exception: {
+    start?: Date | string;
+    end?: Date | string;
+  };
+} | {
+  action: 'substitute';
+  exception: {
+    to: Deep.Group | Deep.Teacher | Deep.Location | Deep.Person;
+    toModel: 'groups' | 'teachers' | 'locations' | 'persons';
+    include: boolean;
+    start?: Date | string;
+    end?: Date | string;
+  };
+} | {
+  action: 'add';
+  exception: {
+    start: Date | string;
+    end: Date | string;
+    displayName: string;
+  };
+} | {
+  action: 'comment';
+  exception: {
+    comment: string;
+  };
+});
+type CalendarExceptionEdge<V extends Vertex<Collection>> = Coalesced.Edge<V, {
+  optional: true;
+}, Omit<CalendarException<unknown>, 'to' | 'toModel'>>;
+type ExceptionVertex = VertexFactory<'exceptions', {
+  start?: Moment | string;
+  end?: Moment | string;
+  reason?: string;
+  description?: string;
+  comment?: string;
+  action?: 'cancel' | 'remove' | 'reschedule' | 'add' | 'substitute' | 'comment';
+  type?: 'absence' | 'calendar';
+  handleStatus?: ExceptionStatus;
+  sources?: EdgeWrapper<'array', Coalesced.Edge<CourseVertex> | Coalesced.Edge<EventVertex> | Coalesced.Edge<GroupVertex> | Coalesced.Edge<LocationVertex> | Coalesced.Edge<TeacherVertex> | Coalesced.Edge<PersonVertex>>;
+  exception?: EdgeWrapper<'single', CalendarExceptionEdge<GroupVertex> | CalendarExceptionEdge<CourseVertex> | CalendarExceptionEdge<LocationVertex> | CalendarExceptionEdge<TeacherVertex> | CalendarExceptionEdge<PersonVertex>>;
+  parentExceptions?: EdgeWrapper<'array', Plain.Edge<ExceptionVertex>>;
+  exceptions?: EdgeWrapper<'array', Plain.Edge<ExceptionVertex>>;
+}>;
+//#endregion
+export { CalendarExceptionAction, ExceptionStatus, ExceptionVertex };
+//# sourceMappingURL=exceptions.d.mts.map

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

@@ -0,0 +1,23 @@
+import { VertexFactory } from "./util/vertex.mjs";
+import "./util/index.mjs";
+import { User } from "../other/users.mjs";
+import "../other/index.mjs";
+import { BelongsTo } from "./properties/belongs-to.mjs";
+import { Moment } from "moment";
+
+//#region src/core/interfaces/vertices/generations.d.ts
+type Status = 'PENDING' | 'STARTED' | 'COMPLETED' | 'FAILED' | 'CANCELED';
+type GenerationVertex = VertexFactory<'generations', BelongsTo & {
+  createdAt?: string;
+  startedBy?: User;
+  completionDate?: string | Moment;
+  startDate?: string | Moment;
+  configurationId: number;
+  status: Status;
+  error?: string | Error;
+  progress: number;
+  canceled: boolean;
+}>;
+//#endregion
+export { GenerationVertex };
+//# sourceMappingURL=generations.d.mts.map

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,237 @@
+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 { SyllabusVertex } from "./syllabuses.mjs";
+import { CalendarEventVertex, EventVertex, ScheduleEventVertex } from "./events.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 { MessageVertex } from "./messages.mjs";
+import { ConversationVertex } from "./conversations.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'>, 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[];
+  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 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>;
+  type Conversation = SerializedVertexExport<ConversationVertex>;
+  type Message = SerializedVertexExport<MessageVertex>;
+  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, 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 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>;
+  type Conversation = DeepVertexExport<ConversationVertex>;
+  type Message = DeepVertexExport<MessageVertex>;
+  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, 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 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>;
+  type Conversation = DeepVertexExportOmitPrivateId<ConversationVertex>;
+  type Message = DeepVertexExportOmitPrivateId<MessageVertex>;
+  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, 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 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>;
+  type Conversation = MixedVertexExport<ConversationVertex>;
+  type Message = MixedVertexExport<MessageVertex>;
+  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, 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 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>;
+  type Conversation = MixedWithOptionalIdVertexExport<ConversationVertex>;
+  type Message = MixedWithOptionalIdVertexExport<MessageVertex>;
+  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, 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 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 type Conversation = MakeIdsOptional<Serialized.Conversation>;
+  export type Message = MakeIdsOptional<Serialized.Message>;
+  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, 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/messages.d.mts

@@ -0,0 +1,27 @@
+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 { UserVertex } from "./users.mjs";
+import { ConversationVertex } from "./conversations.mjs";
+
+//#region src/core/interfaces/vertices/messages.d.ts
+type MessageVertex = VertexFactory<'messages', BelongsTo & {
+  user: EdgeWrapper<'single', Plain.Edge<UserVertex>>;
+  conversation: EdgeWrapper<'single', Plain.Edge<ConversationVertex>>;
+  type: string;
+  content?: string;
+  status?: string;
+  name?: string;
+  args?: unknown;
+  response?: unknown;
+  reasoning?: boolean;
+  error?: string;
+  interrupt?: {
+    data?: string | Record<string, unknown>;
+    response?: string | Record<string, unknown>;
+  };
+}>;
+//#endregion
+export { MessageVertex };
+//# sourceMappingURL=messages.d.mts.map

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

@@ -0,0 +1,16 @@
+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;
+  inline?: boolean;
+}>;
+//#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