@royalschedule/maps 4.0.30 → 4.0.32

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

@@ -5,51 +5,55 @@ import { EdgeMultiplicity } from "./edges.js";
 /**
  * Similar to O[K], but does not require K to be a key of O. Extracts the property K from each member of the possible union types in U.
  */
-type GetByKey<O, K$1 extends keyof any> = O extends { [P in K$1]: infer T } ? T : O extends { [P in K$1]?: infer T } ? T | undefined : never;
+type GetByKey<O, K extends keyof any> = O extends { [P in K]: infer T } ? T : O extends { [P in K]?: infer T } ? T | undefined : never;
 /**
  * keyof { a1: ..., a2: ..., ... } | { b1: ..., b2: ..., ... } | ... => 'a1' | 'a2' | ... | 'b1' | 'b2' | ...
  */
-type AllKeys<U$1> = U$1 extends any ? keyof U$1 : never;
+type AllKeys<U> = U extends any ? keyof U : never;
 declare namespace MakeMixedNs {
-  type ExtractArrayType<T$1> = T$1 extends Array<any> ? T$1 : never;
-  type ExtractObjectType<T$1> = T$1 extends Array<any> ? never : T$1 extends object ? T$1 : never;
-  type _MakeMixedArray<T$1 extends any[]> = [T$1] extends [never] ? never : (T$1 extends Array<infer U> ? U : never) extends infer U ? Array<MakeMixed<U>> : never;
-  type _MakeMixedObject<T$1 extends object> = [T$1] extends [never] ? never : { [K in AllKeys<T$1>]: MakeMixed<GetByKey<T$1, K>> };
-  export type MakeMixed<T$1> = (ExtractArrayType<T$1> extends (infer V extends any[]) ? _MakeMixedArray<V> : never) | (ExtractObjectType<T$1> extends (infer V extends object) ? _MakeMixedObject<V> : never) | (T$1 extends object ? never : T$1);
+  type ExtractArrayType<T> = T extends Array<any> ? T : never;
+  type ExtractObjectType<T> = T extends Array<any> ? never : T extends object ? T : never;
+  type _MakeMixedArray<T extends any[]> = [T] extends [never] ? never : (T extends Array<infer U> ? U : never) extends infer U ? Array<MakeMixed<U>> : never;
+  type _MakeMixedObject<T extends object> = [T] extends [never] ? never : { [K in AllKeys<T>]: MakeMixed<GetByKey<T, K>> };
+  export type MakeMixed<T> = (ExtractArrayType<T> extends (infer V extends any[]) ? _MakeMixedArray<V> : never) | (ExtractObjectType<T> extends (infer V extends object) ? _MakeMixedObject<V> : never) | (T extends object ? never : T);
   export {};
 }
 /**
  * Merges a union of types into a single type by combining properties of object types and merging array element types.
  */
-type MakeMixed<T$1> = MakeMixedNs.MakeMixed<T$1>;
+type MakeMixed<T> = MakeMixedNs.MakeMixed<T>;
 /**
  * Deep partial type that allows for partial properties at any level of nesting.
  */
-type DeepPartial<T$1> = T$1 extends Array<infer U> ? Array<DeepPartial<U>> : T$1 extends object ? { [K in keyof T$1]?: DeepPartial<T$1[K]> } : T$1;
+type DeepPartial<T> = T extends Array<infer U> ? Array<DeepPartial<U>> : T extends object ? { [K in keyof T]?: DeepPartial<T[K]> } : T;
 /**
  * A deep version of NonNullable<T> that recursively removes null and undefined from all properties and nested properties.
  */
-type DeepNonNullable<T$1> = T$1 extends any ? T$1 extends ((...args: any[]) => any) ? T$1 : T$1 extends Array<infer U> ? Array<DeepNonNullable<NonNullable<U>>> : T$1 extends object ? { [K in keyof T$1]-?: DeepNonNullable<NonNullable<T$1[K]>> } : NonNullable<T$1> : never;
-type _IsUnion<T$1, U$1 = T$1> = T$1 extends any ? [U$1] extends [T$1] ? false : true : never;
+type DeepNonNullable<T> = T extends any ? T extends ((...args: any[]) => any) ? T : T extends Array<infer U> ? Array<DeepNonNullable<NonNullable<U>>> : T extends object ? { [K in keyof T]-?: DeepNonNullable<NonNullable<T[K]>> } : NonNullable<T> : never;
+type _IsUnion<T, U = T> = T extends any ? [U] extends [T] ? false : true : never;
 /**
  * Lets a type pass if it is a union type, otherwise returns `never`.
  */
-type IsUnion<T$1> = _IsUnion<T$1> extends true ? T$1 : never;
+type IsUnion<T> = _IsUnion<T> extends true ? T : never;
+/**
+ * Lets a type pass if it is not a union type, otherwise returns `never`.
+ */
+
 /**
  * Returns never if any type in the tuple is a union, otherwise returns the tuple.
  */
-type NoneIsUnion<T$1 extends any[]> = AnyUnion<T$1> extends true ? never : T$1;
-type AnyUnion<T$1 extends any[]> = T$1 extends [infer Head, ...infer Tail] ? _IsUnion<Head> extends true ? true : AnyUnion<Tail extends any[] ? Tail : []> : false;
+type NoneIsUnion<T extends any[]> = AnyUnion<T> extends true ? never : T;
+type AnyUnion<T extends any[]> = T extends [infer Head, ...infer Tail] ? _IsUnion<Head> extends true ? true : AnyUnion<Tail extends any[] ? Tail : []> : false;
 /**
  * Returns `true` if every element in the tuple is `true`, otherwise returns `false`.
  * Returns `never` for an empty tuple.
  */
-type AllTrue<T$1 extends any[]> = T$1 extends [] ? never : _AllTrue<T$1>;
-type _AllTrue<T$1 extends any[]> = T$1 extends [infer Head, ...infer Tail] ? Head extends true ? Tail extends any[] ? _AllTrue<Tail> : never : false : true;
+type AllTrue<T extends any[]> = T extends [] ? never : _AllTrue<T>;
+type _AllTrue<T extends any[]> = T extends [infer Head, ...infer Tail] ? Head extends true ? Tail extends any[] ? _AllTrue<Tail> : never : false : true;
 /**
  * Returns the tail of a tuple, or `never` if the tuple is empty.
  */
-type Tail<T$1 extends any[]> = T$1 extends [any, ...infer V extends [any, ...any[]]] ? Tail<V> : T$1 extends [infer U] ? U : never;
+type Tail<T extends any[]> = T extends [any, ...infer V extends [any, ...any[]]] ? Tail<V> : T extends [infer U] ? U : never;
 /**
  * Prettify<T>
  * Materializes T into a plain object type for clearer tooltips and stable structural equality.
@@ -66,15 +70,15 @@ type Tail<T$1 extends any[]> = T$1 extends [any, ...infer V extends [any, ...any
  * - Inner unions remain unions; only the outer shape is normalized.
  * - The `& {}` forces recomputation and a simpler displayed shape in editor/tooling.
  */
-type Prettify<T$1> = { [K in keyof T$1]: T$1[K] } & {};
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
 /**
  * Wraps the given type T into an array if its multiplicity M is 'array'.
  */
-type SetMultiplicity<T$1, M = EdgeMultiplicity> = M extends 'array' ? T$1[] : T$1;
+type SetMultiplicity<T, M = EdgeMultiplicity> = M extends 'array' ? T[] : T;
 /**
  * Extracts null and undefined from a type T, resulting in `null | undefined` if both are present, otherwise `null`, `undefined`, or `never`.
  */
-type ExtractNullish<T$1> = Extract<T$1, null | undefined>;
+type ExtractNullish<T> = Extract<T, null | undefined>;
 //#endregion
 export { AllKeys, AllTrue, DeepNonNullable, DeepPartial, ExtractNullish, IsUnion, MakeMixed, NoneIsUnion, Prettify, SetMultiplicity, Tail };
 //# sourceMappingURL=util.d.ts.map

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

@@ -1,5 +1,5 @@
 import { Collection, Vertex } from "../vertex.js";
-import { AvailableLocation, Coalesced, EdgeBase, EdgeMultiplicity, EdgeWrapper, GroupWithExclude, Plain, Wrapped } from "../edges.js";
+import { AvailableLocation, Coalesced, EdgeBase, EdgeMultiplicity, EdgeWrapper, GroupWithExclude, Plain, ThreadMessage, Wrapped } from "../edges.js";
 import { DeepPartial, MakeMixed } from "../util.js";
 import { Decrement, EXPAND_KEY, InvalidEdgeMessage, MaxDepth, MinDepth, PickEdges, RemoveNeverValues, SELECT_KEY, SupportedDepths } from "../common.js";
 import { AllKeysOf } from "../keys-of.js";
