@royalschedule/maps 4.0.32 → 4.1.0-beta.0

package/dist/core/interfaces/other/companies.mjs

@@ -0,0 +1,9 @@
+//#region src/core/interfaces/other/companies.ts
+const INACTIVITY_ACTIONS = {
+	REFRESH: "refresh",
+	LOGOUT: "logout"
+};
+
+//#endregion
+export { INACTIVITY_ACTIONS };
+//# sourceMappingURL=companies.mjs.map

package/dist/core/interfaces/other/companies.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"companies.mjs","names":[],"sources":["../../../../src/core/interfaces/other/companies.ts"],"sourcesContent":["import type { Partner, IntegrationTypes, OrganizationType, Theme, SamlProvider } from './etc';\nimport type { PlannedScheduledDuration } from '../vertices/properties/planned-scheduled-duration';\nimport type { MaximumScheduleSpan } from '../vertices/properties/maximum-schedule-span';\nimport type { PublicId } from '../vertices/properties';\n\n\ntype Identifier = {\n  value:   string;\n  type:    'VAT' | 'SchoolCode' | 'MunicipalityCode' | 'SchoolSoft' | 'Sdui' | 'Edlevo' | 'Edaktus';\n  country: string;\n};\n\ntype AppFeature = {\n  substitutionPlanner?: {\n    enabled: boolean;\n  };\n  statisticsModule?: {\n    /**\n     * Enables the whole statistics module.\n     */\n    enabled?: boolean;\n\n    scb?:             boolean;\n    lunchCongestion?: boolean;\n  };\n  includeStepGuide?: boolean;\n};\n\nexport type Address = {\n  type:           string; // Type of address (e.g., home, work, etc.)\n  streetAddress:  string; // Street address (e.g., 123 Main St)\n  addressLine2?:  string; // Optional second line of the address (e.g., Apt 4B)sss\n  addressLine3?:  string; // Optional third line of the address\n  postalCode:     string; // Postal code (e.g., 12345)\n  locality:       string; // City or locality (e.g., New York)\n  state?:         string; // Optional state or province (e.g., NY)\n  region?:        string; // Optional region (e.g., Northeast)\n  country:        string; // Country (e.g., USA)\n  geoCoordinates: {\n    latitude:  string;\n    longitude: string;\n  };\n};\n\nexport type TimeRosterSection = {\n  start: string; // In HH:mm format\n  end:   string; // In HH:mm format\n  id:    string;\n  name:  string;\n};\n\nexport type PublicConfig = {\n  filters: {\n    groups:      boolean;\n    teachers:    boolean;\n    inLocations: boolean;\n    tags:        boolean;\n    subjects:    boolean;\n    subGroups:   boolean;\n  };\n  showTeacherWorkingHours: boolean;\n  multipleSelection:       boolean;\n  timeFilters: {\n    all:     boolean;\n    periods: boolean;\n  };\n  lockedTimes: boolean;\n};\n\nexport type AutoSyncConfig = {\n  enabled:       boolean;\n  integration?:  IntegrationTypes;\n  weekdaysOnly?: boolean;\n  time?:         string;\n};\n\nexport const INACTIVITY_ACTIONS = {\n  REFRESH: 'refresh',\n  LOGOUT:  'logout',\n} as const;\nexport type InactivityAction =\n  (typeof INACTIVITY_ACTIONS)[keyof typeof INACTIVITY_ACTIONS];\n\nexport type InactivitySettings = {\n  /**\n   * In units of minutes\n   */\n  time:   number;\n  action: InactivityAction;\n};\n\nexport type GlobalDefaultValues = {\n  dayStart:                             string;\n  dayEnd:                               string;\n  numDays:                              number;\n  potentialCenter?:                     string;\n  defaultGroupMinimumBreakLength?:      number;\n  defaultEventMinimumBreakLength?:      number;\n  defaultDependencyMinimumBreakLength?: number;\n  defaultPlannedScheduledDuration?:     PlannedScheduledDuration;\n  defaultMaximumScheduleSpan?:          MaximumScheduleSpan;\n  defaultEventDurationVariance?:        number;\n};\n\nexport namespace Company {\n  export type core = {\n    readonly id:        PublicId;\n    associatedPartner?: Partner | null;\n    createdAt?:         string;\n  };\n\n  type optionals = {\n    name?:       string;\n    logo?:       string; // URL to the company's logo\n    timezone?:   string;\n    environment: {\n      theme?:              Theme;\n      organizationType?:   OrganizationType;\n      appFeatures?:        AppFeature;\n      canCreateCompanies?: boolean;\n    };\n    identifiers:      Identifier[];\n    addresses:        Address[];\n    constituentTypes: string[];\n    samlProviders?:   SamlProvider[];\n    publicSettings?:  PublicConfig;\n    autoSync?:        AutoSyncConfig;\n    organization?: {\n      name?:               string;\n      logo?:               string;\n      inactivitySettings?: InactivitySettings;\n      constituentTypes?:   string[];\n      environment?:        Company.complete['environment'];\n    };\n    inactivitySettings?:  InactivitySettings;\n    timeRoster?:          TimeRosterSection[];\n    globalDefaultValues?: GlobalDefaultValues;\n  };\n\n  export type complete = core & optionals;\n}\n"],"mappings":";AA4EA,MAAa,qBAAqB;CAChC,SAAS;CACT,QAAS;CACV"}

