@royalschedule/maps 4.0.15 → 4.0.17

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

@@ -0,0 +1,209 @@
+import { Collection, Vertex } from "./util/vertex.js";
+import { IdKey, InternalIdKey } from "../../types/common/index.js";
+import { DeepVertexExport, DeepVertexExportOmitPrivateId, MixedVertexExport, MixedWithOptionalIdVertexExport } from "./util/deep-vertex-export/index.js";
+import { SerializedVertexExport } from "./util/serialized-vertex-export.js";
+import "./util/index.js";
+import { PeriodVertex } from "./periods.js";
+import { RootIntervalVertex } from "./root-intervals.js";
+import { CalendarException, DivisionSettingsVertex } from "./division-settings.js";
+import { GenerationVertex } from "./generations.js";
+import { DivisionVertex, StepGuideProgress } from "./divisions.js";
+import { PersonVertex } from "./persons.js";
+import { LocationVertex } from "./locations.js";
+import { CalendarEventVertex, EventVertex, ScheduleEventVertex } from "./events.js";
+import { OverlapGroupVertex } from "./overlap-groups.js";
+import { SyllabusVertex } from "./syllabuses.js";
+import { CourseVertex } from "./courses.js";
+import { CalendarExceptionAction, ExceptionStatus, ExceptionVertex } from "./exceptions.js";
+import { GroupVertex } from "./groups.js";
+import { LockedTimeType, LockedTimeVertex } from "./locked-times.js";
+import { TeacherVertex } from "./teachers.js";
+import { ConfigurationFilterVertex, ConfigurationRuleVertex, ConfigurationTemplateVertex, ConfigurationVertex } from "./configurations.js";
+import { Infer, VertexQuery, createVertexQuery } from "./vertex-query.js";
+
+//#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'>> = {
+  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[];
+};
+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 Period = SerializedVertexExport<PeriodVertex>;
+  type Person = SerializedVertexExport<PersonVertex>;
+  type RootInterval = SerializedVertexExport<RootIntervalVertex>;
+  type Syllabus = SerializedVertexExport<SyllabusVertex>;
+  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>;
+}
+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 Period = DeepVertexExport<PeriodVertex>;
+  type Person = DeepVertexExport<PersonVertex>;
+  type RootInterval = DeepVertexExport<RootIntervalVertex>;
+  type Syllabus = DeepVertexExport<SyllabusVertex>;
+  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>;
+}
+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 Period = DeepVertexExportOmitPrivateId<PeriodVertex>;
+  type Person = DeepVertexExportOmitPrivateId<PersonVertex>;
+  type RootInterval = DeepVertexExportOmitPrivateId<RootIntervalVertex>;
+  type Syllabus = DeepVertexExportOmitPrivateId<SyllabusVertex>;
+  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>;
+}
+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 Period = MixedVertexExport<PeriodVertex>;
+  type Person = MixedVertexExport<PersonVertex>;
+  type RootInterval = MixedVertexExport<RootIntervalVertex>;
+  type Syllabus = MixedVertexExport<SyllabusVertex>;
+  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>;
+}
+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 Period = MixedWithOptionalIdVertexExport<PeriodVertex>;
+  type Person = MixedWithOptionalIdVertexExport<PersonVertex>;
+  type RootInterval = MixedWithOptionalIdVertexExport<RootIntervalVertex>;
+  type Syllabus = MixedWithOptionalIdVertexExport<SyllabusVertex>;
+  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>;
+}
+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 Period = MakeIdsOptional<Serialized.Period>;
+  export type Person = MakeIdsOptional<Serialized.Person>;
+  export type RootInterval = MakeIdsOptional<Serialized.RootInterval>;
+  export type Syllabus = MakeIdsOptional<Serialized.Syllabus>;
+  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>;
+  export {};
+}
+//#endregion
+export { Deep, DeepWithoutPrivateId, Mixed, MixedWithOptionalId, Serialized, SerializedWithOptionalId };
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -0,0 +1,22 @@
+import { VertexFactory } from "./util/vertex.js";
+import { EdgeWrapper, Plain } from "./util/edges.js";
+import "./util/index.js";
+import { Day } from "./properties/days.js";
+import { Tag } from "./properties/tags.js";
+import { BelongsTo } from "./properties/belongs-to.js";
+import { ExceptionVertex } from "./exceptions.js";
+import { LockedTimeVertex } from "./locked-times.js";
+
+//#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.ts.map

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