@@ -7,40 +7,45 @@ import { FLATTEN_KEY, _Flatten } from "./util.js";
 
 //#region src/core/interfaces/vertices/util/vertex-query/index.d.ts
 declare namespace HandleEdge {
-  type Plain<E$1 extends EdgeBase<any, any>, D extends SupportedDepths> = E$1 extends Plain.Edge<infer U> ? _VertexQuery<U, D> : never;
-  type Wrapped<E$1 extends EdgeBase<any, any>, D extends SupportedDepths> = E$1 extends Wrapped.Edge<infer K extends string, infer V extends Vertex<Collection>, object> ? ({
+  type Plain<E extends EdgeBase<any, any>, D extends SupportedDepths> = E extends Plain.Edge<infer U> ? _VertexQuery<U, D> : never;
+  type Wrapped<E extends EdgeBase<any, any>, D extends SupportedDepths> = E extends Wrapped.Edge<infer K extends string, infer V extends Vertex<Collection>, object> ? ({
     [FLATTEN_KEY]: true;
   } & { [k in K]: V extends any ? _VertexQuery<V, D> : never }) : never;
-  type Coalesced<E$1 extends EdgeBase<any, any>, D extends SupportedDepths> = (E$1 extends Coalesced.Edge<infer V, any, object> ? V : null) extends (infer V extends Vertex<Collection>) ? {
+  type Coalesced<E extends EdgeBase<any, any>, D extends SupportedDepths> = (E extends Coalesced.Edge<infer V, any, object> ? V : null) extends (infer V extends Vertex<Collection>) ? {
     [FLATTEN_KEY]: true;
     [Coalesced.Util.Keys.TO]: MakeMixed<
     // must mix here to support all different vertex types
     V extends any ? _VertexQuery<V, D> : never>;
   } : never;
-  type GroupWithExclude<E$1 extends EdgeBase<any, any>, D extends SupportedDepths> = E$1 extends GroupWithExclude.Edge<infer G extends Vertex<Collection>, infer P extends Vertex<Collection>, object> ? {
+  type GroupWithExclude<E extends EdgeBase<any, any>, D extends SupportedDepths> = E extends GroupWithExclude.Edge<infer G extends Vertex<Collection>, infer P extends Vertex<Collection>, object> ? {
     [FLATTEN_KEY]: true;
     [GroupWithExclude.Util.Keys.TO]: G extends any ? _VertexQuery<G, D> : never;
     [GroupWithExclude.Util.Keys.EXCLUDE]: P extends any ? _VertexQuery<P, D> : never;
   } : never;
-  type AvailableLocation<E$1 extends EdgeBase<any, any>, D extends SupportedDepths> = E$1 extends AvailableLocation.Edge<infer L extends Vertex<Collection>, object> ? {
+  type AvailableLocation<E extends EdgeBase<any, any>, D extends SupportedDepths> = E extends AvailableLocation.Edge<infer L extends Vertex<Collection>, object> ? {
     [FLATTEN_KEY]: true;
     [AvailableLocation.Util.Keys.LOCATIONS]: L extends any ? _VertexQuery<L, D> : never;
   } : never;
+  type ThreadMessage<E extends EdgeBase<any, any>, D extends SupportedDepths> = E extends ThreadMessage.Edge<infer U extends Vertex<Collection>, infer T extends Vertex<Collection>, object> ? {
+    [FLATTEN_KEY]: true;
+    [ThreadMessage.Util.Keys.USER]: U extends any ? _VertexQuery<U, D> : never;
+    [ThreadMessage.Util.Keys.TAGGED_PERSONS]: T extends any ? _VertexQuery<T, D> : never;
+  } : never;
 }
 /**
  *
  */
-type _VertexQuery<V$1 extends Vertex<Collection>, D extends SupportedDepths> = D extends MinDepth ? {
-  [SELECT_KEY]: Array<AllKeysOf<V$1>>;
+type _VertexQuery<V extends Vertex<Collection>, D extends SupportedDepths> = D extends MinDepth ? {
+  [SELECT_KEY]: Array<AllKeysOf<V>>;
 } : {
-  [EXPAND_KEY]: { [K in keyof PickEdges<V$1> as V$1[K] extends never ? K : never]: InvalidEdgeMessage } & _Flatten<RemoveNeverValues<{ [K in keyof PickEdges<V$1> as V$1[K] extends never ? never : K]-?: NonNullable<V$1[K]> extends EdgeWrapper<EdgeMultiplicity, infer E extends EdgeBase<any, any> | null | undefined> ? (HandleEdge.Plain<NonNullable<E>, Decrement<D>> | HandleEdge.Wrapped<NonNullable<E>, Decrement<D>> | HandleEdge.Coalesced<NonNullable<E>, Decrement<D>> | HandleEdge.GroupWithExclude<NonNullable<E>, Decrement<D>> | HandleEdge.AvailableLocation<NonNullable<E>, Decrement<D>>) : never }>>;
+  [EXPAND_KEY]: { [K in keyof PickEdges<V> as V[K] extends never ? K : never]: InvalidEdgeMessage } & _Flatten<RemoveNeverValues<{ [K in keyof PickEdges<V> as V[K] extends never ? never : K]-?: NonNullable<V[K]> extends EdgeWrapper<EdgeMultiplicity, infer E extends EdgeBase<any, any> | null | undefined> ? (HandleEdge.Plain<NonNullable<E>, Decrement<D>> | HandleEdge.Wrapped<NonNullable<E>, Decrement<D>> | HandleEdge.Coalesced<NonNullable<E>, Decrement<D>> | HandleEdge.GroupWithExclude<NonNullable<E>, Decrement<D>> | HandleEdge.AvailableLocation<NonNullable<E>, Decrement<D>> | HandleEdge.ThreadMessage<NonNullable<E>, Decrement<D>>) : never }>>;
 } & {
-  [SELECT_KEY]: Array<AllKeysOf<V$1>>;
+  [SELECT_KEY]: Array<AllKeysOf<V>>;
 };
 /**
  *
  */
-type VertexQuery<V$1 extends Vertex<Collection>> = DeepPartial<_VertexQuery<V$1, MaxDepth>>;
+type VertexQuery<V extends Vertex<Collection>> = DeepPartial<_VertexQuery<V, MaxDepth>>;
 //#endregion
 export { VertexQuery };
 //# sourceMappingURL=index.d.ts.map

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

@@ -5,7 +5,7 @@ import { Types } from "mongoose";
 /**
  *
  */
-type RealCollection = 'settings' | 'divisionSettings' | 'exceptions' | 'groups' | 'teachers' | 'locations' | 'configurations' | 'courses' | 'events' | 'generations' | 'lockedTimes' | 'overlapGroups' | 'periods' | 'rootIntervals' | 'persons' | 'syllabuses' | 'divisions' | 'companies' | 'users';
+type RealCollection = 'settings' | 'divisionSettings' | 'exceptions' | 'groups' | 'teachers' | 'locations' | 'configurations' | 'courses' | 'events' | 'generations' | 'lockedTimes' | 'overlapGroups' | 'periods' | 'rootIntervals' | 'persons' | 'syllabuses' | 'divisions' | 'companies' | 'users' | 'threads';
 /**
  *
  */
@@ -66,5 +66,5 @@ type OmitVertexProperties<T extends object> = Omit<T, keyof Vertex<Collection>>;
 type PickVertexProperties<T extends Vertex<Collection>> = Pick<T, keyof Vertex<Collection>>;
 type VertexFactory<C extends Collection, T extends object = object> = Vertex<C> & T;
 //#endregion
-export { Collection, IDKey, IDType, OmitInternalVertexKeys, OmitVertexProperties, PickVertexProperties, PrivateIDKey, PrivateIDType, PseudoCollection, PublicIDKey, RealCollection, Vertex, VertexFactory };
+export { Collection, IDKey, IDType, OmitInternalVertexKeys, OmitVertexProperties, PickVertexProperties, PrivateIDKey, PrivateIDType, PublicIDKey, RealCollection, Vertex, VertexFactory };
 //# sourceMappingURL=vertex.d.ts.map

package/dist/core/interfaces/vertices/vertex-query.d.ts

@@ -1,7 +1,6 @@
 import { VertexQuery } from "./util/vertex-query/index.js";
 import { AssertNoInvalidExpandKeys } from "./util/custom-vertex-export/assert-no-invalid-expand-keys.js";
 import { CustomVertexExport } from "./util/custom-vertex-export/index.js";
-import "./util/index.js";
 import { PeriodVertex } from "./periods.js";
 import { RootIntervalVertex } from "./root-intervals.js";
 import { DivisionSettingsVertex } from "./division-settings.js";
@@ -9,6 +8,8 @@ import { GenerationVertex } from "./generations.js";
 import { DivisionVertex } from "./divisions.js";
 import { PersonVertex } from "./persons.js";
 import { LocationVertex } from "./locations.js";
+import { UserVertex } from "./users.js";
+import { ThreadVertex } from "./threads.js";
 import { CalendarEventVertex, EventVertex, ScheduleEventVertex } from "./events.js";
 import { OverlapGroupVertex } from "./overlap-groups.js";
 import { SyllabusVertex } from "./syllabuses.js";
@@ -18,7 +19,6 @@ import { GroupVertex } from "./groups.js";
 import { LockedTimeVertex } from "./locked-times.js";
 import { TeacherVertex } from "./teachers.js";
 import { CompanyVertex } from "./companies.js";
-import { UserVertex } from "./users.js";
 import { ConfigurationVertex } from "./configurations.js";
 
 //#region src/core/interfaces/vertices/vertex-query.d.ts
@@ -45,17 +45,18 @@ type VertexRecord = {
   configurations: ConfigurationVertex;
   companies: CompanyVertex;
   users: UserVertex;
+  threads: ThreadVertex;
 };
-type BaseQueryRecord<C$1 extends keyof VertexRecord> = VertexQuery<VertexRecord[C$1]>;
+type BaseQueryRecord<C extends keyof VertexRecord> = VertexQuery<VertexRecord[C]>;
 /**
  * See {@link createVertexQuery}
  */
-declare class VertexQuery$1<C$1 extends keyof VertexRecord, Q$1 extends BaseQueryRecord<C$1> & AssertNoInvalidExpandKeys<VertexRecord[C$1], Q$1>> {
+declare class VertexQuery$1<C extends keyof VertexRecord, Q extends BaseQueryRecord<C> & AssertNoInvalidExpandKeys<VertexRecord[C], Q>> {
   private readonly _collection;
   private readonly _query;
-  constructor(_collection: C$1, _query: Q$1);
-  get collection(): C$1;
-  get query(): Q$1;
+  constructor(_collection: C, _query: Q);
+  get collection(): C;
+  get query(): Q;
 }
 /**
  * Infers the result type for a query created via createVertexQuery.
@@ -80,25 +81,27 @@ type Infer<T extends VertexQuery$1<any, any>> = T extends VertexQuery$1<infer C,
  * type GroupType = Infer<typeof groupQuery>;
  */
 declare namespace createVertexQuery {
-  function division<Q$1 extends VertexQuery<DivisionVertex> & AssertNoInvalidExpandKeys<DivisionVertex, Q$1>>(query: Q$1): VertexQuery$1<"divisions", Q$1>;
-  function settings<Q$1 extends VertexQuery<DivisionSettingsVertex> & AssertNoInvalidExpandKeys<DivisionSettingsVertex, Q$1>>(query: Q$1): VertexQuery$1<"settings", Q$1>;
-  function exception<Q$1 extends VertexQuery<ExceptionVertex> & AssertNoInvalidExpandKeys<ExceptionVertex, Q$1>>(query: Q$1): VertexQuery$1<"exceptions", Q$1>;
-  function event<Q$1 extends VertexQuery<EventVertex> & AssertNoInvalidExpandKeys<EventVertex, Q$1>>(query: Q$1): VertexQuery$1<"events", Q$1>;
-  function scheduleEvent<Q$1 extends VertexQuery<ScheduleEventVertex> & AssertNoInvalidExpandKeys<ScheduleEventVertex, Q$1>>(query: Q$1): VertexQuery$1<"scheduleEvents", Q$1>;
-  function calendarEvent<Q$1 extends VertexQuery<CalendarEventVertex> & AssertNoInvalidExpandKeys<CalendarEventVertex, Q$1>>(query: Q$1): VertexQuery$1<"calendarEvents", Q$1>;
-  function course<Q$1 extends VertexQuery<CourseVertex> & AssertNoInvalidExpandKeys<CourseVertex, Q$1>>(query: Q$1): VertexQuery$1<"courses", Q$1>;
-  function generation<Q$1 extends VertexQuery<GenerationVertex> & AssertNoInvalidExpandKeys<GenerationVertex, Q$1>>(query: Q$1): VertexQuery$1<"generations", Q$1>;
-  function location<Q$1 extends VertexQuery<LocationVertex> & AssertNoInvalidExpandKeys<LocationVertex, Q$1>>(query: Q$1): VertexQuery$1<"locations", Q$1>;
-  function lockedTime<Q$1 extends VertexQuery<LockedTimeVertex> & AssertNoInvalidExpandKeys<LockedTimeVertex, Q$1>>(query: Q$1): VertexQuery$1<"lockedTimes", Q$1>;
-  function overlapGroup<Q$1 extends VertexQuery<OverlapGroupVertex> & AssertNoInvalidExpandKeys<OverlapGroupVertex, Q$1>>(query: Q$1): VertexQuery$1<"overlapGroups", Q$1>;
-  function period<Q$1 extends VertexQuery<PeriodVertex> & AssertNoInvalidExpandKeys<PeriodVertex, Q$1>>(query: Q$1): VertexQuery$1<"periods", Q$1>;
-  function person<Q$1 extends VertexQuery<PersonVertex> & AssertNoInvalidExpandKeys<PersonVertex, Q$1>>(query: Q$1): VertexQuery$1<"persons", Q$1>;
-  function student<Q$1 extends VertexQuery<PersonVertex> & AssertNoInvalidExpandKeys<PersonVertex, Q$1>>(query: Q$1): VertexQuery$1<"students", Q$1>;
-  function rootInterval<Q$1 extends VertexQuery<RootIntervalVertex> & AssertNoInvalidExpandKeys<RootIntervalVertex, Q$1>>(query: Q$1): VertexQuery$1<"rootIntervals", Q$1>;
-  function syllabus<Q$1 extends VertexQuery<SyllabusVertex> & AssertNoInvalidExpandKeys<SyllabusVertex, Q$1>>(query: Q$1): VertexQuery$1<"syllabuses", Q$1>;
-  function group<Q$1 extends VertexQuery<GroupVertex> & AssertNoInvalidExpandKeys<GroupVertex, Q$1>>(query: Q$1): VertexQuery$1<"groups", Q$1>;
-  function teacher<Q$1 extends VertexQuery<TeacherVertex> & AssertNoInvalidExpandKeys<TeacherVertex, Q$1>>(query: Q$1): VertexQuery$1<"teachers", Q$1>;
-  function configuration<Q$1 extends VertexQuery<ConfigurationVertex> & AssertNoInvalidExpandKeys<ConfigurationVertex, Q$1>>(query: Q$1): VertexQuery$1<"configurations", Q$1>;
+  function division<Q extends VertexQuery<DivisionVertex> & AssertNoInvalidExpandKeys<DivisionVertex, Q>>(query: Q): VertexQuery$1<"divisions", Q>;
+  function settings<Q extends VertexQuery<DivisionSettingsVertex> & AssertNoInvalidExpandKeys<DivisionSettingsVertex, Q>>(query: Q): VertexQuery$1<"settings", Q>;
+  function exception<Q extends VertexQuery<ExceptionVertex> & AssertNoInvalidExpandKeys<ExceptionVertex, Q>>(query: Q): VertexQuery$1<"exceptions", Q>;
+  function event<Q extends VertexQuery<EventVertex> & AssertNoInvalidExpandKeys<EventVertex, Q>>(query: Q): VertexQuery$1<"events", Q>;
+  function scheduleEvent<Q extends VertexQuery<ScheduleEventVertex> & AssertNoInvalidExpandKeys<ScheduleEventVertex, Q>>(query: Q): VertexQuery$1<"scheduleEvents", Q>;
+  function calendarEvent<Q extends VertexQuery<CalendarEventVertex> & AssertNoInvalidExpandKeys<CalendarEventVertex, Q>>(query: Q): VertexQuery$1<"calendarEvents", Q>;
+  function course<Q extends VertexQuery<CourseVertex> & AssertNoInvalidExpandKeys<CourseVertex, Q>>(query: Q): VertexQuery$1<"courses", Q>;
+  function generation<Q extends VertexQuery<GenerationVertex> & AssertNoInvalidExpandKeys<GenerationVertex, Q>>(query: Q): VertexQuery$1<"generations", Q>;
+  function location<Q extends VertexQuery<LocationVertex> & AssertNoInvalidExpandKeys<LocationVertex, Q>>(query: Q): VertexQuery$1<"locations", Q>;
+  function lockedTime<Q extends VertexQuery<LockedTimeVertex> & AssertNoInvalidExpandKeys<LockedTimeVertex, Q>>(query: Q): VertexQuery$1<"lockedTimes", Q>;
+  function overlapGroup<Q extends VertexQuery<OverlapGroupVertex> & AssertNoInvalidExpandKeys<OverlapGroupVertex, Q>>(query: Q): VertexQuery$1<"overlapGroups", Q>;
+  function period<Q extends VertexQuery<PeriodVertex> & AssertNoInvalidExpandKeys<PeriodVertex, Q>>(query: Q): VertexQuery$1<"periods", Q>;
+  function person<Q extends VertexQuery<PersonVertex> & AssertNoInvalidExpandKeys<PersonVertex, Q>>(query: Q): VertexQuery$1<"persons", Q>;
+  function student<Q extends VertexQuery<PersonVertex> & AssertNoInvalidExpandKeys<PersonVertex, Q>>(query: Q): VertexQuery$1<"students", Q>;
+  function rootInterval<Q extends VertexQuery<RootIntervalVertex> & AssertNoInvalidExpandKeys<RootIntervalVertex, Q>>(query: Q): VertexQuery$1<"rootIntervals", Q>;
+  function syllabus<Q extends VertexQuery<SyllabusVertex> & AssertNoInvalidExpandKeys<SyllabusVertex, Q>>(query: Q): VertexQuery$1<"syllabuses", Q>;
+  function group<Q extends VertexQuery<GroupVertex> & AssertNoInvalidExpandKeys<GroupVertex, Q>>(query: Q): VertexQuery$1<"groups", Q>;
+  function teacher<Q extends VertexQuery<TeacherVertex> & AssertNoInvalidExpandKeys<TeacherVertex, Q>>(query: Q): VertexQuery$1<"teachers", Q>;
+  function configuration<Q extends VertexQuery<ConfigurationVertex> & AssertNoInvalidExpandKeys<ConfigurationVertex, Q>>(query: Q): VertexQuery$1<"configurations", Q>;
+  function thread<Q extends VertexQuery<ThreadVertex> & AssertNoInvalidExpandKeys<ThreadVertex, Q>>(query: Q): VertexQuery$1<"threads", Q>;
+  function user<Q extends VertexQuery<UserVertex> & AssertNoInvalidExpandKeys<UserVertex, Q>>(query: Q): VertexQuery$1<"users", Q>;
 }
 //#endregion
 export { Infer, VertexQuery$1 as VertexQuery, createVertexQuery };

package/dist/core/interfaces/vertices/vertex-query.js

@@ -95,6 +95,14 @@ let createVertexQuery;
 		return new VertexQuery("configurations", query);
 	}
 	_createVertexQuery.configuration = configuration;
+	function thread(query) {
+		return new VertexQuery("threads", query);
+	}
+	_createVertexQuery.thread = thread;
+	function user(query) {
+		return new VertexQuery("users", query);
+	}
+	_createVertexQuery.user = user;
 })(createVertexQuery || (createVertexQuery = {}));
 
 //#endregion

package/dist/core/interfaces/vertices/vertex-query.js.map

@@ -1 +1 @@
-{"version":3,"file":"vertex-query.js","names":["_collection: C","_query:      Q"],"sources":["../../../../src/core/interfaces/vertices/vertex-query.ts"],"sourcesContent":["import type { AssertNoInvalidExpandKeys, Collection, CustomVertexExport } from './util';\nimport type { TeacherVertex } from './teachers';\nimport type { ExceptionVertex } from './exceptions';\nimport type { EventVertex, ScheduleEventVertex, CalendarEventVertex } from './events';\nimport type { CourseVertex } from './courses';\nimport type { DivisionSettingsVertex } from './division-settings';\nimport type { DivisionVertex } from './divisions';\nimport type { GenerationVertex } from './generations';\nimport type { GroupVertex } from './groups';\nimport type { LocationVertex } from './locations';\nimport type { LockedTimeVertex } from './locked-times';\nimport type { OverlapGroupVertex } from './overlap-groups';\nimport type { PeriodVertex } from './periods';\nimport type { PersonVertex } from './persons';\nimport type { RootIntervalVertex } from './root-intervals';\nimport type { SyllabusVertex } from './syllabuses';\nimport type { ConfigurationVertex } from './configurations';\nimport type { CompanyVertex } from './companies';\nimport type { UserVertex } from './users';\nimport type { VertexQuery as Query } from './util/vertex-query';\nimport type { TypeEqual } from 'ts-expect';\nimport { expectType } from 'ts-expect';\n\n\nexport type VertexRecord = {\n  divisions:        DivisionVertex;\n  divisionSettings: DivisionSettingsVertex;\n  settings:         DivisionSettingsVertex;\n  teachers:         TeacherVertex;\n  exceptions:       ExceptionVertex;\n  events:           EventVertex;\n  scheduleEvents:   ScheduleEventVertex;\n  calendarEvents:   CalendarEventVertex;\n  courses:          CourseVertex;\n  generations:      GenerationVertex;\n  groups:           GroupVertex;\n  locations:        LocationVertex;\n  lockedTimes:      LockedTimeVertex;\n  overlapGroups:    OverlapGroupVertex;\n  periods:          PeriodVertex;\n  persons:          PersonVertex;\n  students:         PersonVertex;\n  rootIntervals:    RootIntervalVertex;\n  syllabuses:       SyllabusVertex;\n  configurations:   ConfigurationVertex;\n  companies:        CompanyVertex;\n  users:            UserVertex;\n};\nexport type BaseQueryRecord<C extends keyof VertexRecord> = Query<VertexRecord[C]>;\n{\n  // the keys must all be a collection\n  type Mismatches = keyof {\n    [K in keyof VertexRecord as K extends Collection ? never : K]: true\n  };\n  expectType<TypeEqual<Mismatches, never>>(true);\n}\n\n/**\n * See {@link createVertexQuery}\n */\nexport class VertexQuery <\n  C extends keyof VertexRecord,\n  Q extends BaseQueryRecord<C> & AssertNoInvalidExpandKeys<VertexRecord[C], Q>\n> {\n  constructor (\n    private readonly _collection: C,\n    private readonly _query:      Q\n  ) {}\n\n  get collection () { return this._collection }\n  get query      () { return this._query      }\n}\n\n\n/**\n * Infers the result type for a query created via createVertexQuery.\n *\n * @example\n * const personQuery = createVertexQuery('persons', { select: ['id', 'firstName'] });\n * type PersonType = Infer<typeof personQuery>;\n */\nexport type Infer<T extends VertexQuery<any, any>> = // eslint-disable-line @typescript-eslint/no-explicit-any\n  T extends VertexQuery<infer C, infer Q>\n    ? CustomVertexExport<VertexRecord[C], Q>\n    : never;\n\n\n/**\n * Builds a typed vertex query for a given vertex type using a select/expand shape.\n *\n * Use together with Infer<T> to obtain the serialized result type.\n *\n * @typeParam Q - The select/expand query shape for that vertex.\n *\n * @example\n * const groupQuery = createVertexQuery.group({\n *   select: ['id', 'displayName'],\n *   expand: { members: { select: ['id'] } }\n * });\n * type GroupType = Infer<typeof groupQuery>;\n */\nexport namespace createVertexQuery {\n  //\n  // The following did not work: it seems we need to define Q as an completely independent type parameter (?)\n  //\n  // export function createVertexQuery <\n  //   C extends keyof VertexRecord,\n  //   const Q extends Query<VertexRecord[C]>\n  // > (\n  //   collection: C,\n  //   query:      Q\n  // ) {\n  //   return new VertexQuery(collection, query);\n  // }\n\n  export function division     <Q extends Query<DivisionVertex        > & AssertNoInvalidExpandKeys<DivisionVertex,         Q>> (query: Q) { return new VertexQuery('divisions',        query) }\n  export function settings     <Q extends Query<DivisionSettingsVertex> & AssertNoInvalidExpandKeys<DivisionSettingsVertex, Q>> (query: Q) { return new VertexQuery('settings',         query) }\n  export function exception    <Q extends Query<ExceptionVertex       > & AssertNoInvalidExpandKeys<ExceptionVertex,        Q>> (query: Q) { return new VertexQuery('exceptions',       query) }\n  export function event        <Q extends Query<EventVertex           > & AssertNoInvalidExpandKeys<EventVertex,            Q>> (query: Q) { return new VertexQuery('events',           query) }\n  export function scheduleEvent<Q extends Query<ScheduleEventVertex   > & AssertNoInvalidExpandKeys<ScheduleEventVertex,    Q>> (query: Q) { return new VertexQuery('scheduleEvents',   query) }\n  export function calendarEvent<Q extends Query<CalendarEventVertex   > & AssertNoInvalidExpandKeys<CalendarEventVertex,    Q>> (query: Q) { return new VertexQuery('calendarEvents',   query) }\n  export function course       <Q extends Query<CourseVertex          > & AssertNoInvalidExpandKeys<CourseVertex,           Q>> (query: Q) { return new VertexQuery('courses',          query) }\n  export function generation   <Q extends Query<GenerationVertex      > & AssertNoInvalidExpandKeys<GenerationVertex,       Q>> (query: Q) { return new VertexQuery('generations',      query) }\n  export function location     <Q extends Query<LocationVertex        > & AssertNoInvalidExpandKeys<LocationVertex,         Q>> (query: Q) { return new VertexQuery('locations',        query) }\n  export function lockedTime   <Q extends Query<LockedTimeVertex      > & AssertNoInvalidExpandKeys<LockedTimeVertex,       Q>> (query: Q) { return new VertexQuery('lockedTimes',      query) }\n  export function overlapGroup <Q extends Query<OverlapGroupVertex    > & AssertNoInvalidExpandKeys<OverlapGroupVertex,     Q>> (query: Q) { return new VertexQuery('overlapGroups',    query) }\n  export function period       <Q extends Query<PeriodVertex          > & AssertNoInvalidExpandKeys<PeriodVertex,           Q>> (query: Q) { return new VertexQuery('periods',          query) }\n  export function person       <Q extends Query<PersonVertex          > & AssertNoInvalidExpandKeys<PersonVertex,           Q>> (query: Q) { return new VertexQuery('persons',          query) }\n  export function student      <Q extends Query<PersonVertex          > & AssertNoInvalidExpandKeys<PersonVertex,           Q>> (query: Q) { return new VertexQuery('students',         query) }\n  export function rootInterval <Q extends Query<RootIntervalVertex    > & AssertNoInvalidExpandKeys<RootIntervalVertex,     Q>> (query: Q) { return new VertexQuery('rootIntervals',    query) }\n  export function syllabus     <Q extends Query<SyllabusVertex        > & AssertNoInvalidExpandKeys<SyllabusVertex,         Q>> (query: Q) { return new VertexQuery('syllabuses',       query) }\n  export function group        <Q extends Query<GroupVertex           > & AssertNoInvalidExpandKeys<GroupVertex,            Q>> (query: Q) { return new VertexQuery('groups',           query) }\n  export function teacher      <Q extends Query<TeacherVertex         > & AssertNoInvalidExpandKeys<TeacherVertex,          Q>> (query: Q) { return new VertexQuery('teachers',         query) }\n  export function configuration<Q extends Query<ConfigurationVertex   > & AssertNoInvalidExpandKeys<ConfigurationVertex,    Q>> (query: Q) { return new VertexQuery('configurations',   query) }\n}"],"mappings":";;;AAsDE,WAAyC,KAAK;;;;AAMhD,IAAa,cAAb,MAGE;CACA,YACE,AAAiBA,aACjB,AAAiBC,QACjB;EAFiB;EACA;;CAGnB,IAAI,aAAc;AAAE,SAAO,KAAK;;CAChC,IAAI,QAAc;AAAE,SAAO,KAAK;;;;;CA6CzB,SAAS,SAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,aAAoB,MAAM;;;CACrL,SAAS,SAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,YAAoB,MAAM;;;CACrL,SAAS,UAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,cAAoB,MAAM;;;CACrL,SAAS,MAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,UAAoB,MAAM;;;CACrL,SAAS,cAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,kBAAoB,MAAM;;;CACrL,SAAS,cAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,kBAAoB,MAAM;;;CACrL,SAAS,OAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,WAAoB,MAAM;;;CACrL,SAAS,WAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,eAAoB,MAAM;;;CACrL,SAAS,SAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,aAAoB,MAAM;;;CACrL,SAAS,WAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,eAAoB,MAAM;;;CACrL,SAAS,aAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,iBAAoB,MAAM;;;CACrL,SAAS,OAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,WAAoB,MAAM;;;CACrL,SAAS,OAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,WAAoB,MAAM;;;CACrL,SAAS,QAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,YAAoB,MAAM;;;CACrL,SAAS,aAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,iBAAoB,MAAM;;;CACrL,SAAS,SAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,cAAoB,MAAM;;;CACrL,SAAS,MAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,UAAoB,MAAM;;;CACrL,SAAS,QAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,YAAoB,MAAM;;;CACrL,SAAS,cAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,kBAAoB,MAAM"}
+{"version":3,"file":"vertex-query.js","names":["_collection: C","_query:      Q"],"sources":["../../../../src/core/interfaces/vertices/vertex-query.ts"],"sourcesContent":["import type { AssertNoInvalidExpandKeys, Collection, CustomVertexExport } from './util';\nimport type { TeacherVertex } from './teachers';\nimport type { ExceptionVertex } from './exceptions';\nimport type { EventVertex, ScheduleEventVertex, CalendarEventVertex } from './events';\nimport type { CourseVertex } from './courses';\nimport type { DivisionSettingsVertex } from './division-settings';\nimport type { DivisionVertex } from './divisions';\nimport type { GenerationVertex } from './generations';\nimport type { GroupVertex } from './groups';\nimport type { LocationVertex } from './locations';\nimport type { LockedTimeVertex } from './locked-times';\nimport type { OverlapGroupVertex } from './overlap-groups';\nimport type { PeriodVertex } from './periods';\nimport type { PersonVertex } from './persons';\nimport type { RootIntervalVertex } from './root-intervals';\nimport type { SyllabusVertex } from './syllabuses';\nimport type { ConfigurationVertex } from './configurations';\nimport type { CompanyVertex } from './companies';\nimport type { UserVertex } from './users';\nimport type { ThreadVertex } from './threads';\nimport type { VertexQuery as Query } from './util/vertex-query';\nimport type { TypeEqual } from 'ts-expect';\nimport { expectType } from 'ts-expect';\n\n\nexport type VertexRecord = {\n  divisions:        DivisionVertex;\n  divisionSettings: DivisionSettingsVertex;\n  settings:         DivisionSettingsVertex;\n  teachers:         TeacherVertex;\n  exceptions:       ExceptionVertex;\n  events:           EventVertex;\n  scheduleEvents:   ScheduleEventVertex;\n  calendarEvents:   CalendarEventVertex;\n  courses:          CourseVertex;\n  generations:      GenerationVertex;\n  groups:           GroupVertex;\n  locations:        LocationVertex;\n  lockedTimes:      LockedTimeVertex;\n  overlapGroups:    OverlapGroupVertex;\n  periods:          PeriodVertex;\n  persons:          PersonVertex;\n  students:         PersonVertex;\n  rootIntervals:    RootIntervalVertex;\n  syllabuses:       SyllabusVertex;\n  configurations:   ConfigurationVertex;\n  companies:        CompanyVertex;\n  users:            UserVertex;\n  threads:          ThreadVertex;\n};\nexport type BaseQueryRecord<C extends keyof VertexRecord> = Query<VertexRecord[C]>;\n{\n  // the keys must all be a collection\n  type Mismatches = keyof {\n    [K in keyof VertexRecord as K extends Collection ? never : K]: true\n  };\n  expectType<TypeEqual<Mismatches, never>>(true);\n}\n\n/**\n * See {@link createVertexQuery}\n */\nexport class VertexQuery <\n  C extends keyof VertexRecord,\n  Q extends BaseQueryRecord<C> & AssertNoInvalidExpandKeys<VertexRecord[C], Q>\n> {\n  constructor (\n    private readonly _collection: C,\n    private readonly _query:      Q\n  ) {}\n\n  get collection () { return this._collection }\n  get query      () { return this._query      }\n}\n\n\n/**\n * Infers the result type for a query created via createVertexQuery.\n *\n * @example\n * const personQuery = createVertexQuery('persons', { select: ['id', 'firstName'] });\n * type PersonType = Infer<typeof personQuery>;\n */\nexport type Infer<T extends VertexQuery<any, any>> = // eslint-disable-line @typescript-eslint/no-explicit-any\n  T extends VertexQuery<infer C, infer Q>\n    ? CustomVertexExport<VertexRecord[C], Q>\n    : never;\n\n\n/**\n * Builds a typed vertex query for a given vertex type using a select/expand shape.\n *\n * Use together with Infer<T> to obtain the serialized result type.\n *\n * @typeParam Q - The select/expand query shape for that vertex.\n *\n * @example\n * const groupQuery = createVertexQuery.group({\n *   select: ['id', 'displayName'],\n *   expand: { members: { select: ['id'] } }\n * });\n * type GroupType = Infer<typeof groupQuery>;\n */\nexport namespace createVertexQuery {\n  //\n  // The following did not work: it seems we need to define Q as an completely independent type parameter (?)\n  //\n  // export function createVertexQuery <\n  //   C extends keyof VertexRecord,\n  //   const Q extends Query<VertexRecord[C]>\n  // > (\n  //   collection: C,\n  //   query:      Q\n  // ) {\n  //   return new VertexQuery(collection, query);\n  // }\n\n  export function division     <Q extends Query<DivisionVertex        > & AssertNoInvalidExpandKeys<DivisionVertex,         Q>> (query: Q) { return new VertexQuery('divisions',        query) }\n  export function settings     <Q extends Query<DivisionSettingsVertex> & AssertNoInvalidExpandKeys<DivisionSettingsVertex, Q>> (query: Q) { return new VertexQuery('settings',         query) }\n  export function exception    <Q extends Query<ExceptionVertex       > & AssertNoInvalidExpandKeys<ExceptionVertex,        Q>> (query: Q) { return new VertexQuery('exceptions',       query) }\n  export function event        <Q extends Query<EventVertex           > & AssertNoInvalidExpandKeys<EventVertex,            Q>> (query: Q) { return new VertexQuery('events',           query) }\n  export function scheduleEvent<Q extends Query<ScheduleEventVertex   > & AssertNoInvalidExpandKeys<ScheduleEventVertex,    Q>> (query: Q) { return new VertexQuery('scheduleEvents',   query) }\n  export function calendarEvent<Q extends Query<CalendarEventVertex   > & AssertNoInvalidExpandKeys<CalendarEventVertex,    Q>> (query: Q) { return new VertexQuery('calendarEvents',   query) }\n  export function course       <Q extends Query<CourseVertex          > & AssertNoInvalidExpandKeys<CourseVertex,           Q>> (query: Q) { return new VertexQuery('courses',          query) }\n  export function generation   <Q extends Query<GenerationVertex      > & AssertNoInvalidExpandKeys<GenerationVertex,       Q>> (query: Q) { return new VertexQuery('generations',      query) }\n  export function location     <Q extends Query<LocationVertex        > & AssertNoInvalidExpandKeys<LocationVertex,         Q>> (query: Q) { return new VertexQuery('locations',        query) }\n  export function lockedTime   <Q extends Query<LockedTimeVertex      > & AssertNoInvalidExpandKeys<LockedTimeVertex,       Q>> (query: Q) { return new VertexQuery('lockedTimes',      query) }\n  export function overlapGroup <Q extends Query<OverlapGroupVertex    > & AssertNoInvalidExpandKeys<OverlapGroupVertex,     Q>> (query: Q) { return new VertexQuery('overlapGroups',    query) }\n  export function period       <Q extends Query<PeriodVertex          > & AssertNoInvalidExpandKeys<PeriodVertex,           Q>> (query: Q) { return new VertexQuery('periods',          query) }\n  export function person       <Q extends Query<PersonVertex          > & AssertNoInvalidExpandKeys<PersonVertex,           Q>> (query: Q) { return new VertexQuery('persons',          query) }\n  export function student      <Q extends Query<PersonVertex          > & AssertNoInvalidExpandKeys<PersonVertex,           Q>> (query: Q) { return new VertexQuery('students',         query) }\n  export function rootInterval <Q extends Query<RootIntervalVertex    > & AssertNoInvalidExpandKeys<RootIntervalVertex,     Q>> (query: Q) { return new VertexQuery('rootIntervals',    query) }\n  export function syllabus     <Q extends Query<SyllabusVertex        > & AssertNoInvalidExpandKeys<SyllabusVertex,         Q>> (query: Q) { return new VertexQuery('syllabuses',       query) }\n  export function group        <Q extends Query<GroupVertex           > & AssertNoInvalidExpandKeys<GroupVertex,            Q>> (query: Q) { return new VertexQuery('groups',           query) }\n  export function teacher      <Q extends Query<TeacherVertex         > & AssertNoInvalidExpandKeys<TeacherVertex,          Q>> (query: Q) { return new VertexQuery('teachers',         query) }\n  export function configuration<Q extends Query<ConfigurationVertex   > & AssertNoInvalidExpandKeys<ConfigurationVertex,    Q>> (query: Q) { return new VertexQuery('configurations',   query) }\n  export function thread       <Q extends Query<ThreadVertex          > & AssertNoInvalidExpandKeys<ThreadVertex,           Q>> (query: Q) { return new VertexQuery('threads',          query) }\n  export function user         <Q extends Query<UserVertex            > & AssertNoInvalidExpandKeys<UserVertex,             Q>> (query: Q) { return new VertexQuery('users',            query) }\n}"],"mappings":";;;AAwDE,WAAyC;;;;AAM3C,IAAa,cAAb,MAGE;CACA,YACE,AAAiBA,aACjB,AAAiBC,QACjB;EAFiB;EACA;;CAGnB,IAAI,aAAc;AAAE,SAAO,KAAK;;CAChC,IAAI,QAAc;AAAE,SAAO,KAAK;;;;;CA6CzB,SAAS,SAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,aAAoB;;;CAC/K,SAAS,SAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,YAAoB;;;CAC/K,SAAS,UAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,cAAoB;;;CAC/K,SAAS,MAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,UAAoB;;;CAC/K,SAAS,cAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,kBAAoB;;;CAC/K,SAAS,cAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,kBAAoB;;;CAC/K,SAAS,OAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,WAAoB;;;CAC/K,SAAS,WAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,eAAoB;;;CAC/K,SAAS,SAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,aAAoB;;;CAC/K,SAAS,WAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,eAAoB;;;CAC/K,SAAS,aAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,iBAAoB;;;CAC/K,SAAS,OAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,WAAoB;;;CAC/K,SAAS,OAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,WAAoB;;;CAC/K,SAAS,QAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,YAAoB;;;CAC/K,SAAS,aAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,iBAAoB;;;CAC/K,SAAS,SAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,cAAoB;;;CAC/K,SAAS,MAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,UAAoB;;;CAC/K,SAAS,QAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,YAAoB;;;CAC/K,SAAS,cAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,kBAAoB;;;CAC/K,SAAS,OAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,WAAoB;;;CAC/K,SAAS,KAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,SAAoB"}

package/dist/core/to/configurations.js

@@ -4,8 +4,9 @@ import { omitEdgesAndInternalProperties } from "./util.js";
 var configurations_default = (configurations, _options) => {
 	return configurations.map((x) => {
 		const edges = {};
+		const nonEdges = omitEdgesAndInternalProperties(x, edges);
 		return {
-			...omitEdgesAndInternalProperties(x, edges),
+			...nonEdges,
 			...edges
 		};
 	});

package/dist/core/to/configurations.js.map

@@ -1 +1 @@
-{"version":3,"file":"configurations.js","names":["edges: SerializedEdgesOnlyVertexExport<ConfigurationVertex>"],"sources":["../../../src/core/to/configurations.ts"],"sourcesContent":["import type { Types } from '../types';\nimport type { OutTypes } from './schedules';\nimport type { BaseOptions } from '../../common/types';\nimport { omitEdgesAndInternalProperties, type SerializedEdgesOnlyVertexExport, type SerializedEdgesShape } from './util';\nimport type { ConfigurationVertex } from '../interfaces/vertices/configurations';\n\nexport default (\n  configurations: Types.Mixed.Configuration[],\n  _options:       BaseOptions\n): OutTypes.configuration[] => {\n  return configurations\n    .map(x => {\n      const edges: SerializedEdgesOnlyVertexExport<ConfigurationVertex> = {\n      } satisfies SerializedEdgesShape<SerializedEdgesOnlyVertexExport<ConfigurationVertex>>;\n      const nonEdges = omitEdgesAndInternalProperties(x, edges);\n\n      return { ...nonEdges, ...edges };\n    });\n};\n"],"mappings":";;;AAMA,8BACE,gBACA,aAC6B;AAC7B,QAAO,eACJ,KAAI,MAAK;EACR,MAAMA,QAA8D,EACnE;AAGD,SAAO;GAAE,GAFQ,+BAA+B,GAAG,MAAM;GAEnC,GAAG;GAAO;GAChC"}
+{"version":3,"file":"configurations.js","names":["edges: SerializedEdgesOnlyVertexExport<ConfigurationVertex>"],"sources":["../../../src/core/to/configurations.ts"],"sourcesContent":["import type { Types } from '../types';\nimport type { OutTypes } from './schedules';\nimport type { BaseOptions } from '../../common/types';\nimport { omitEdgesAndInternalProperties, type SerializedEdgesOnlyVertexExport, type SerializedEdgesShape } from './util';\nimport type { ConfigurationVertex } from '../interfaces/vertices/configurations';\n\nexport default (\n  configurations: Types.Mixed.Configuration[],\n  _options:       BaseOptions\n): OutTypes.configuration[] => {\n  return configurations\n    .map(x => {\n      const edges: SerializedEdgesOnlyVertexExport<ConfigurationVertex> = {\n      } satisfies SerializedEdgesShape<SerializedEdgesOnlyVertexExport<ConfigurationVertex>>;\n      const nonEdges = omitEdgesAndInternalProperties(x, edges);\n\n      return { ...nonEdges, ...edges };\n    });\n};\n"],"mappings":";;;AAMA,8BACE,gBACA,aAC6B;AAC7B,QAAO,eACJ,KAAI,MAAK;EACR,MAAMA,QAA8D;EAEpE,MAAM,WAAW,+BAA+B,GAAG;AAEnD,SAAO;GAAE,GAAG;GAAU,GAAG"}

package/dist/core/to/courses.js

@@ -29,8 +29,9 @@ var courses_default = (courses, options) => {
 				locations: [getVertexId(x$1.locations[0], options)]
 			}))
 		};
+		const nonEdges = omitEdgesAndInternalProperties(x, edges);
 		return {
-			...omitEdgesAndInternalProperties(x, edges),
+			...nonEdges,
 			...edges
 		};
 	});