package/dist/core/interfaces/other/etc.d.mts

@@ -0,0 +1,19 @@
+import { Moment } from "moment";
+
+//#region src/core/interfaces/other/etc.d.ts
+type DateType = Moment | string | Date;
+type Partner = 'schoolsoft' | 'sdui' | 'additio' | 'pupil' | 'konecto';
+type OrganizationType = 'school' | 'sports_facility';
+type Theme = 'royal_schedule' | 'schoolsoft' | 'sdui' | 'additio' | 'pupil' | 'konecto';
+type IntegrationTypes = 'Admentum' | 'Gotit' | 'Infomentor' | 'Adelaskola' | 'SchoolSoft' | 'vKlass' | 'IST' | 'Quiculum' | 'Meitner' | 'Sdui' | 'Additio' | 'Pupil' | 'Konecto' | 'Edlevo' | 'Unikum' | 'Edaktus';
+type SamlProvider = 'microsoft';
+type Access = {
+  CREATE: 'create';
+  READ: 'read';
+  UPDATE: 'update';
+  DELETE: 'delete';
+};
+type Role = 'admin' | 'partner' | 'administrator' | 'unrestricted' | 'restricted' | 'demo';
+//#endregion
+export { Access, DateType, IntegrationTypes, OrganizationType, Partner, Role, SamlProvider, Theme };
+//# sourceMappingURL=etc.d.mts.map

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

@@ -0,0 +1,6 @@
+import { Address, AutoSyncConfig, Company, GlobalDefaultValues, INACTIVITY_ACTIONS, InactivityAction, InactivitySettings, PublicConfig, TimeRosterSection } from "./companies.mjs";
+import { Integration } from "./integrations.mjs";
+import { User } from "./users.mjs";
+import { Action, Policy, Statement } from "./policies.mjs";
+import { Operation, OperationType, operationType } from "./operations.mjs";
+import { ErrorCode, SyncLog } from "./sync-logs.mjs";

package/dist/core/interfaces/other/integrations.d.mts

@@ -0,0 +1,17 @@
+import { IntegrationTypes } from "./etc.mjs";
+import { PublicId } from "../vertices/properties/index.mjs";
+import { Moment } from "moment";
+
+//#region src/core/interfaces/other/integrations.d.ts
+interface Integration {
+  id: PublicId;
+  active?: boolean;
+  key?: string | string[] | any;
+  integrationType?: IntegrationTypes;
+  description?: string;
+  usedAt?: Moment | Date | string;
+  status?: 'PENDING' | 'APPROVED' | 'REJECTED';
+}
+//#endregion
+export { Integration };
+//# sourceMappingURL=integrations.d.mts.map

package/dist/core/interfaces/other/operations.d.mts

