@royalschedule/maps 4.1.0-beta.0 → 4.1.1-beta.0

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

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

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

@@ -0,0 +1,17 @@
+import { IntegrationTypes } from "./etc.js";
+import { PublicId } from "../vertices/properties/index.js";
+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.ts.map

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

@@ -0,0 +1,35 @@
+import { RealCollection } from "../vertices/util/vertex.js";
+import { IntegrationTypes } from "./etc.js";
+import { Company } from "./companies.js";
+import { User } from "./users.js";
+import { Deep } from "../vertices/index.js";
+
+//#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.ts.map

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

@@ -0,0 +1,31 @@
+import { Access } from "./etc.js";
+import { PublicId } from "../vertices/properties/index.js";
+import { Company } from "./companies.js";
+import { User } from "./users.js";
+import { Deep } from "../vertices/index.js";
+
+//#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.ts.map

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

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

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

@@ -0,0 +1,35 @@
+import { Partner, Role } from "./etc.js";
+import { PublicId } from "../vertices/properties/index.js";
+import { Company } from "./companies.js";
+
+//#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.ts.map

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

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

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

@@ -0,0 +1,57 @@
+import { VertexFactory } from "./util/vertex.js";
+import { Coalesced, EdgeWrapper } from "./util/edges.js";
+import { DivisionVertex } from "./divisions.js";
+import { UserVertex } from "./users.js";
+import { CompanyVertex } from "./companies.js";
+
+//#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.ts.map

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

@@ -0,0 +1,67 @@
+import { VertexFactory } from "./util/vertex.js";
+import { AvailableLocation, EdgeWrapper, GroupWithExclude, Plain, Wrapped } from "./util/edges.js";
+import { Day } from "./properties/days.js";
+import { Interval } from "./properties/intervals.js";
+import { Tag } from "./properties/tags.js";
+import { MinBreakLength } from "./properties/min-break-length.js";
+import { PeriodVertex } from "./periods.js";
+import { BelongsTo } from "./properties/belongs-to.js";
+import { PersonVertex } from "./persons.js";
+import { LocationVertex } from "./locations.js";
+import { EventVertex } from "./events.js";
+import { OverlapGroupVertex } from "./overlap-groups.js";
+import { SyllabusVertex } from "./syllabuses.js";
+import { ExceptionVertex } from "./exceptions.js";
+import { GroupVertex } from "./groups.js";
+import { LockedTimeVertex } from "./locked-times.js";
+import { TeacherVertex } from "./teachers.js";
+
+//#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.ts.map

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

@@ -0,0 +1,56 @@
+import { VertexFactory } from "./util/vertex.js";
+import { EdgeWrapper, Plain } from "./util/edges.js";
+import { MaximumScheduleSpan } from "./properties/maximum-schedule-span.js";
+import { PlannedScheduledDuration } from "./properties/planned-scheduled-duration.js";
+import { PeriodVertex } from "./periods.js";
+import { RootIntervalVertex } from "./root-intervals.js";
+import { BelongsTo } from "./properties/belongs-to.js";
+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.ts.map

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

@@ -0,0 +1,30 @@
+import { VertexFactory } from "./util/vertex.js";
+import { EdgeWrapper, Plain } from "./util/edges.js";
+import { DateType, Partner } from "../other/etc.js";
+import { DivisionSettingsVertex } from "./division-settings.js";
+import { GenerationVertex } from "./generations.js";
+
+//#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.ts.map

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

@@ -0,0 +1,104 @@
+import { VertexFactory } from "./util/vertex.js";
+import { AvailableLocation, EdgeWrapper, GroupWithExclude, Plain, Wrapped } from "./util/edges.js";
+import { Day } from "./properties/days.js";
+import { Interval } from "./properties/intervals.js";
+import { Tag } from "./properties/tags.js";
+import { MinBreakLength } from "./properties/min-break-length.js";
+import { PeriodVertex } from "./periods.js";
+import { BelongsTo } from "./properties/belongs-to.js";
+import { PersonVertex } from "./persons.js";
+import { LocationVertex } from "./locations.js";
+import { LinkedEventsSetVertex } from "./linked-events-sets.js";
+import { ThreadVertex } from "./threads.js";
+import { OverlapGroupVertex } from "./overlap-groups.js";
+import { CourseVertex } from "./courses.js";
+import { ExceptionVertex } from "./exceptions.js";
+import { GroupVertex } from "./groups.js";
+import { LockedTimeVertex } from "./locked-times.js";
+import { TeacherVertex } from "./teachers.js";
+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;
+  }>>;
+  linkedEventsSet?: EdgeWrapper<'single', Plain.Edge<LinkedEventsSetVertex>>;
+}>;
+//#endregion
+export { CalendarEventVertex, EventVertex, ScheduleEventVertex };
+//# sourceMappingURL=events.d.ts.map

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

@@ -0,0 +1,73 @@
+import { Collection, Vertex, VertexFactory } from "./util/vertex.js";
+import { Coalesced, EdgeWrapper, Plain } from "./util/edges.js";
+import { PersonVertex } from "./persons.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 { Deep } from "./index.js";
+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.ts.map

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

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

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

@@ -0,0 +1,52 @@
+import { VertexFactory } from "./util/vertex.js";
+import { EdgeWrapper, Plain, Wrapped } from "./util/edges.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 { 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/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.ts.map