package/dist/core/to/courses.js.map

@@ -1 +1 @@
-{"version":3,"file":"courses.js","names":["edges: SerializedEdgesOnlyVertexExport<CourseVertex>","x"],"sources":["../../../src/core/to/courses.ts"],"sourcesContent":["import type { Types } from '../types';\nimport type { OutTypes } from './schedules';\nimport { getVertexId } from '../util';\nimport { omitEdgesAndInternalProperties, type SerializedEdgesOnlyVertexExport, type SerializedEdgesShape } from './util';\nimport type { BaseOptions } from '../../common/types';\nimport type { CourseVertex } from '../interfaces/vertices/courses';\n\n\nexport default (\n  courses: Types.Mixed.Course[],\n  options: BaseOptions\n): OutTypes.course[] => {\n  return courses\n    .map(x => {\n      const edges: SerializedEdgesOnlyVertexExport<CourseVertex> = {\n        period:         x.period         ? getVertexId(x.period,         options) : undefined,\n        overlapGroup:   x.overlapGroup   ? getVertexId(x.overlapGroup,   options) : undefined,\n        // overlapSpecies: x.overlapSpecies ? getVertexId(x.overlapSpecies, options) : undefined,\n        syllabus:       x.syllabus       ? getVertexId(x.syllabus,       options) : undefined,\n        events:         x.events      ?.map(x => getVertexId(x, options)),\n        lockedTimes:    x.lockedTimes ?.map(x => getVertexId(x, options)),\n        exceptions:     x.exceptions  ?.map(x => getVertexId(x, options)),\n        teachers:       x.teachers    ?.map(x => ({ ...x, to: getVertexId(x.to, options) })),\n        participants:   x.participants?.map(x => ({ ...x, to: getVertexId(x.to, options) })),\n        groups:         x.groups      ?.map(x => ({ ...x, to: getVertexId(x.to, options), exclude: x.exclude?.map(y => getVertexId(y, options)) })),\n        locations:      x.locations   ?.map(x => ({ ...x, locations: [getVertexId(x.locations[0], options)] as [string] })),\n      } satisfies SerializedEdgesShape<SerializedEdgesOnlyVertexExport<CourseVertex>>;\n      const nonEdges = omitEdgesAndInternalProperties(x, edges);\n\n      return { ...nonEdges, ...edges };\n    });\n};\n"],"mappings":";;;;AAQA,uBACE,SACA,YACsB;AACtB,QAAO,QACJ,KAAI,MAAK;EACR,MAAMA,QAAuD;GAC3D,QAAgB,EAAE,SAAiB,YAAY,EAAE,QAAgB,QAAQ,GAAG;GAC5E,cAAgB,EAAE,eAAiB,YAAY,EAAE,cAAgB,QAAQ,GAAG;GAE5E,UAAgB,EAAE,WAAiB,YAAY,EAAE,UAAgB,QAAQ,GAAG;GAC5E,QAAgB,EAAE,QAAc,KAAI,QAAK,YAAYC,KAAG,QAAQ,CAAC;GACjE,aAAgB,EAAE,aAAc,KAAI,QAAK,YAAYA,KAAG,QAAQ,CAAC;GACjE,YAAgB,EAAE,YAAc,KAAI,QAAK,YAAYA,KAAG,QAAQ,CAAC;GACjE,UAAgB,EAAE,UAAc,KAAI,SAAM;IAAE,GAAGA;IAAG,IAAI,YAAYA,IAAE,IAAI,QAAQ;IAAE,EAAE;GACpF,cAAgB,EAAE,cAAc,KAAI,SAAM;IAAE,GAAGA;IAAG,IAAI,YAAYA,IAAE,IAAI,QAAQ;IAAE,EAAE;GACpF,QAAgB,EAAE,QAAc,KAAI,SAAM;IAAE,GAAGA;IAAG,IAAI,YAAYA,IAAE,IAAI,QAAQ;IAAE,SAASA,IAAE,SAAS,KAAI,MAAK,YAAY,GAAG,QAAQ,CAAC;IAAE,EAAE;GAC3I,WAAgB,EAAE,WAAc,KAAI,SAAM;IAAE,GAAGA;IAAG,WAAW,CAAC,YAAYA,IAAE,UAAU,IAAI,QAAQ,CAAC;IAAc,EAAE;GACpH;AAGD,SAAO;GAAE,GAFQ,+BAA+B,GAAG,MAAM;GAEnC,GAAG;GAAO;GAChC"}
+{"version":3,"file":"courses.js","names":["edges: SerializedEdgesOnlyVertexExport<CourseVertex>","x"],"sources":["../../../src/core/to/courses.ts"],"sourcesContent":["import type { Types } from '../types';\nimport type { OutTypes } from './schedules';\nimport { getVertexId } from '../util';\nimport { omitEdgesAndInternalProperties, type SerializedEdgesOnlyVertexExport, type SerializedEdgesShape } from './util';\nimport type { BaseOptions } from '../../common/types';\nimport type { CourseVertex } from '../interfaces/vertices/courses';\n\n\nexport default (\n  courses: Types.Mixed.Course[],\n  options: BaseOptions\n): OutTypes.course[] => {\n  return courses\n    .map(x => {\n      const edges: SerializedEdgesOnlyVertexExport<CourseVertex> = {\n        period:         x.period         ? getVertexId(x.period,         options) : undefined,\n        overlapGroup:   x.overlapGroup   ? getVertexId(x.overlapGroup,   options) : undefined,\n        // overlapSpecies: x.overlapSpecies ? getVertexId(x.overlapSpecies, options) : undefined,\n        syllabus:       x.syllabus       ? getVertexId(x.syllabus,       options) : undefined,\n        events:         x.events      ?.map(x => getVertexId(x, options)),\n        lockedTimes:    x.lockedTimes ?.map(x => getVertexId(x, options)),\n        exceptions:     x.exceptions  ?.map(x => getVertexId(x, options)),\n        teachers:       x.teachers    ?.map(x => ({ ...x, to: getVertexId(x.to, options) })),\n        participants:   x.participants?.map(x => ({ ...x, to: getVertexId(x.to, options) })),\n        groups:         x.groups      ?.map(x => ({ ...x, to: getVertexId(x.to, options), exclude: x.exclude?.map(y => getVertexId(y, options)) })),\n        locations:      x.locations   ?.map(x => ({ ...x, locations: [getVertexId(x.locations[0], options)] as [string] })),\n      } satisfies SerializedEdgesShape<SerializedEdgesOnlyVertexExport<CourseVertex>>;\n      const nonEdges = omitEdgesAndInternalProperties(x, edges);\n\n      return { ...nonEdges, ...edges };\n    });\n};\n"],"mappings":";;;;AAQA,uBACE,SACA,YACsB;AACtB,QAAO,QACJ,KAAI,MAAK;EACR,MAAMA,QAAuD;GAC3D,QAAgB,EAAE,SAAiB,YAAY,EAAE,QAAgB,WAAW;GAC5E,cAAgB,EAAE,eAAiB,YAAY,EAAE,cAAgB,WAAW;GAE5E,UAAgB,EAAE,WAAiB,YAAY,EAAE,UAAgB,WAAW;GAC5E,QAAgB,EAAE,QAAc,KAAI,QAAK,YAAYC,KAAG;GACxD,aAAgB,EAAE,aAAc,KAAI,QAAK,YAAYA,KAAG;GACxD,YAAgB,EAAE,YAAc,KAAI,QAAK,YAAYA,KAAG;GACxD,UAAgB,EAAE,UAAc,KAAI,SAAM;IAAE,GAAGA;IAAG,IAAI,YAAYA,IAAE,IAAI;;GACxE,cAAgB,EAAE,cAAc,KAAI,SAAM;IAAE,GAAGA;IAAG,IAAI,YAAYA,IAAE,IAAI;;GACxE,QAAgB,EAAE,QAAc,KAAI,SAAM;IAAE,GAAGA;IAAG,IAAI,YAAYA,IAAE,IAAI;IAAU,SAASA,IAAE,SAAS,KAAI,MAAK,YAAY,GAAG;;GAC9H,WAAgB,EAAE,WAAc,KAAI,SAAM;IAAE,GAAGA;IAAG,WAAW,CAAC,YAAYA,IAAE,UAAU,IAAI;;;EAE5F,MAAM,WAAW,+BAA+B,GAAG;AAEnD,SAAO;GAAE,GAAG;GAAU,GAAG"}