@@ -0,0 +1,36 @@
+import { RealCollection } from "../vertices/util/vertex.mjs";
+import "../vertices/util/index.mjs";
+import { IntegrationTypes } from "./etc.mjs";
+import { Company } from "./companies.mjs";
+import { User } from "./users.mjs";
+import { Deep } from "../vertices/index.mjs";
+
+//#region src/core/interfaces/other/operations.d.ts
+type Status = 'COMPLETED' | 'FAILED' | 'STARTED' | 'PENDING' | 'CANCELED' | 'RESOLVED' | 'IN_PROGRESS';
+declare const operationType: readonly ["IMPORT", "EXPORT", "UPDATE", "MIGRATION", "MUTATE", "RESTORE_BACKUP", "SYNC", "SYSTEM_MAINTENANCE"];
+type OperationType = typeof operationType[number];
+interface Operation {
+  organization?: Company.complete;
+  id?: string;
+  belongsTo?: Deep.Division;
+  createdBy?: User;
+  integrationType?: IntegrationTypes;
+  status?: Status;
+  type?: OperationType;
+  error?: {
+    message: string;
+    stack: string;
+    code: number;
+    data: any;
+  };
+  updatedAt?: Date;
+  createdAt?: Date;
+  expiresAt?: string;
+  deltaStats?: {
+    coll: RealCollection;
+    count: number;
+  }[];
+}
+//#endregion
+export { Operation, OperationType, operationType };
+//# sourceMappingURL=operations.d.mts.map

package/dist/core/interfaces/other/policies.d.mts