@@ -0,0 +1,37 @@
+import { VertexFactory } from "./util/vertex.js";
+import { Coalesced, EdgeWrapper } from "./util/edges.js";
+import "./util/index.js";
+import { Interval } from "./properties/intervals.js";
+import { Tag } from "./properties/tags.js";
+import "./properties/index.js";
+import { BelongsTo } from "./properties/belongs-to.js";
+import { LocationVertex } from "./locations.js";
+import { EventVertex } from "./events.js";
+import { CourseVertex } from "./courses.js";
+import { GroupVertex } from "./groups.js";
+import { TeacherVertex } from "./teachers.js";
+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.ts.map

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

@@ -0,0 +1,17 @@
+import { VertexFactory } from "./util/vertex.js";
+import { Coalesced, EdgeWrapper } from "./util/edges.js";
+import "./util/index.js";
+import { BelongsTo } from "./properties/belongs-to.js";
+import { EventVertex } from "./events.js";
+import { CourseVertex } from "./courses.js";
+
+//#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.ts.map

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

@@ -0,0 +1,15 @@
+import { VertexFactory } from "./util/vertex.js";
+import "./util/index.js";
+import { Interval } from "./properties/intervals.js";
+import "./properties/index.js";
+import { BelongsTo } from "./properties/belongs-to.js";
+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.ts.map

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

@@ -0,0 +1,32 @@
+import { VertexFactory } from "./util/vertex.js";
+import { EdgeWrapper, Plain } from "./util/edges.js";
+import "./util/index.js";
+import { Tag } from "./properties/tags.js";
+import { BelongsTo } from "./properties/belongs-to.js";
+import { GroupVertex } from "./groups.js";
+
+//#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.ts.map

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

@@ -0,0 +1,11 @@
+import { EdgeWrapper, Plain } from "../util/edges.js";
+import "../util/index.js";
+import { DivisionVertex } from "../divisions.js";
+
+//#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.ts.map

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

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

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

@@ -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.ts.map

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

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

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

@@ -0,0 +1,10 @@
+import { DateType } from "../../other/etc.js";
+
+//#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.ts.map

package/dist/core/{types/common → interfaces/vertices/properties}/maximum-schedule-span.d.ts

@@ -1,4 +1,4 @@
-//#region src/core/types/common/maximum-schedule-span.d.ts
+//#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
  */

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

@@ -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.ts.map

package/dist/core/{types/common/planned-schedule-duration.d.ts → interfaces/vertices/properties/planned-scheduled-duration.d.ts}

@@ -1,4 +1,4 @@
-//#region src/core/types/common/planned-schedule-duration.d.ts
+//#region src/core/interfaces/vertices/properties/planned-scheduled-duration.d.ts
 /**
  * The planned/expected total weekly minutes of schedule events assigned to a teacher
  */
@@ -10,4 +10,4 @@ type PlannedScheduledDuration = {
 };
 //#endregion
 export { PlannedScheduledDuration };
-//# sourceMappingURL=planned-schedule-duration.d.ts.map
+//# sourceMappingURL=planned-scheduled-duration.d.ts.map

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

@@ -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.ts.map

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

@@ -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.ts.map

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

@@ -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.ts.map

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"week.js","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.ts

@@ -0,0 +1,14 @@
+import { VertexFactory } from "./util/vertex.js";
+import "./util/index.js";
+import { Interval } from "./properties/intervals.js";
+import "./properties/index.js";
+import { BelongsTo } from "./properties/belongs-to.js";
+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.ts.map

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

@@ -0,0 +1,18 @@
+import { VertexFactory } from "./util/vertex.js";
+import "./util/index.js";
+import { BelongsTo } from "./properties/belongs-to.js";
+
+//#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.ts.map

package/dist/core/interfaces/vertices/teachers.d.ts