package/dist/core/to/division.js.map

@@ -1 +1 @@
-{"version":3,"file":"division.js","names":[],"sources":["../../../src/core/to/division.ts"],"sourcesContent":["import { pick } from 'lodash-es';\nimport type { Types } from '../types';\nimport type { BaseOptions } from '../../common/types';\nimport type { OutTypes } from './schedules';\n\nexport default (\n  division: Types.Mixed.Division,\n  options:  BaseOptions\n): Pick<OutTypes.division, 'displayName' | 'start' | 'end'> => {\n  return pick(division, 'displayName', 'start', 'end');\n};\n"],"mappings":";;;AAKA,wBACE,UACA,YAC6D;AAC7D,QAAO,KAAK,UAAU,eAAe,SAAS,MAAM"}
+{"version":3,"file":"division.js","names":[],"sources":["../../../src/core/to/division.ts"],"sourcesContent":["import { pick } from 'lodash-es';\nimport type { Types } from '../types';\nimport type { BaseOptions } from '../../common/types';\nimport type { OutTypes } from './schedules';\n\nexport default (\n  division: Types.Mixed.Division,\n  options:  BaseOptions\n): Pick<OutTypes.division, 'displayName' | 'start' | 'end'> => {\n  return pick(division, 'displayName', 'start', 'end');\n};\n"],"mappings":";;;AAKA,wBACE,UACA,YAC6D;AAC7D,QAAO,KAAK,UAAU,eAAe,SAAS"}

