@royalschedule/maps 2.2.77 → 2.2.79

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

@@ -1,4 +1,5 @@
 import { Types } from 'mongoose';
+import { Edge } from './common';
 import { Division } from './divisions';
 import { BreakLength } from './break-lengths';
 import { LockedTime } from './locked-times';
@@ -10,28 +11,29 @@ import { AvailableLocation } from './available-locations';
 import { CourseEvent } from './course-events';
 import { OverlapGroup } from './overlap-groups';
 export interface CourseBare {
-    belongsTo?: Division;
-    events?: CourseEvent[] | string[];
-    groups?: Group[] | string[] | null;
-    teachers?: Teacher[] | string[] | null;
-    locations?: AvailableLocation[] | null;
+    belongsTo?: Edge<Division>;
+    events?: Edge<CourseEvent[]>;
+    groups?: Edge<Group[]>;
+    teachers?: Edge<Teacher[]>;
+    locations?: AvailableLocation[];
     density?: number;
     weight?: number;
     potentialCenter?: string;
     ids?: string;
     subject?: string;
     minBreakLength?: BreakLength;
+    weeks?: number[];
     displayName?: string;
     color?: string;
+    eventDurationVariance?: number;
     totalTime?: string;
     type?: string;
-    lockedTimes?: LockedTime[] | string[];
+    lockedTimes?: Edge<LockedTime[]>;
     intervals?: Interval[];
+    centerOfAttraction?: string | null;
     days?: Day[];
-    overlapGroup?: OverlapGroup;
-    overlapSpecies?: OverlapGroup | null;
-    eventDurationVariance?: number;
-    centerOfAttraction?: string;
+    overlapGroup?: Edge<OverlapGroup> | null;
+    overlapSpecies?: Edge<OverlapGroup> | null;
     minutesPerWeek?: number;
     expectedTotalHours?: number;
     createdAt?: string;

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

@@ -1,11 +1,7 @@
 import { Types } from 'mongoose';
-import { Division } from './divisions';
 export interface DayBare {
-    belongsTo?: Division;
     day?: number;
     rank?: number;
-    to?: Types.ObjectId;
-    toModel?: string;
 }
 export interface Day extends DayBare {
     _id?: Types.ObjectId;

package/dist/core/types/division-settings.d.ts

@@ -1,28 +1,29 @@
 import { Types } from 'mongoose';
+import { Edge } from './common';
 import { Division } from './divisions';
 import { LockedTime } from './locked-times';
 export interface DivisionSettingsBare {
-    belongsTo?: Division;
+    belongsTo?: Edge<Division>;
     createdAt?: string;
+    discretization: number;
     numDays: number;
-    discretization?: number;
-    dayStart?: string;
-    dayEnd?: string;
-    defaultDependencyMinimumBreakLength?: number;
+    dayStart: string;
+    dayEnd: string;
+    potentialCenter?: string;
     defaultGroupMinimumBreakLength?: number;
     defaultEventMinimumBreakLength?: number;
-    potentialCenter?: string;
-    defaultEventDensity?: number;
-    defaultEventDurationVariance?: number;
-    defaultMaxNumWorkingHours?: number | boolean;
-    defaultMaxNumDailyWorkingHours?: number | boolean;
+    defaultDependencyMinimumBreakLength?: number;
+    defaultMaxNumWorkingHours?: number | boolean | any;
+    defaultMaxNumDailyWorkingHours?: number | boolean | any;
     defaultDayRank?: number;
-    defaultDependencyRank?: number;
     defaultGroupRank?: number;
+    defaultDependencyRank?: number;
+    defaultEventDensity?: number;
     defaultEventWeight?: number;
     defaultGroupWeight?: number;
     defaultCourseWeight?: number;
-    defaultLunch?: Pick<LockedTime, 'intervals' | 'duration' | 'durationVariance'>[];
+    defaultEventDurationVariance?: number;
+    defaultLunch?: Edge<LockedTime[]>;
 }
 export interface DivisionSettings extends DivisionSettingsBare {
     _id?: Types.ObjectId;

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

@@ -1,5 +1,6 @@
 import { Types } from 'mongoose';
 import moment from 'moment';
+import { Edge } from './common';
 import { Area } from './areas';
 import { Course } from './courses';
 import { CourseEvent } from './course-events';
@@ -8,25 +9,30 @@ import { Group } from './groups';
 import { Location } from './locations';
 import { LockedTime } from './locked-times';
 import { OverlapGroup } from './overlap-groups';
+import { Person } from './persons';
 import { Teacher } from './teachers';
 import { Meta } from './meta';
-export interface DivisionBare {
-    displayName?: string;
+export interface VirtualDivisionFields {
     groups?: Group[];
     teachers?: Teacher[];
     locations?: Location[];
+    courses?: Course[];
     events?: CourseEvent[];
+    persons?: Person[];
     overlapGroups?: OverlapGroup[];
-    courses?: Course[];
     lockedTimes?: LockedTime[];
     area?: Area;
+}
+export interface DivisionBare {
+    settings?: Edge<DivisionSettings>;
+    displayName?: string;
     start?: moment.Moment | string | Date;
     end?: moment.Moment | string | Date;
-    settings?: DivisionSettings;
+    editedAt?: moment.Moment | string | Date;
     createdAt?: string;
     meta?: Meta;
 }
-export interface Division extends DivisionBare {
+export interface Division extends DivisionBare, VirtualDivisionFields {
     _id?: Types.ObjectId;
     id?: string;
 }

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

@@ -1,11 +1,12 @@
 import { Types } from 'mongoose';
+import { Edge } from './common';
 import { Division } from './divisions';
 import { BreakLength } from './break-lengths';
 import { LockedTime } from './locked-times';
 import { Interval } from './intervals';
 import { Day } from './days';
 export interface GroupBare {
-    belongsTo?: Division;
+    belongsTo?: Edge<Division>;
     ids?: string;
     displayName?: string;
     minBreakLength?: BreakLength;
@@ -14,8 +15,9 @@ export interface GroupBare {
     forbidOverlappingEvents?: boolean;
     disableDayLengthPunishment?: boolean;
     weight?: number;
-    lockedTimes?: LockedTime[];
-    lunch?: LockedTime[] | null;
+    rank?: number;
+    lockedTimes?: Edge<LockedTime[]>;
+    lunch?: Edge<LockedTime[]>;
     intervals?: Interval[];
     days?: Day[];
     createdAt?: string;

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

@@ -1,10 +1,8 @@
 import { Types } from 'mongoose';
 import moment from 'moment';
-import { Division } from './divisions';
 export interface IntervalBare {
-    belongsTo?: Division;
-    start?: moment.Moment | string;
-    end?: moment.Moment | string;
+    start?: moment.Moment | string | Date;
+    end?: moment.Moment | string | Date;
     day?: number;
     type?: string;
 }

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

@@ -1,15 +1,18 @@
 import { Types } from 'mongoose';
+import { Edge } from './common';
 import { Division } from './divisions';
 import { LockedTime } from './locked-times';
 import { Interval } from './intervals';
 import { Day } from './days';
 export interface LocationBare {
-    belongsTo?: Division;
+    belongsTo?: Edge<Division>;
     ids?: string;
-    displayName?: string;
+    rank?: number;
     seats?: number;
-    lockedTimes?: LockedTime[];
-    lunch?: LockedTime[];
+    displayName?: string;
+    text?: string;
+    lockedTimes?: Edge<LockedTime[]>;
+    lunch?: Edge<LockedTime[]>;
     intervals?: Interval[];
     days?: Day[];
     area?: string;

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

@@ -1,22 +1,31 @@
 import { Types } from 'mongoose';
 import moment from 'moment';
+import { Edge } from './common';
+import { Coalesced } from './common/coalesced';
 import { Division } from './divisions';
 import { Interval } from './intervals';
-import { Coalesced } from './common/coalesced';
+import { Day } from './days';
+import { Teacher } from './teachers';
+import { Course } from './courses';
+import { CourseEvent } from './course-events';
+import { Person } from './persons';
+import { Location } from './locations';
 export interface LockedTimeBare {
-    belongsTo?: Division;
+    belongsTo?: Edge<Division>;
     displayName?: string;
-    start?: moment.Moment | string;
-    end?: moment.Moment | string;
+    color?: string;
+    type?: 'LUNCH' | 'ANY';
+    start?: moment.Moment | Date | string;
+    end?: moment.Moment | Date | string;
     visible?: boolean;
     parked?: boolean;
-    day?: number;
-    coalesced?: Coalesced[];
     duration?: number;
     durationVariance?: number;
+    coalesced?: Coalesced<Teacher | Course | CourseEvent | Location | Person>[];
     intervals?: Interval[];
+    days?: Day[];
     createdAt?: string;
-    type?: 'LUNCH' | 'ANY';
+    updatedAt?: string;
     lastModifiedBy?: unknown;
 }
 export interface LockedTime extends LockedTimeBare {

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

@@ -1,14 +1,18 @@
 import { Types } from 'mongoose';
+import { Edge } from './common';
 import { Division } from './divisions';
 import { Coalesced } from './common/coalesced';
+import { Course } from './courses';
+import { CourseEvent } from './course-events';
 export interface OverlapGroupBare {
-    belongsTo?: Division | Types.ObjectId;
+    belongsTo?: Edge<Division>;
     ids?: string;
-    coalesced?: Coalesced[];
-    species?: (Coalesced & {
+    coalesced?: Coalesced<Course>[];
+    species?: (Coalesced<CourseEvent> & {
         id?: string;
     })[];
     createdAt?: string;
+    updatedAt?: string;
     lastModifiedBy?: unknown;
 }
 export interface OverlapGroup extends OverlapGroupBare {

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

@@ -0,0 +1,19 @@
+import { Types } from 'mongoose';
+import { Edge } from './common';
+import { Division } from './divisions';
+import { LockedTime } from './locked-times';
+export interface PersonBare {
+    belongsTo?: Edge<Division>;
+    ids?: string;
+    displayName?: string;
+    lastname?: string;
+    firstname?: string;
+    lockedTimes?: Edge<LockedTime[]>;
+    lunch?: Edge<LockedTime[]>;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface Person extends PersonBare {
+    _id?: Types.ObjectId;
+    id?: string;
+}

package/dist/core/types/persons.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=persons.js.map

package/dist/core/types/persons.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"persons.js","mappings":"","names":[],"sourceRoot":"","sources":[],"sourcesContent":[]}

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

@@ -1,11 +1,12 @@
 import { Types } from 'mongoose';
+import { Edge } from './common';
 import { Division } from './divisions';
 import { BreakLength } from './break-lengths';
 import { LockedTime } from './locked-times';
 import { Interval } from './intervals';
 import { Day } from './days';
 export interface TeacherBare {
-    belongsTo?: Division;
+    belongsTo?: Edge<Division>;
     ids?: string;
     displayName?: string;
     lastname?: string;
@@ -16,8 +17,8 @@ export interface TeacherBare {
     forbidOverlappingEvents?: boolean;
     disableDayLengthPunishment?: boolean;
     weight?: number;
-    lockedTimes?: LockedTime[];
-    lunch?: LockedTime[] | null;
+    lockedTimes?: Edge<LockedTime[]>;
+    lunch?: Edge<LockedTime[]>;
     intervals?: Interval[];
     days?: Day[];
     rank?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@royalschedule/maps",
-  "version": "2.2.77",
+  "version": "2.2.79",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",