@@ -0,0 +1,31 @@
+import { Access } from "./etc.mjs";
+import { PublicId } from "../vertices/properties/index.mjs";
+import { Company } from "./companies.mjs";
+import { User } from "./users.mjs";
+import { Deep } from "../vertices/index.mjs";
+
+//#region src/core/interfaces/other/policies.d.ts
+interface Action {
+  targetResourceModel?: string;
+  operation: (Access['CREATE'] | Access['READ'] | Access['UPDATE'] | Access['DELETE'])[];
+}
+interface Statement {
+  resource: Pick<Company.complete, 'name' | 'id'> | Pick<Deep.Division, 'displayName' | 'id'>;
+  resourceModel: string;
+  action: Action;
+  effect: boolean;
+}
+interface Policy {
+  id?: PublicId;
+  users?: User[];
+  inline?: boolean;
+  organization?: Company.complete;
+  displayName?: string;
+  description?: string;
+  statements?: Statement[];
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+//#endregion
+export { Action, Policy, Statement };
+//# sourceMappingURL=policies.d.mts.map

package/dist/core/interfaces/other/sync-logs.d.mts

@@ -0,0 +1,21 @@
+//#region src/core/interfaces/other/sync-logs.d.ts
+declare enum ErrorCode {
+  CONFIG_ERROR = "CONFIG_ERROR",
+  AUTHENTICATION_ERROR = "AUTHENTICATION_ERROR",
+  API_ERROR = "API_ERROR",
+  DATA_ERROR = "DATA_ERROR",
+  THIRD_PARTY_ERROR = "THIRD_PARTY_ERROR",
+  UNKNOWN_ERROR = "UNKNOWN_ERROR"
+}
+type Collection = 'courses' | 'teachers' | 'groups' | 'persons' | 'locations' | 'syllabuses';
+interface SyncLog {
+  status: 'success' | 'error';
+  message?: string;
+  errorCode?: ErrorCode;
+  createdAt: Date;
+  divisionIds: string[];
+  imported?: Partial<{ [key in Collection]: number }>;
+}
+//#endregion
+export { ErrorCode, SyncLog };
+//# sourceMappingURL=sync-logs.d.mts.map

package/dist/core/interfaces/other/users.d.mts

@@ -0,0 +1,35 @@
+import { Partner, Role } from "./etc.mjs";
+import { PublicId } from "../vertices/properties/index.mjs";
+import { Company } from "./companies.mjs";
+
+//#region src/core/interfaces/other/users.d.ts
+declare namespace User {
+  export type core = {
+    readonly id: PublicId;
+    username: string;
+    role: Role;
+    associatedPartner?: Partner | null;
+  };
+  type optionals = {
+    createdAt?: string;
+    verifyToken?: string;
+    company?: {
+      id: string;
+      name: string;
+    };
+  };
+  export type serialized = core & optionals & {};
+  export type shallow = core & optionals & {};
+  export type populated = core & optionals & {};
+  export {};
+}
+interface User {
+  id?: PublicId;
+  username?: string;
+  role: Role;
+  timestamps?: string[];
+  company?: Pick<Company.complete, 'id' | 'name'>;
+}
+//#endregion
+export { User };
+//# sourceMappingURL=users.d.mts.map

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

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

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

@@ -0,0 +1,58 @@
+import { VertexFactory } from "./util/vertex.mjs";
+import { Coalesced, EdgeWrapper } from "./util/edges.mjs";
+import "./util/index.mjs";
+import { DivisionVertex } from "./divisions.mjs";
+import { UserVertex } from "./users.mjs";
+import { CompanyVertex } from "./companies.mjs";
+
+//#region src/core/interfaces/vertices/configurations.d.ts
+type ConfigurationType = 'filter' | 'template' | 'rule';
+interface ConfigurationMetadata {
+  active: boolean;
+  version: string;
+  tags: {
+    value: string;
+    type?: string;
+  }[];
+}
+type Base = {
+  domain?: EdgeWrapper<'array', Coalesced.Edge<DivisionVertex> | Coalesced.Edge<CompanyVertex>>;
+  type: ConfigurationType;
+  metadata: ConfigurationMetadata;
+  lastModifiedBy?: UserVertex;
+  data?: any;
+  displayName?: string;
+  description?: string;
+  category?: string;
+  enabled?: boolean;
+};
+type ConfigurationVertex = VertexFactory<'configurations', Base>;
+type ConfigurationFilterVertex = VertexFactory<'configurations', Base & {
+  type: 'filter';
+  data: any;
+  displayName: string;
+  description?: string;
+}>;
+type ConfigurationTemplateVertex = VertexFactory<'configurations', Base & {
+  type: 'template';
+  data: {
+    layout: any;
+    defaultValues?: any;
+    validation?: any;
+  };
+  displayName: string;
+  category?: string;
+}>;
+type ConfigurationRuleVertex = VertexFactory<'configurations', Base & {
+  type: 'rule';
+  data: {
+    conditions?: Array<any>;
+    actions?: Array<any>;
+    priority?: number;
+  };
+  displayName: string;
+  enabled?: boolean;
+}>;
+//#endregion
+export { ConfigurationFilterVertex, ConfigurationRuleVertex, ConfigurationTemplateVertex, ConfigurationVertex };
+//# sourceMappingURL=configurations.d.mts.map

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

@@ -0,0 +1,66 @@
+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 { EventVertex } from "./events.mjs";
+import { OverlapGroupVertex } from "./overlap-groups.mjs";
+import { SyllabusVertex } from "./syllabuses.mjs";
+import { ExceptionVertex } from "./exceptions.mjs";
+import { GroupVertex } from "./groups.mjs";
+import { LockedTimeVertex } from "./locked-times.mjs";
+import { TeacherVertex } from "./teachers.mjs";
+
+//#region src/core/interfaces/vertices/courses.d.ts
+type CourseVertex = VertexFactory<'courses', BelongsTo & {
+  tags?: Tag[];
+  subject?: string;
+  color?: string;
+  minBreakLength?: MinBreakLength;
+  /**
+   * @note an empty array is the same as undefined
+   */
+  intervals?: Interval[];
+  days?: Day[];
+  eventDurationVariance?: number;
+  centerOfAttraction?: string | null;
+  density?: number;
+  weight?: number;
+  type?: string;
+  /**
+   * Can be one of the following formats:
+   * - X hrs
+   * - Y min/week
+   */
+  plannedDuration?: string; /** @deprecated replaced by plannedDuration? */
+  minutesPerWeek?: number; /** @deprecated replaced by plannedDuration? */
+  expectedTotalHours?: number;
+  period?: EdgeWrapper<'single', Plain.Edge<PeriodVertex>>;
+  overlapGroup?: EdgeWrapper<'single', Plain.Edge<OverlapGroupVertex>>;
+  syllabus?: EdgeWrapper<'single', Plain.Edge<SyllabusVertex>>;
+  lockedTimes?: EdgeWrapper<'array', Plain.Edge<LockedTimeVertex>>;
+  exceptions?: EdgeWrapper<'array', Plain.Edge<ExceptionVertex>>;
+  events?: EdgeWrapper<'array', Plain.Edge<EventVertex>>;
+  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;
+  }>>;
+}>;
+//#endregion
+export { CourseVertex };
+//# sourceMappingURL=courses.d.mts.map

package/dist/core/interfaces/vertices/division-settings.d.mts