package/dist/core/to/events.js

@@ -27,10 +27,12 @@ var events_default = (events, options) => {
 				...x$1,
 				locations: [getVertexId(x$1.locations[0], options)]
 			})),
-			inLocations: x.inLocations?.map((x$1) => x$1 ? getVertexId(x$1, options) : null)
+			inLocations: x.inLocations?.map((x$1) => x$1 ? getVertexId(x$1, options) : null),
+			threads: void 0
 		};
+		const nonEdges = omitEdgesAndInternalProperties(x, edges);
 		return {
-			...omitEdgesAndInternalProperties(x, edges),
+			...nonEdges,
 			...edges
 		};
 	});

package/dist/core/to/events.js.map

@@ -1 +1 @@
-{"version":3,"file":"events.js","names":["edges: SerializedEdgesOnlyVertexExport<EventVertex>","x"],"sources":["../../../src/core/to/events.ts"],"sourcesContent":["import type { Types } from '../types';\nimport type { OutTypes } from './schedules';\nimport { getVertexId } from '../util';\nimport { omitEdgesAndInternalProperties, type SerializedEdgesOnlyVertexExport, type SerializedEdgesShape } from './util';\nimport type { BaseOptions } from '../../common/types';\nimport type { EventVertex } from '../interfaces/vertices/events';\n\n\n\n\nexport default (\n  events:  Types.Mixed.Event[],\n  options: BaseOptions\n): OutTypes.event[] => {\n  return events\n    .map(x => {\n      const edges: SerializedEdgesOnlyVertexExport<EventVertex> = {\n        period:         x.period         ? getVertexId(x.period,         options) : undefined,\n        // overlapGroup:   x.overlapGroup   ? getVertexId(x.overlapGroup,   options) : undefined,\n        overlapSpecies: x.overlapSpecies ? getVertexId(x.overlapSpecies, options) : undefined,\n        course:         x.course         ? getVertexId(x.course,         options) : undefined,\n        lockedTimes:    x.lockedTimes ?.map(x => getVertexId(x, options)),\n        exceptions:     x.exceptions  ?.map(x => getVertexId(x, options)),\n        teachers:       x.teachers    ?.map(x => ({ ...x, to: getVertexId(x.to, options) })),\n        participants:   x.participants?.map(x => ({ ...x, to: getVertexId(x.to, options) })),\n        groups:         x.groups      ?.map(x => ({ ...x, to: getVertexId(x.to, options), exclude: x.exclude?.map(y => getVertexId(y, options)) })),\n        locations:      x.locations   ?.map(x => ({ ...x, locations: [getVertexId(x.locations[0], options)] as [string] })),\n        inLocations:    x.inLocations ?.map(x => x ? getVertexId(x, options) : null)\n      } satisfies SerializedEdgesShape<SerializedEdgesOnlyVertexExport<EventVertex>>;\n      const nonEdges = omitEdgesAndInternalProperties(x, edges);\n\n      return { ...nonEdges, ...edges };\n    });\n};\n\n"],"mappings":";;;;AAUA,sBACE,QACA,YACqB;AACrB,QAAO,OACJ,KAAI,MAAK;EACR,MAAMA,QAAsD;GAC1D,QAAgB,EAAE,SAAiB,YAAY,EAAE,QAAgB,QAAQ,GAAG;GAE5E,gBAAgB,EAAE,iBAAiB,YAAY,EAAE,gBAAgB,QAAQ,GAAG;GAC5E,QAAgB,EAAE,SAAiB,YAAY,EAAE,QAAgB,QAAQ,GAAG;GAC5E,aAAgB,EAAE,aAAc,KAAI,QAAK,YAAYC,KAAG,QAAQ,CAAC;GACjE,YAAgB,EAAE,YAAc,KAAI,QAAK,YAAYA,KAAG,QAAQ,CAAC;GACjE,UAAgB,EAAE,UAAc,KAAI,SAAM;IAAE,GAAGA;IAAG,IAAI,YAAYA,IAAE,IAAI,QAAQ;IAAE,EAAE;GACpF,cAAgB,EAAE,cAAc,KAAI,SAAM;IAAE,GAAGA;IAAG,IAAI,YAAYA,IAAE,IAAI,QAAQ;IAAE,EAAE;GACpF,QAAgB,EAAE,QAAc,KAAI,SAAM;IAAE,GAAGA;IAAG,IAAI,YAAYA,IAAE,IAAI,QAAQ;IAAE,SAASA,IAAE,SAAS,KAAI,MAAK,YAAY,GAAG,QAAQ,CAAC;IAAE,EAAE;GAC3I,WAAgB,EAAE,WAAc,KAAI,SAAM;IAAE,GAAGA;IAAG,WAAW,CAAC,YAAYA,IAAE,UAAU,IAAI,QAAQ,CAAC;IAAc,EAAE;GACnH,aAAgB,EAAE,aAAc,KAAI,QAAKA,MAAI,YAAYA,KAAG,QAAQ,GAAG,KAAK;GAC7E;AAGD,SAAO;GAAE,GAFQ,+BAA+B,GAAG,MAAM;GAEnC,GAAG;GAAO;GAChC"}
+{"version":3,"file":"events.js","names":["edges: SerializedEdgesOnlyVertexExport<EventVertex>","x"],"sources":["../../../src/core/to/events.ts"],"sourcesContent":["import type { Types } from '../types';\nimport type { OutTypes } from './schedules';\nimport { getVertexId } from '../util';\nimport { omitEdgesAndInternalProperties, type SerializedEdgesOnlyVertexExport, type SerializedEdgesShape } from './util';\nimport type { BaseOptions } from '../../common/types';\nimport type { EventVertex } from '../interfaces/vertices/events';\n\n\n\n\nexport default (\n  events:  Types.Mixed.Event[],\n  options: BaseOptions\n): OutTypes.event[] => {\n  return events\n    .map(x => {\n      const edges: SerializedEdgesOnlyVertexExport<EventVertex> = {\n        period:         x.period         ? getVertexId(x.period,         options) : undefined,\n        // overlapGroup:   x.overlapGroup   ? getVertexId(x.overlapGroup,   options) : undefined,\n        overlapSpecies: x.overlapSpecies ? getVertexId(x.overlapSpecies, options) : undefined,\n        course:         x.course         ? getVertexId(x.course,         options) : undefined,\n        lockedTimes:    x.lockedTimes ?.map(x => getVertexId(x, options)),\n        exceptions:     x.exceptions  ?.map(x => getVertexId(x, options)),\n        teachers:       x.teachers    ?.map(x => ({ ...x, to: getVertexId(x.to, options) })),\n        participants:   x.participants?.map(x => ({ ...x, to: getVertexId(x.to, options) })),\n        groups:         x.groups      ?.map(x => ({ ...x, to: getVertexId(x.to, options), exclude: x.exclude?.map(y => getVertexId(y, options)) })),\n        locations:      x.locations   ?.map(x => ({ ...x, locations: [getVertexId(x.locations[0], options)] as [string] })),\n        inLocations:    x.inLocations ?.map(x => x ? getVertexId(x, options) : null),\n        threads:        undefined\n      } satisfies SerializedEdgesShape<SerializedEdgesOnlyVertexExport<EventVertex>>;\n      const nonEdges = omitEdgesAndInternalProperties(x, edges);\n\n      return { ...nonEdges, ...edges };\n    });\n};\n\n"],"mappings":";;;;AAUA,sBACE,QACA,YACqB;AACrB,QAAO,OACJ,KAAI,MAAK;EACR,MAAMA,QAAsD;GAC1D,QAAgB,EAAE,SAAiB,YAAY,EAAE,QAAgB,WAAW;GAE5E,gBAAgB,EAAE,iBAAiB,YAAY,EAAE,gBAAgB,WAAW;GAC5E,QAAgB,EAAE,SAAiB,YAAY,EAAE,QAAgB,WAAW;GAC5E,aAAgB,EAAE,aAAc,KAAI,QAAK,YAAYC,KAAG;GACxD,YAAgB,EAAE,YAAc,KAAI,QAAK,YAAYA,KAAG;GACxD,UAAgB,EAAE,UAAc,KAAI,SAAM;IAAE,GAAGA;IAAG,IAAI,YAAYA,IAAE,IAAI;;GACxE,cAAgB,EAAE,cAAc,KAAI,SAAM;IAAE,GAAGA;IAAG,IAAI,YAAYA,IAAE,IAAI;;GACxE,QAAgB,EAAE,QAAc,KAAI,SAAM;IAAE,GAAGA;IAAG,IAAI,YAAYA,IAAE,IAAI;IAAU,SAASA,IAAE,SAAS,KAAI,MAAK,YAAY,GAAG;;GAC9H,WAAgB,EAAE,WAAc,KAAI,SAAM;IAAE,GAAGA;IAAG,WAAW,CAAC,YAAYA,IAAE,UAAU,IAAI;;GAC1F,aAAgB,EAAE,aAAc,KAAI,QAAKA,MAAI,YAAYA,KAAG,WAAW;GACvE,SAAgB;;EAElB,MAAM,WAAW,+BAA+B,GAAG;AAEnD,SAAO;GAAE,GAAG;GAAU,GAAG"}