@@ -0,0 +1,43 @@
+import { VertexFactory } from "./util/vertex.js";
+import { EdgeWrapper, Plain } from "./util/edges.js";
+import "./util/index.js";
+import { Day } from "./properties/days.js";
+import { Interval } from "./properties/intervals.js";
+import { Tag } from "./properties/tags.js";
+import { MaximumScheduleSpan } from "./properties/maximum-schedule-span.js";
+import { PlannedScheduledDuration } from "./properties/planned-scheduled-duration.js";
+import { RootIntervalVertex } from "./root-intervals.js";
+import { BelongsTo } from "./properties/belongs-to.js";
+import { PersonVertex } from "./persons.js";
+import { ExceptionVertex } from "./exceptions.js";
+import { LockedTimeVertex } from "./locked-times.js";
+
+//#region src/core/interfaces/vertices/teachers.d.ts
+type TeacherVertex = VertexFactory<'teachers', BelongsTo & {
+  tags?: Tag[];
+  signature?: string;
+  minBreakLength?: number;
+  /** @deprecated replaced by defaultMaximumScheduleSpan */
+  maxNumWorkingHours?: number | false;
+  /** @deprecated replaced by defaultMaximumScheduleSpan */
+  maxNumDailyWorkingHours?: number | number[] | false;
+  plannedScheduledDuration?: PlannedScheduledDuration;
+  maximumScheduleSpan?: MaximumScheduleSpan;
+  forbidOverlappingEvents?: boolean;
+  disableDayLengthPunishment?: boolean;
+  weight?: number;
+  /**
+   * @note an empty array is the same as undefined
+   */
+  intervals?: Interval[];
+  days?: Day[];
+  rootInterval?: EdgeWrapper<'single', Plain.Edge<RootIntervalVertex>>;
+  lockedTimes?: EdgeWrapper<'array', Plain.Edge<LockedTimeVertex>>;
+  lunch?: EdgeWrapper<'array', Plain.Edge<LockedTimeVertex>>;
+  complementaryTimes?: EdgeWrapper<'array', Plain.Edge<LockedTimeVertex>>;
+  exceptions?: EdgeWrapper<'array', Plain.Edge<ExceptionVertex>>;
+  person?: EdgeWrapper<'single', Plain.Edge<PersonVertex>>;
+}>;
+//#endregion
+export { TeacherVertex };
+//# sourceMappingURL=teachers.d.ts.map

package/dist/core/interfaces/vertices/users.d.ts

@@ -0,0 +1,8 @@
+import { VertexFactory } from "./util/vertex.js";
+import "./util/index.js";
+
+//#region src/core/interfaces/vertices/users.d.ts
+type UserVertex = VertexFactory<'users', object>;
+//#endregion
+export { UserVertex };
+//# sourceMappingURL=users.d.ts.map

package/dist/core/interfaces/vertices/util/common.d.ts

@@ -0,0 +1,28 @@
+import { Collection, OmitVertexProperties, PickVertexProperties, Vertex } from "./vertex.js";
+import { EdgeMultiplicity, EdgeWrapper } from "./edges.js";
+import { Tail } from "./util.js";
+
+//#region src/core/interfaces/vertices/util/common.d.ts
+type IsAny<T> = 0 extends (1 & T) ? true : false;
+/**
+ * Picks all properties of a vertex that are edges to other vertices. (we ignore explicit any types)
+ */
+type PickEdges<V extends Vertex<Collection>> = { [K in keyof V as NonNullable<V[K]> extends EdgeWrapper<EdgeMultiplicity, any> ? IsAny<V[K]> extends true ? never : K : never]: V[K] };
+/**
+ * Omits all properties of a vertex that are edges to other vertices.
+ */
+type OmitEdges<V extends Vertex<Collection>> = PickVertexProperties<V> & OmitVertexProperties<{ [K in keyof V as NonNullable<V[K]> extends EdgeWrapper<EdgeMultiplicity, any> ? never : K]: V[K] }>;
+declare const SELECT_KEY = "select";
+type SelectKey = typeof SELECT_KEY;
+declare const EXPAND_KEY = "expand";
+type ExpandKey = typeof EXPAND_KEY;
+type InvalidEdgeMessage = 'INVALID VERTEX EDGE';
+type RemoveNeverValues<T extends object> = { [K in keyof T as T[K] extends never ? never : K]: T[K] };
+type DepthDecrementMap = [never, 0, 1, 2, 3];
+type SupportedDepths = DepthDecrementMap[number];
+type MaxDepth = Tail<DepthDecrementMap>;
+type MinDepth = Extract<SupportedDepths, 0>;
+type Decrement<T extends SupportedDepths> = DepthDecrementMap[T];
+//#endregion
+export { Decrement, EXPAND_KEY, ExpandKey, InvalidEdgeMessage, MaxDepth, MinDepth, OmitEdges, PickEdges, RemoveNeverValues, SELECT_KEY, SelectKey, SupportedDepths };
+//# sourceMappingURL=common.d.ts.map

package/dist/core/interfaces/vertices/util/custom-vertex-export/index.d.ts