@@ -0,0 +1,54 @@
+import { VertexFactory } from "./util/vertex.mjs";
+import { EdgeWrapper, Plain } from "./util/edges.mjs";
+import "./util/index.mjs";
+import { MaximumScheduleSpan } from "./properties/maximum-schedule-span.mjs";
+import { PlannedScheduledDuration } from "./properties/planned-scheduled-duration.mjs";
+import { PeriodVertex } from "./periods.mjs";
+import { RootIntervalVertex } from "./root-intervals.mjs";
+import { BelongsTo } from "./properties/belongs-to.mjs";
+import { Moment } from "moment";
+
+//#region src/core/interfaces/vertices/division-settings.d.ts
+type CalendarException = {
+  start: string | Moment;
+  end: string | Moment;
+  description?: string;
+};
+interface ExceptionsConfig {
+  requireAbsenceReason: boolean;
+  constrictAbsenceReason: boolean;
+  absenceReasons: string[];
+  suggestionRanking: Record<string, number>;
+}
+type DivisionSettingsVertex = VertexFactory<'settings', BelongsTo & {
+  numDays: number;
+  dayStart: string;
+  dayEnd: string;
+  discretization: number;
+  potentialCenter: string;
+  defaultEventMinimumBreakLength?: number;
+  defaultGroupMinimumBreakLength?: number;
+  defaultDependencyMinimumBreakLength?: number; /** @deprecated replaced by defaultMaximumScheduleSpan */
+  defaultMaxNumWorkingHours?: number | null; /** @deprecated replaced by defaultMaximumScheduleSpan */
+  defaultMaxNumDailyWorkingHours?: number | null;
+  defaultPlannedScheduledDuration?: PlannedScheduledDuration;
+  defaultMaximumScheduleSpan?: MaximumScheduleSpan;
+  defaultDayRank?: number;
+  defaultDependencyRank?: number;
+  defaultGroupRank?: number;
+  defaultEventDensity?: number;
+  defaultEventWeight?: number;
+  defaultGroupWeight?: number; /** @deprecated no longer needed */
+  defaultCourseWeight?: number;
+  calendarExceptions?: CalendarException[];
+  defaultEventDurationVariance?: number;
+  eventTime?: number;
+  eventTimeActive?: boolean;
+  requireForcedOverlappingEventsSets?: boolean;
+  exceptionsConfig?: ExceptionsConfig;
+  period?: EdgeWrapper<'single', Plain.Edge<PeriodVertex>>;
+  defaultRootInterval?: EdgeWrapper<'single', Plain.Edge<RootIntervalVertex>>;
+}>;
+//#endregion
+export { CalendarException, DivisionSettingsVertex };
+//# sourceMappingURL=division-settings.d.mts.map

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

@@ -0,0 +1,31 @@
+import { VertexFactory } from "./util/vertex.mjs";
+import { EdgeWrapper, Plain } from "./util/edges.mjs";
+import "./util/index.mjs";
+import { DateType, Partner } from "../other/etc.mjs";
+import { DivisionSettingsVertex } from "./division-settings.mjs";
+import { GenerationVertex } from "./generations.mjs";
+
+//#region src/core/interfaces/vertices/divisions.d.ts
+type StepGuideProgress = {
+  checked: string[];
+  completed: boolean;
+  updatedAt: Date | null;
+};
+type DivisionVertex = VertexFactory<'divisions', {
+  associatedPartner?: Partner | null;
+  start: DateType;
+  end: DateType;
+  published?: boolean;
+  createdAt?: string;
+  updatedAt?: string;
+  syncedAt?: string | number | Date;
+  selected?: boolean;
+  autoSync?: boolean;
+  stepGuideProgress?: StepGuideProgress;
+  pinned?: boolean;
+  settings?: EdgeWrapper<'single', Plain.Edge<DivisionSettingsVertex>>;
+  running?: EdgeWrapper<'single', Plain.Edge<GenerationVertex>>;
+}>;
+//#endregion
+export { DivisionVertex, StepGuideProgress };
+//# sourceMappingURL=divisions.d.mts.map

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

@@ -0,0 +1,104 @@
+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 { OverlapGroupVertex } from "./overlap-groups.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>>;
+  overlapSpecies?: EdgeWrapper<'single', Plain.Edge<OverlapGroupVertex>>;
+  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>>;
+}>;
+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>>;
+  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;
+  }>>;
+}>;
+//#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