package/dist/core/to/exceptions.js

@@ -17,8 +17,9 @@ var exceptions_default = (exceptions, options) => {
 			exceptions: x.exceptions?.map((x$1) => getVertexId(x$1, options)),
 			parentExceptions: x.parentExceptions?.map((x$1) => getVertexId(x$1, options))
 		};
+		const nonEdges = omitEdgesAndInternalProperties(x, edges);
 		return {
-			...omitEdgesAndInternalProperties(x, edges),
+			...nonEdges,
 			...edges
 		};
 	});

package/dist/core/to/exceptions.js.map

@@ -1 +1 @@
-{"version":3,"file":"exceptions.js","names":["edges: SerializedEdgesOnlyVertexExport<ExceptionVertex>","x"],"sources":["../../../src/core/to/exceptions.ts"],"sourcesContent":["import type { Types } from '../types';\nimport type { OutTypes } from './schedules';\nimport { getVertexId } from '../util';\nimport { omitEdgesAndInternalProperties, type SerializedEdgesOnlyVertexExport, type SerializedEdgesShape } from './util';\nimport type { BaseOptions } from '../../common/types';\nimport type { ExceptionVertex } from '../interfaces/vertices/exceptions';\nimport { omit } from 'lodash-es';\n\n\nexport default (\n  exceptions: Types.Mixed.Exception[],\n  options:    BaseOptions\n): OutTypes.exception[] => {\n  return exceptions\n    .map(x => {\n      const edges: SerializedEdgesOnlyVertexExport<ExceptionVertex> = {\n        exception: x.exception\n          ? {\n            ...omit(x.exception, 'to'),\n            ...x.exception.to && { to: getVertexId(x.exception.to, options) }\n          }\n          : undefined,\n        sources:          x.sources         ?.map(x => ({ toModel: x.toModel, to: getVertexId(x.to, options) })),\n        exceptions:       x.exceptions      ?.map(x => getVertexId(x, options)),\n        parentExceptions: x.parentExceptions?.map(x => getVertexId(x, options)),\n      } satisfies SerializedEdgesShape<SerializedEdgesOnlyVertexExport<ExceptionVertex>>;\n      const nonEdges = omitEdgesAndInternalProperties(x, edges);\n\n      return { ...nonEdges, ...edges };\n    });\n};\n"],"mappings":";;;;;AASA,0BACE,YACA,YACyB;AACzB,QAAO,WACJ,KAAI,MAAK;EACR,MAAMA,QAA0D;GAC9D,WAAW,EAAE,YACT;IACA,GAAG,KAAK,EAAE,WAAW,KAAK;IAC1B,GAAG,EAAE,UAAU,MAAM,EAAE,IAAI,YAAY,EAAE,UAAU,IAAI,QAAQ,EAAE;IAClE,GACC;GACJ,SAAkB,EAAE,SAAkB,KAAI,SAAM;IAAE,SAASC,IAAE;IAAS,IAAI,YAAYA,IAAE,IAAI,QAAQ;IAAE,EAAE;GACxG,YAAkB,EAAE,YAAkB,KAAI,QAAK,YAAYA,KAAG,QAAQ,CAAC;GACvE,kBAAkB,EAAE,kBAAkB,KAAI,QAAK,YAAYA,KAAG,QAAQ,CAAC;GACxE;AAGD,SAAO;GAAE,GAFQ,+BAA+B,GAAG,MAAM;GAEnC,GAAG;GAAO;GAChC"}
+{"version":3,"file":"exceptions.js","names":["edges: SerializedEdgesOnlyVertexExport<ExceptionVertex>","x"],"sources":["../../../src/core/to/exceptions.ts"],"sourcesContent":["import type { Types } from '../types';\nimport type { OutTypes } from './schedules';\nimport { getVertexId } from '../util';\nimport { omitEdgesAndInternalProperties, type SerializedEdgesOnlyVertexExport, type SerializedEdgesShape } from './util';\nimport type { BaseOptions } from '../../common/types';\nimport type { ExceptionVertex } from '../interfaces/vertices/exceptions';\nimport { omit } from 'lodash-es';\n\n\nexport default (\n  exceptions: Types.Mixed.Exception[],\n  options:    BaseOptions\n): OutTypes.exception[] => {\n  return exceptions\n    .map(x => {\n      const edges: SerializedEdgesOnlyVertexExport<ExceptionVertex> = {\n        exception: x.exception\n          ? {\n            ...omit(x.exception, 'to'),\n            ...x.exception.to && { to: getVertexId(x.exception.to, options) }\n          }\n          : undefined,\n        sources:          x.sources         ?.map(x => ({ toModel: x.toModel, to: getVertexId(x.to, options) })),\n        exceptions:       x.exceptions      ?.map(x => getVertexId(x, options)),\n        parentExceptions: x.parentExceptions?.map(x => getVertexId(x, options)),\n      } satisfies SerializedEdgesShape<SerializedEdgesOnlyVertexExport<ExceptionVertex>>;\n      const nonEdges = omitEdgesAndInternalProperties(x, edges);\n\n      return { ...nonEdges, ...edges };\n    });\n};\n"],"mappings":";;;;;AASA,0BACE,YACA,YACyB;AACzB,QAAO,WACJ,KAAI,MAAK;EACR,MAAMA,QAA0D;GAC9D,WAAW,EAAE,YACT;IACA,GAAG,KAAK,EAAE,WAAW;IACrB,GAAG,EAAE,UAAU,MAAM,EAAE,IAAI,YAAY,EAAE,UAAU,IAAI;OAEvD;GACJ,SAAkB,EAAE,SAAkB,KAAI,SAAM;IAAE,SAASC,IAAE;IAAS,IAAI,YAAYA,IAAE,IAAI;;GAC5F,YAAkB,EAAE,YAAkB,KAAI,QAAK,YAAYA,KAAG;GAC9D,kBAAkB,EAAE,kBAAkB,KAAI,QAAK,YAAYA,KAAG;;EAEhE,MAAM,WAAW,+BAA+B,GAAG;AAEnD,SAAO;GAAE,GAAG;GAAU,GAAG"}