@@ -0,0 +1,31 @@
+import { Collection, Vertex } from "../vertex.js";
+import { AvailableLocation, Coalesced, EdgeBase, EdgeWrapper, GroupWithExclude, Plain, Wrapped } from "../edges.js";
+import { ExtractNullish, Prettify, SetMultiplicity } from "../util.js";
+import { ExpandKey, OmitEdges, PickEdges } from "../common.js";
+import { KeysOf } from "../keys-of.js";
+import { VertexQuery } from "../vertex-query/index.js";
+import { ExtractChildKeys, ExtractChildObject, ExtractParentKeys, IntersectExpandSelectPath, Lookup, RelaxedPick } from "./util.js";
+
+//#region src/core/interfaces/vertices/util/custom-vertex-export/index.d.ts
+declare namespace HandleEdge {
+  type Recursion<V extends Vertex<Collection>, Query> = [Query] extends [never] ? string : Query extends VertexQuery<V> ? CustomVertexExport<V, Query> : never;
+  export type Plain<E$1 extends EdgeBase<any, any>, Query> = E$1 extends Plain.Edge<infer V> ? Recursion<V, Query> : never;
+  export type Wrapped<E$1 extends EdgeBase<any, any>, Query> = E$1 extends Wrapped.Edge<infer K, infer V extends Vertex<Collection>, infer Extra extends object> ? Wrapped.Util.Value<K, Recursion<V, IntersectExpandSelectPath<Lookup<Query, K>, VertexQuery<V>>>, Extra> : never;
+  export type Coalesced<E$1 extends EdgeBase<any, any>, Query> = E$1 extends Coalesced.Edge<infer V, infer O extends object, infer Extra extends object> ? V extends Vertex<Collection> ? Coalesced.Util.Value<Recursion<V, IntersectExpandSelectPath<Lookup<Query, Coalesced.Util.Keys.To>, VertexQuery<V>>>, Coalesced.Util.ToModel<V>, O, Extra> : never : never;
+  export type GroupWithExclude<E$1 extends EdgeBase<any, any>, Query> = E$1 extends GroupWithExclude.Edge<infer G extends Vertex<any>, infer P extends Vertex<any>, infer Extra extends object> ? GroupWithExclude.Util.Value<Recursion<G, IntersectExpandSelectPath<Lookup<Query, GroupWithExclude.Util.Keys.To>, VertexQuery<G>>>, Recursion<P, IntersectExpandSelectPath<Lookup<Query, GroupWithExclude.Util.Keys.Exclude>, VertexQuery<P>>>, Extra> : never;
+  export type AvailableLocation<E$1 extends EdgeBase<any, any>, Query> = E$1 extends AvailableLocation.Edge<infer L extends Vertex<any>, infer Extra extends object> ? AvailableLocation.Util.Value<Recursion<L, IntersectExpandSelectPath<Lookup<Query, AvailableLocation.Util.Keys.Locations>, VertexQuery<L>>>, Extra> : never;
+  export {};
+}
+/**
+ * Recursively exports a Vertex type to a plain object structure,
+ * selecting and expanding properties and edges according to the provided expand/select path.
+ * - Non-edge properties are included based on selection.
+ * - Edge properties are exported and expanded according to their type (Plain, Coalesced, GroupWithExclude, AvailableLocation).
+ * - Handles edge multiplicity (single/array) and optional/null cases.
+ * - Invalid or unsupported edge unions are filtered out as `never`.
+ * - Supports dot-notation for nested property selection and expansion.
+ */
+type CustomVertexExport<V extends Vertex<Collection>, Q extends VertexQuery<V> | never> = Prettify<{ [K in keyof OmitEdges<V> as K extends KeysOf<V, Q> ? K : never]: V[K] } & { [K in keyof PickEdges<V> as K extends ExtractParentKeys<KeysOf<V, Q>> ? K : never]: [V[K]] extends [never] ? never : NonNullable<V[K]> extends EdgeWrapper<infer M, infer E extends EdgeBase<any, any> | null | undefined> ? (SetMultiplicity<Prettify<E extends EdgeBase<any, any> ? (HandleEdge.Plain<E, Lookup<Q[ExpandKey], K>> | RelaxedPick<HandleEdge.Wrapped<E, ExtractChildObject<Q[ExpandKey], K>> | HandleEdge.Coalesced<E, ExtractChildObject<Q[ExpandKey], K>> | HandleEdge.GroupWithExclude<E, ExtractChildObject<Q[ExpandKey], K>> | HandleEdge.AvailableLocation<E, ExtractChildObject<Q[ExpandKey], K>>, ExtractChildKeys<KeysOf<V, Q>, K>>) : E>, M> | ExtractNullish<V[K]>) : never }>;
+//#endregion
+export { CustomVertexExport };
+//# sourceMappingURL=index.d.ts.map