package/dist/core/to/groups.js

@@ -13,8 +13,9 @@ var groups_default = (groups, options) => {
 			parentGroups: x.parentGroups?.map((x$1) => getVertexId(x$1, options)),
 			subGroups: x.subGroups?.map((x$1) => getVertexId(x$1, options))
 		};
+		const nonEdges = omitEdgesAndInternalProperties(x, edges);
 		return {
-			...omitEdgesAndInternalProperties(x, edges),
+			...nonEdges,
 			...edges
 		};
 	});

package/dist/core/to/groups.js.map

@@ -1 +1 @@
-{"version":3,"file":"groups.js","names":["edges: SerializedEdgesOnlyVertexExport<GroupVertex>","x"],"sources":["../../../src/core/to/groups.ts"],"sourcesContent":["import type { Types } from '../types';\nimport type { OutTypes } from './schedules';\nimport { getVertexId } from '../util';\nimport { omitEdgesAndInternalProperties, type SerializedEdgesOnlyVertexExport, type SerializedEdgesShape } from './util';\nimport type { BaseOptions } from '../../common/types';\nimport type { GroupVertex } from '../interfaces/vertices/groups';\n\nexport default (\n  groups:  Types.Mixed.Group[],\n  options: BaseOptions\n): OutTypes.group[] => {\n  return groups\n    .map(x => {\n      const edges: SerializedEdgesOnlyVertexExport<GroupVertex> = {\n        rootInterval: x.rootInterval ? getVertexId(x.rootInterval, options) : undefined,\n        exceptions:   x.exceptions  ?.map(x => getVertexId(x, options)),\n        lockedTimes:  x.lockedTimes ?.map(x => getVertexId(x, options)),\n        lunch:        x.lunch       ?.map(x => getVertexId(x, options)),\n        members:      x.members     ?.map(x => getVertexId(x, options)),\n        parentGroups: x.parentGroups?.map(x => getVertexId(x, options)),\n        subGroups:    x.subGroups   ?.map(x => getVertexId(x, options)),\n      } satisfies SerializedEdgesShape<SerializedEdgesOnlyVertexExport<GroupVertex>>;\n      const nonEdges = omitEdgesAndInternalProperties(x, edges);\n\n      return { ...nonEdges, ...edges };\n    });\n};\n"],"mappings":";;;;AAOA,sBACE,QACA,YACqB;AACrB,QAAO,OACJ,KAAI,MAAK;EACR,MAAMA,QAAsD;GAC1D,cAAc,EAAE,eAAe,YAAY,EAAE,cAAc,QAAQ,GAAG;GACtE,YAAc,EAAE,YAAc,KAAI,QAAK,YAAYC,KAAG,QAAQ,CAAC;GAC/D,aAAc,EAAE,aAAc,KAAI,QAAK,YAAYA,KAAG,QAAQ,CAAC;GAC/D,OAAc,EAAE,OAAc,KAAI,QAAK,YAAYA,KAAG,QAAQ,CAAC;GAC/D,SAAc,EAAE,SAAc,KAAI,QAAK,YAAYA,KAAG,QAAQ,CAAC;GAC/D,cAAc,EAAE,cAAc,KAAI,QAAK,YAAYA,KAAG,QAAQ,CAAC;GAC/D,WAAc,EAAE,WAAc,KAAI,QAAK,YAAYA,KAAG,QAAQ,CAAC;GAChE;AAGD,SAAO;GAAE,GAFQ,+BAA+B,GAAG,MAAM;GAEnC,GAAG;GAAO;GAChC"}
+{"version":3,"file":"groups.js","names":["edges: SerializedEdgesOnlyVertexExport<GroupVertex>","x"],"sources":["../../../src/core/to/groups.ts"],"sourcesContent":["import type { Types } from '../types';\nimport type { OutTypes } from './schedules';\nimport { getVertexId } from '../util';\nimport { omitEdgesAndInternalProperties, type SerializedEdgesOnlyVertexExport, type SerializedEdgesShape } from './util';\nimport type { BaseOptions } from '../../common/types';\nimport type { GroupVertex } from '../interfaces/vertices/groups';\n\nexport default (\n  groups:  Types.Mixed.Group[],\n  options: BaseOptions\n): OutTypes.group[] => {\n  return groups\n    .map(x => {\n      const edges: SerializedEdgesOnlyVertexExport<GroupVertex> = {\n        rootInterval: x.rootInterval ? getVertexId(x.rootInterval, options) : undefined,\n        exceptions:   x.exceptions  ?.map(x => getVertexId(x, options)),\n        lockedTimes:  x.lockedTimes ?.map(x => getVertexId(x, options)),\n        lunch:        x.lunch       ?.map(x => getVertexId(x, options)),\n        members:      x.members     ?.map(x => getVertexId(x, options)),\n        parentGroups: x.parentGroups?.map(x => getVertexId(x, options)),\n        subGroups:    x.subGroups   ?.map(x => getVertexId(x, options)),\n      } satisfies SerializedEdgesShape<SerializedEdgesOnlyVertexExport<GroupVertex>>;\n      const nonEdges = omitEdgesAndInternalProperties(x, edges);\n\n      return { ...nonEdges, ...edges };\n    });\n};\n"],"mappings":";;;;AAOA,sBACE,QACA,YACqB;AACrB,QAAO,OACJ,KAAI,MAAK;EACR,MAAMA,QAAsD;GAC1D,cAAc,EAAE,eAAe,YAAY,EAAE,cAAc,WAAW;GACtE,YAAc,EAAE,YAAc,KAAI,QAAK,YAAYC,KAAG;GACtD,aAAc,EAAE,aAAc,KAAI,QAAK,YAAYA,KAAG;GACtD,OAAc,EAAE,OAAc,KAAI,QAAK,YAAYA,KAAG;GACtD,SAAc,EAAE,SAAc,KAAI,QAAK,YAAYA,KAAG;GACtD,cAAc,EAAE,cAAc,KAAI,QAAK,YAAYA,KAAG;GACtD,WAAc,EAAE,WAAc,KAAI,QAAK,YAAYA,KAAG;;EAExD,MAAM,WAAW,+BAA+B,GAAG;AAEnD,SAAO;GAAE,GAAG;GAAU,GAAG"}

package/dist/core/to/locations.js

@@ -9,8 +9,9 @@ var locations_default = (locations, options) => {
 			lockedTimes: x.lockedTimes?.map((x$1) => getVertexId(x$1, options)),
 			lunch: x.lunch?.map((x$1) => getVertexId(x$1, options))
 		};
+		const nonEdges = omitEdgesAndInternalProperties(x, edges);
 		return {
-			...omitEdgesAndInternalProperties(x, edges),
+			...nonEdges,
 			...edges
 		};
 	});

package/dist/core/to/locations.js.map

@@ -1 +1 @@
-{"version":3,"file":"locations.js","names":["edges: SerializedEdgesOnlyVertexExport<LocationVertex>","x"],"sources":["../../../src/core/to/locations.ts"],"sourcesContent":["import type { Types } from '../types';\nimport type { OutTypes } from './schedules';\nimport { getVertexId } from '../util';\nimport { omitEdgesAndInternalProperties, type SerializedEdgesOnlyVertexExport, type SerializedEdgesShape } from './util';\nimport type { BaseOptions } from '../../common/types';\nimport type { LocationVertex } from '../interfaces/vertices/locations';\n\nexport default (\n  locations: Types.Mixed.Location[],\n  options:   BaseOptions\n): OutTypes.location[] => {\n  return locations\n    .map(x => {\n      const edges: SerializedEdgesOnlyVertexExport<LocationVertex> = {\n        exceptions:  x.exceptions ?.map(x => getVertexId(x, options)),\n        lockedTimes: x.lockedTimes?.map(x => getVertexId(x, options)),\n        lunch:       x.lunch      ?.map(x => getVertexId(x, options)),\n      } satisfies SerializedEdgesShape<SerializedEdgesOnlyVertexExport<LocationVertex>>;\n      const nonEdges = omitEdgesAndInternalProperties(x, edges);\n\n      return { ...nonEdges, ...edges };\n    });\n};\n"],"mappings":";;;;AAOA,yBACE,WACA,YACwB;AACxB,QAAO,UACJ,KAAI,MAAK;EACR,MAAMA,QAAyD;GAC7D,YAAa,EAAE,YAAa,KAAI,QAAK,YAAYC,KAAG,QAAQ,CAAC;GAC7D,aAAa,EAAE,aAAa,KAAI,QAAK,YAAYA,KAAG,QAAQ,CAAC;GAC7D,OAAa,EAAE,OAAa,KAAI,QAAK,YAAYA,KAAG,QAAQ,CAAC;GAC9D;AAGD,SAAO;GAAE,GAFQ,+BAA+B,GAAG,MAAM;GAEnC,GAAG;GAAO;GAChC"}
+{"version":3,"file":"locations.js","names":["edges: SerializedEdgesOnlyVertexExport<LocationVertex>","x"],"sources":["../../../src/core/to/locations.ts"],"sourcesContent":["import type { Types } from '../types';\nimport type { OutTypes } from './schedules';\nimport { getVertexId } from '../util';\nimport { omitEdgesAndInternalProperties, type SerializedEdgesOnlyVertexExport, type SerializedEdgesShape } from './util';\nimport type { BaseOptions } from '../../common/types';\nimport type { LocationVertex } from '../interfaces/vertices/locations';\n\nexport default (\n  locations: Types.Mixed.Location[],\n  options:   BaseOptions\n): OutTypes.location[] => {\n  return locations\n    .map(x => {\n      const edges: SerializedEdgesOnlyVertexExport<LocationVertex> = {\n        exceptions:  x.exceptions ?.map(x => getVertexId(x, options)),\n        lockedTimes: x.lockedTimes?.map(x => getVertexId(x, options)),\n        lunch:       x.lunch      ?.map(x => getVertexId(x, options)),\n      } satisfies SerializedEdgesShape<SerializedEdgesOnlyVertexExport<LocationVertex>>;\n      const nonEdges = omitEdgesAndInternalProperties(x, edges);\n\n      return { ...nonEdges, ...edges };\n    });\n};\n"],"mappings":";;;;AAOA,yBACE,WACA,YACwB;AACxB,QAAO,UACJ,KAAI,MAAK;EACR,MAAMA,QAAyD;GAC7D,YAAa,EAAE,YAAa,KAAI,QAAK,YAAYC,KAAG;GACpD,aAAa,EAAE,aAAa,KAAI,QAAK,YAAYA,KAAG;GACpD,OAAa,EAAE,OAAa,KAAI,QAAK,YAAYA,KAAG;;EAEtD,MAAM,WAAW,+BAA+B,GAAG;AAEnD,SAAO;GAAE,GAAG;GAAU,GAAG"}

package/dist/core/to/locked-times.js

@@ -8,8 +8,9 @@ var locked_times_default = (lockedTimes, options) => {
 			toModel: x$1.toModel,
 			to: getVertexId(x$1.to, options)
 		})) };
+		const nonEdges = omitEdgesAndInternalProperties(x, edges);
 		return {
-			...omitEdgesAndInternalProperties(x, edges),
+			...nonEdges,
 			...edges
 		};
 	});

package/dist/core/to/locked-times.js.map

@@ -1 +1 @@
-{"version":3,"file":"locked-times.js","names":["edges: SerializedEdgesOnlyVertexExport<LockedTimeVertex>","x"],"sources":["../../../src/core/to/locked-times.ts"],"sourcesContent":["import type { Types } from '../types';\nimport type { OutTypes } from './schedules';\nimport { getVertexId } from '../util';\nimport { omitEdgesAndInternalProperties, type SerializedEdgesOnlyVertexExport, type SerializedEdgesShape } from './util';\nimport type { BaseOptions } from '../../common/types';\nimport type { LockedTimeVertex } from '../interfaces/vertices/locked-times';\n\nexport default (\n  lockedTimes: Types.Mixed.LockedTime[],\n  options:     BaseOptions\n): OutTypes.lockedTime[] => {\n  return lockedTimes\n    .map(x => {\n      const edges: SerializedEdgesOnlyVertexExport<LockedTimeVertex> = {\n        coalesced: x.coalesced?.map(x => ({ toModel: x.toModel, to: getVertexId(x.to, options) })),\n      } satisfies SerializedEdgesShape<SerializedEdgesOnlyVertexExport<LockedTimeVertex>>;\n      const nonEdges = omitEdgesAndInternalProperties(x, edges);\n\n      return { ...nonEdges, ...edges };\n    });\n};\n"],"mappings":";;;;AAOA,4BACE,aACA,YAC0B;AAC1B,QAAO,YACJ,KAAI,MAAK;EACR,MAAMA,QAA2D,EAC/D,WAAW,EAAE,WAAW,KAAI,SAAM;GAAE,SAASC,IAAE;GAAS,IAAI,YAAYA,IAAE,IAAI,QAAQ;GAAE,EAAE,EAC3F;AAGD,SAAO;GAAE,GAFQ,+BAA+B,GAAG,MAAM;GAEnC,GAAG;GAAO;GAChC"}
+{"version":3,"file":"locked-times.js","names":["edges: SerializedEdgesOnlyVertexExport<LockedTimeVertex>","x"],"sources":["../../../src/core/to/locked-times.ts"],"sourcesContent":["import type { Types } from '../types';\nimport type { OutTypes } from './schedules';\nimport { getVertexId } from '../util';\nimport { omitEdgesAndInternalProperties, type SerializedEdgesOnlyVertexExport, type SerializedEdgesShape } from './util';\nimport type { BaseOptions } from '../../common/types';\nimport type { LockedTimeVertex } from '../interfaces/vertices/locked-times';\n\nexport default (\n  lockedTimes: Types.Mixed.LockedTime[],\n  options:     BaseOptions\n): OutTypes.lockedTime[] => {\n  return lockedTimes\n    .map(x => {\n      const edges: SerializedEdgesOnlyVertexExport<LockedTimeVertex> = {\n        coalesced: x.coalesced?.map(x => ({ toModel: x.toModel, to: getVertexId(x.to, options) })),\n      } satisfies SerializedEdgesShape<SerializedEdgesOnlyVertexExport<LockedTimeVertex>>;\n      const nonEdges = omitEdgesAndInternalProperties(x, edges);\n\n      return { ...nonEdges, ...edges };\n    });\n};\n"],"mappings":";;;;AAOA,4BACE,aACA,YAC0B;AAC1B,QAAO,YACJ,KAAI,MAAK;EACR,MAAMA,QAA2D,EAC/D,WAAW,EAAE,WAAW,KAAI,SAAM;GAAE,SAASC,IAAE;GAAS,IAAI,YAAYA,IAAE,IAAI;;EAEhF,MAAM,WAAW,+BAA+B,GAAG;AAEnD,SAAO;GAAE,GAAG;GAAU,GAAG"}

package/dist/core/to/overlap-groups.js

@@ -15,8 +15,9 @@ var overlap_groups_default = (overlapGroups, options) => {
 				to: getVertexId(x$1.to, options)
 			}))
 		};
+		const nonEdges = omitEdgesAndInternalProperties(x, edges);
 		return {
-			...omitEdgesAndInternalProperties(x, edges),
+			...nonEdges,
 			...edges
 		};
 	});

package/dist/core/to/overlap-groups.js.map

@@ -1 +1 @@
-{"version":3,"file":"overlap-groups.js","names":["edges: SerializedEdgesOnlyVertexExport<OverlapGroupVertex>","x"],"sources":["../../../src/core/to/overlap-groups.ts"],"sourcesContent":["import type { Types } from '../types';\nimport type { OutTypes } from './schedules';\nimport { getVertexId } from '../util';\nimport { omitEdgesAndInternalProperties, type SerializedEdgesOnlyVertexExport, type SerializedEdgesShape } from './util';\nimport type { BaseOptions } from '../../common/types';\nimport type { OverlapGroupVertex } from '../interfaces/vertices/overlap-groups';\n\nexport default (\n  overlapGroups: Types.Mixed.OverlapGroup[],\n  options:       BaseOptions\n): OutTypes.overlapGroup[] => {\n  return overlapGroups\n    .map(x => {\n      const edges: SerializedEdgesOnlyVertexExport<OverlapGroupVertex> = {\n        coalesced: x.coalesced?.map(x => ({ toModel: x.toModel,           to: getVertexId(x.to, options) })),\n        species:   x.species  ?.map(x => ({ toModel: x.toModel, id: x.id, to: getVertexId(x.to, options) })),\n      } satisfies SerializedEdgesShape<SerializedEdgesOnlyVertexExport<OverlapGroupVertex>>;\n      const nonEdges = omitEdgesAndInternalProperties(x, edges);\n\n      return { ...nonEdges, ...edges };\n    });\n};\n"],"mappings":";;;;AAOA,8BACE,eACA,YAC4B;AAC5B,QAAO,cACJ,KAAI,MAAK;EACR,MAAMA,QAA6D;GACjE,WAAW,EAAE,WAAW,KAAI,SAAM;IAAE,SAASC,IAAE;IAAmB,IAAI,YAAYA,IAAE,IAAI,QAAQ;IAAE,EAAE;GACpG,SAAW,EAAE,SAAW,KAAI,SAAM;IAAE,SAASA,IAAE;IAAS,IAAIA,IAAE;IAAI,IAAI,YAAYA,IAAE,IAAI,QAAQ;IAAE,EAAE;GACrG;AAGD,SAAO;GAAE,GAFQ,+BAA+B,GAAG,MAAM;GAEnC,GAAG;GAAO;GAChC"}
+{"version":3,"file":"overlap-groups.js","names":["edges: SerializedEdgesOnlyVertexExport<OverlapGroupVertex>","x"],"sources":["../../../src/core/to/overlap-groups.ts"],"sourcesContent":["import type { Types } from '../types';\nimport type { OutTypes } from './schedules';\nimport { getVertexId } from '../util';\nimport { omitEdgesAndInternalProperties, type SerializedEdgesOnlyVertexExport, type SerializedEdgesShape } from './util';\nimport type { BaseOptions } from '../../common/types';\nimport type { OverlapGroupVertex } from '../interfaces/vertices/overlap-groups';\n\nexport default (\n  overlapGroups: Types.Mixed.OverlapGroup[],\n  options:       BaseOptions\n): OutTypes.overlapGroup[] => {\n  return overlapGroups\n    .map(x => {\n      const edges: SerializedEdgesOnlyVertexExport<OverlapGroupVertex> = {\n        coalesced: x.coalesced?.map(x => ({ toModel: x.toModel,           to: getVertexId(x.to, options) })),\n        species:   x.species  ?.map(x => ({ toModel: x.toModel, id: x.id, to: getVertexId(x.to, options) })),\n      } satisfies SerializedEdgesShape<SerializedEdgesOnlyVertexExport<OverlapGroupVertex>>;\n      const nonEdges = omitEdgesAndInternalProperties(x, edges);\n\n      return { ...nonEdges, ...edges };\n    });\n};\n"],"mappings":";;;;AAOA,8BACE,eACA,YAC4B;AAC5B,QAAO,cACJ,KAAI,MAAK;EACR,MAAMA,QAA6D;GACjE,WAAW,EAAE,WAAW,KAAI,SAAM;IAAE,SAASC,IAAE;IAAmB,IAAI,YAAYA,IAAE,IAAI;;GACxF,SAAW,EAAE,SAAW,KAAI,SAAM;IAAE,SAASA,IAAE;IAAS,IAAIA,IAAE;IAAI,IAAI,YAAYA,IAAE,IAAI;;;EAE1F,MAAM,WAAW,+BAA+B,GAAG;AAEnD,SAAO;GAAE,GAAG;GAAU,GAAG"}

package/dist/core/to/periods.js

@@ -4,8 +4,9 @@ import { omitEdgesAndInternalProperties } from "./util.js";
 var periods_default = (periods, options) => {
 	return periods.map((x) => {
 		const edges = {};
+		const nonEdges = omitEdgesAndInternalProperties(x, edges);
 		return {
-			...omitEdgesAndInternalProperties(x, edges),
+			...nonEdges,
 			...edges
 		};
 	});

package/dist/core/to/periods.js.map

@@ -1 +1 @@
-{"version":3,"file":"periods.js","names":["edges: SerializedEdgesOnlyVertexExport<PeriodVertex>"],"sources":["../../../src/core/to/periods.ts"],"sourcesContent":["import type { Types } from '../types';\nimport type { OutTypes } from './schedules';\nimport { omitEdgesAndInternalProperties, type SerializedEdgesOnlyVertexExport, type SerializedEdgesShape } from './util';\nimport type { BaseOptions } from '../../common/types';\nimport type { PeriodVertex } from '../interfaces/vertices/periods';\n\nexport default (\n  periods: Types.Mixed.Period[],\n  options: BaseOptions\n): OutTypes.period[] => {\n  return periods\n    .map(x => {\n      const edges: SerializedEdgesOnlyVertexExport<PeriodVertex> = {\n      } satisfies SerializedEdgesShape<SerializedEdgesOnlyVertexExport<PeriodVertex>>;\n      const nonEdges = omitEdgesAndInternalProperties(x, edges);\n\n      return { ...nonEdges, ...edges };\n    });\n};\n"],"mappings":";;;AAMA,uBACE,SACA,YACsB;AACtB,QAAO,QACJ,KAAI,MAAK;EACR,MAAMA,QAAuD,EAC5D;AAGD,SAAO;GAAE,GAFQ,+BAA+B,GAAG,MAAM;GAEnC,GAAG;GAAO;GAChC"}
+{"version":3,"file":"periods.js","names":["edges: SerializedEdgesOnlyVertexExport<PeriodVertex>"],"sources":["../../../src/core/to/periods.ts"],"sourcesContent":["import type { Types } from '../types';\nimport type { OutTypes } from './schedules';\nimport { omitEdgesAndInternalProperties, type SerializedEdgesOnlyVertexExport, type SerializedEdgesShape } from './util';\nimport type { BaseOptions } from '../../common/types';\nimport type { PeriodVertex } from '../interfaces/vertices/periods';\n\nexport default (\n  periods: Types.Mixed.Period[],\n  options: BaseOptions\n): OutTypes.period[] => {\n  return periods\n    .map(x => {\n      const edges: SerializedEdgesOnlyVertexExport<PeriodVertex> = {\n      } satisfies SerializedEdgesShape<SerializedEdgesOnlyVertexExport<PeriodVertex>>;\n      const nonEdges = omitEdgesAndInternalProperties(x, edges);\n\n      return { ...nonEdges, ...edges };\n    });\n};\n"],"mappings":";;;AAMA,uBACE,SACA,YACsB;AACtB,QAAO,QACJ,KAAI,MAAK;EACR,MAAMA,QAAuD;EAE7D,MAAM,WAAW,+BAA+B,GAAG;AAEnD,SAAO;GAAE,GAAG;GAAU,GAAG"}