@royalschedule/maps 4.0.31 → 4.0.33

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

@@ -1,4 +1,5 @@
 import { EdgeWrapper, Plain } from "../util/edges.js";
+import "../util/index.js";
 import { DivisionVertex } from "../divisions.js";
 
 //#region src/core/interfaces/vertices/properties/belongs-to.d.ts

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

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

package/dist/core/interfaces/vertices/root-intervals.d.ts

@@ -1,5 +1,7 @@
 import { VertexFactory } from "./util/vertex.js";
+import "./util/index.js";
 import { Interval } from "./properties/intervals.js";
+import "./properties/index.js";
 import { BelongsTo } from "./properties/belongs-to.js";
 import { Moment } from "moment";
 

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

@@ -1,4 +1,5 @@
 import { VertexFactory } from "./util/vertex.js";
+import "./util/index.js";
 import { BelongsTo } from "./properties/belongs-to.js";
 
 //#region src/core/interfaces/vertices/syllabuses.d.ts

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

@@ -1,5 +1,6 @@
 import { VertexFactory } from "./util/vertex.js";
 import { EdgeWrapper, Plain } from "./util/edges.js";
+import "./util/index.js";
 import { Day } from "./properties/days.js";
 import { Interval } from "./properties/intervals.js";
 import { Tag } from "./properties/tags.js";

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

@@ -1,5 +1,6 @@
 import { VertexFactory } from "./util/vertex.js";
-import { Coalesced, EdgeWrapper, ThreadMessage } from "./util/edges.js";
+import { Coalesced, EdgeWrapper, Plain, ThreadMessage } from "./util/edges.js";
+import "./util/index.js";
 import { UserVertex } from "./users.js";
 import { EventVertex } from "./events.js";
 
@@ -13,12 +14,13 @@ type ThreadVertex = VertexFactory<'threads', {
   source?: EdgeWrapper<'single', Coalesced.Edge<EventVertex>>;
   state?: State;
   messages: EdgeWrapper<'array', ThreadMessage.Edge<UserVertex, UserVertex, {
-    _id: string;
+    id: string;
     content: string;
     edited?: boolean;
-    createdAt: string | Date;
-    updatedAt: string | Date;
+    createdAt?: string | Date;
+    updatedAt?: string | Date;
   }>>;
+  taggedPersons?: EdgeWrapper<'array', Plain.Edge<UserVertex>>;
   color?: string;
   resolved?: boolean;
   positionMeta?: {

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

@@ -1,4 +1,5 @@
 import { VertexFactory } from "./util/vertex.js";
+import "./util/index.js";
 
 //#region src/core/interfaces/vertices/users.d.ts
 type UserVertex = VertexFactory<'users', {

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

@@ -10,12 +10,12 @@ import { AssertNoInvalidExpandKeys } from "./assert-no-invalid-expand-keys.js";
 //#region src/core/interfaces/vertices/util/custom-vertex-export/index.d.ts
 declare namespace HandleEdge {
   type Recursion<V extends Vertex<Collection>, Query> = [Query] extends [never] ? string : Query extends VertexQuery<V> ? _CustomVertexExport<V, Query> : never;
-  export type Plain<E extends EdgeBase<any, any>, Query> = E extends Plain.Edge<infer V> ? Recursion<V, Query> : never;
-  export type Wrapped<E extends EdgeBase<any, any>, Query> = E extends Wrapped.Edge<infer K, infer V extends Vertex<Collection>, infer Extra extends object> ? Wrapped.Util.Value<K, Recursion<V, IntersectExpandSelectPath<Lookup<Query, K>, VertexQuery<V>>>, Extra> : never;
-  export type Coalesced<E extends EdgeBase<any, any>, Query> = E extends Coalesced.Edge<infer V, infer O, infer Extra extends object> ? V extends Vertex<Collection> ? Coalesced.Util.Value<Recursion<V, IntersectExpandSelectPath<Lookup<Query, Coalesced.Util.Keys.To>, VertexQuery<V>>>, Coalesced.Util.ToModel<V>, O, Extra> : never : never;
-  export type GroupWithExclude<E extends EdgeBase<any, any>, Query> = E extends GroupWithExclude.Edge<infer G extends Vertex<any>, infer P extends Vertex<any>, infer Extra extends object> ? GroupWithExclude.Util.Value<Recursion<G, IntersectExpandSelectPath<Lookup<Query, GroupWithExclude.Util.Keys.To>, VertexQuery<G>>>, Recursion<P, IntersectExpandSelectPath<Lookup<Query, GroupWithExclude.Util.Keys.Exclude>, VertexQuery<P>>>, Extra> : never;
-  export type AvailableLocation<E extends EdgeBase<any, any>, Query> = E extends AvailableLocation.Edge<infer L extends Vertex<any>, infer Extra extends object> ? AvailableLocation.Util.Value<Recursion<L, IntersectExpandSelectPath<Lookup<Query, AvailableLocation.Util.Keys.Locations>, VertexQuery<L>>>, Extra> : never;
-  export type ThreadMessage<E extends EdgeBase<any, any>, Query> = E extends ThreadMessage.Edge<infer U extends Vertex<Collection>, infer T extends Vertex<Collection>, infer Extra extends object> ? ThreadMessage.Util.Value<Recursion<U, IntersectExpandSelectPath<Lookup<Query, ThreadMessage.Util.Keys.User>, VertexQuery<U>>>, Recursion<T, IntersectExpandSelectPath<Lookup<Query, ThreadMessage.Util.Keys.TaggedPersons>, VertexQuery<T>>>, Extra> : never;
+  export type Plain<E$1 extends EdgeBase<any, any>, Query> = E$1 extends Plain.Edge<infer V> ? Recursion<V, Query> : never;
+  export type Wrapped<E$1 extends EdgeBase<any, any>, Query> = E$1 extends Wrapped.Edge<infer K, infer V extends Vertex<Collection>, infer Extra extends object> ? Wrapped.Util.Value<K, Recursion<V, IntersectExpandSelectPath<Lookup<Query, K>, VertexQuery<V>>>, Extra> : never;
+  export type Coalesced<E$1 extends EdgeBase<any, any>, Query> = E$1 extends Coalesced.Edge<infer V, infer O, infer Extra extends object> ? V extends Vertex<Collection> ? Coalesced.Util.Value<Recursion<V, IntersectExpandSelectPath<Lookup<Query, Coalesced.Util.Keys.To>, VertexQuery<V>>>, Coalesced.Util.ToModel<V>, O, Extra> : never : never;
+  export type GroupWithExclude<E$1 extends EdgeBase<any, any>, Query> = E$1 extends GroupWithExclude.Edge<infer G extends Vertex<any>, infer P extends Vertex<any>, infer Extra extends object> ? GroupWithExclude.Util.Value<Recursion<G, IntersectExpandSelectPath<Lookup<Query, GroupWithExclude.Util.Keys.To>, VertexQuery<G>>>, Recursion<P, IntersectExpandSelectPath<Lookup<Query, GroupWithExclude.Util.Keys.Exclude>, VertexQuery<P>>>, Extra> : never;
+  export type AvailableLocation<E$1 extends EdgeBase<any, any>, Query> = E$1 extends AvailableLocation.Edge<infer L extends Vertex<any>, infer Extra extends object> ? AvailableLocation.Util.Value<Recursion<L, IntersectExpandSelectPath<Lookup<Query, AvailableLocation.Util.Keys.Locations>, VertexQuery<L>>>, Extra> : never;
+  export type ThreadMessage<E$1 extends EdgeBase<any, any>, Query> = E$1 extends ThreadMessage.Edge<infer U extends Vertex<Collection>, infer T extends Vertex<Collection>, infer Extra extends object> ? ThreadMessage.Util.Value<Recursion<U, IntersectExpandSelectPath<Lookup<Query, ThreadMessage.Util.Keys.User>, VertexQuery<U>>>, Recursion<T, IntersectExpandSelectPath<Lookup<Query, ThreadMessage.Util.Keys.TaggedPersons>, VertexQuery<T>>>, Extra> : never;
   export {};
 }
 type _CustomVertexExport<V extends Vertex<Collection>, Q extends VertexQuery<V>> = Prettify<{ [K in keyof OmitEdges<V> as K extends KeysOf<V, Q> ? K : never]: V[K] } & { [K in keyof PickEdges<V> as K extends ExtractParentKeys<KeysOf<V, Q>> ? K : never]: [V[K]] extends [never] ? never : NonNullable<V[K]> extends EdgeWrapper<infer M, infer E extends EdgeBase<any, any> | null | undefined> ? (SetMultiplicity<Prettify<E extends EdgeBase<any, any> ? (HandleEdge.Plain<E, Lookup<Q[ExpandKey], K>> | RelaxedPick<HandleEdge.Wrapped<E, ExtractChildObject<Q[ExpandKey], K>> | HandleEdge.Coalesced<E, ExtractChildObject<Q[ExpandKey], K>> | HandleEdge.GroupWithExclude<E, ExtractChildObject<Q[ExpandKey], K>> | HandleEdge.AvailableLocation<E, ExtractChildObject<Q[ExpandKey], K>> | HandleEdge.ThreadMessage<E, ExtractChildObject<Q[ExpandKey], K>>, ExtractChildKeys<KeysOf<V, Q>, K>>) : E>, M> | ExtractNullish<V[K]>) : never }>;

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

@@ -6,7 +6,7 @@ import { ExpandKey, SelectKey } from "../common.js";
 /**
  * Lookup type that returns the value type for key K in object Obj,
  */
-type Lookup<Obj, K, ELSE = never> = K extends keyof Obj ? Obj[K] : ELSE;
+type Lookup<Obj, K$1, ELSE = never> = K$1 extends keyof Obj ? Obj[K$1] : ELSE;
 /**
  * Intersect two expand/select specifications.
  *
@@ -19,8 +19,8 @@ type Lookup<Obj, K, ELSE = never> = K extends keyof Obj ? Obj[K] : ELSE;
  * Useful to constrain a requested expand/select spec (A) by an allowed/spec (B),
  * yielding only the common subset.
  */
-type IntersectExpandSelectPath<A, B> = _IntersectExpandSelectPath<DeepNonNullable<A>, DeepNonNullable<B>>;
-type _IntersectExpandSelectPath<A, B> = [A] extends [never] ? never : { [K in keyof A & keyof B]: K extends SelectKey ? A[K] extends (infer V1)[] ? B[K] extends (infer V2)[] ? (V1 & V2)[] | Extract<A[K], null | undefined> : never : never : K extends ExpandKey ? { [S in keyof A[K] & keyof B[K]]: A[K][S] extends object ? B[K][S] extends object ? IntersectExpandSelectPath<A[K][S], B[K][S]> : never : never } : never };
+type IntersectExpandSelectPath<A, B$1> = _IntersectExpandSelectPath<DeepNonNullable<A>, DeepNonNullable<B$1>>;
+type _IntersectExpandSelectPath<A, B$1> = [A] extends [never] ? never : { [K in keyof A & keyof B$1]: K extends SelectKey ? A[K] extends (infer V1)[] ? B$1[K] extends (infer V2)[] ? (V1 & V2)[] | Extract<A[K], null | undefined> : never : never : K extends ExpandKey ? { [S in keyof A[K] & keyof B$1[K]]: A[K][S] extends object ? B$1[K][S] extends object ? IntersectExpandSelectPath<A[K][S], B$1[K][S]> : never : never } : never };
 /**
  * Extracts the parent keys from a set of dot-notation keys.
  *
@@ -43,7 +43,7 @@ type ExtractChildKeys<Keys extends keyof any, ParentKey extends string> = Keys e
  * ParentKey: 'a'
  * Object:    { 'a': string; 'a.1': number; 'a.2': boolean; 'b.1': string; 'c': Date }  =>  { '1': number; '2': boolean }
  */
-type ExtractChildObject<Object, ParentKey> = { [K in keyof Object as K extends `${ParentKey & string}.${infer S}` ? S : never]: Object[K] };
+type ExtractChildObject<Object$1, ParentKey> = { [K in keyof Object$1 as K extends `${ParentKey & string}.${infer S}` ? S : never]: Object$1[K] };
 /**
  * Does the same as the built-in Pick<T, Keys>, but does not restrict the Keys to keyof T. Nullish and undefined values are preserved.
  */

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

@@ -12,19 +12,19 @@ type ExportOptions = {
 type IDTypes = IDType | PrivateIDType;
 declare namespace HandleEdge {
   type Recursion<V extends Vertex<Collection>, D extends SupportedDepths, Opts extends ExportOptions> = _DeepVertexExport<V, Decrement<D>, Opts> | (Opts['mixed'] extends true ? IDTypes : never);
-  export type Plain<E extends EdgeBase<any, any>, D extends SupportedDepths, Opts extends ExportOptions> = E extends Plain.Edge<infer V> ? Recursion<V, D, Opts> : never;
-  export type Wrapped<E extends EdgeBase<any, any>, D extends SupportedDepths, Opts extends ExportOptions> = E extends Wrapped.Edge<infer K, infer V extends Vertex<any>, infer Extra extends object> ? Wrapped.Util.Value<K, Recursion<V, D, Opts>, Extra> : never;
-  export type Coalesced<E extends EdgeBase<any, any>, D extends SupportedDepths, Opts extends ExportOptions> = E extends Coalesced.Edge<infer V, infer O extends object, infer Extra extends object> ? V extends Vertex<Collection> ? Coalesced.Util.Value<Recursion<V, D, Opts>, Coalesced.Util.ToModel<V>, O, Extra> : never : never;
-  export type GroupWithExclude<E extends EdgeBase<any, any>, D extends SupportedDepths, Opts extends ExportOptions> = E extends GroupWithExclude.Edge<infer G extends Vertex<any>, infer P extends Vertex<any>, infer Extra extends object> ? GroupWithExclude.Util.Value<Recursion<G, D, Opts>, Recursion<P, D, Opts>, Extra> : never;
-  export type AvailableLocation<E extends EdgeBase<any, any>, D extends SupportedDepths, Opts extends ExportOptions> = E extends AvailableLocation.Edge<infer L extends Vertex<any>, infer Extra extends object> ? AvailableLocation.Util.Value<Recursion<L, D, Opts>, Extra> : never;
-  export type ThreadMessage<E extends EdgeBase<any, any>, D extends SupportedDepths, Opts extends ExportOptions> = E extends ThreadMessage.Edge<infer U extends Vertex<any>, infer T extends Vertex<any>, infer Extra extends object> ? ThreadMessage.Util.Value<Recursion<U, D, Opts>, Recursion<T, D, Opts>, Extra> : never;
+  export type Plain<E$1 extends EdgeBase<any, any>, D extends SupportedDepths, Opts extends ExportOptions> = E$1 extends Plain.Edge<infer V> ? Recursion<V, D, Opts> : never;
+  export type Wrapped<E$1 extends EdgeBase<any, any>, D extends SupportedDepths, Opts extends ExportOptions> = E$1 extends Wrapped.Edge<infer K, infer V extends Vertex<any>, infer Extra extends object> ? Wrapped.Util.Value<K, Recursion<V, D, Opts>, Extra> : never;
+  export type Coalesced<E$1 extends EdgeBase<any, any>, D extends SupportedDepths, Opts extends ExportOptions> = E$1 extends Coalesced.Edge<infer V, infer O extends object, infer Extra extends object> ? V extends Vertex<Collection> ? Coalesced.Util.Value<Recursion<V, D, Opts>, Coalesced.Util.ToModel<V>, O, Extra> : never : never;
+  export type GroupWithExclude<E$1 extends EdgeBase<any, any>, D extends SupportedDepths, Opts extends ExportOptions> = E$1 extends GroupWithExclude.Edge<infer G extends Vertex<any>, infer P extends Vertex<any>, infer Extra extends object> ? GroupWithExclude.Util.Value<Recursion<G, D, Opts>, Recursion<P, D, Opts>, Extra> : never;
+  export type AvailableLocation<E$1 extends EdgeBase<any, any>, D extends SupportedDepths, Opts extends ExportOptions> = E$1 extends AvailableLocation.Edge<infer L extends Vertex<any>, infer Extra extends object> ? AvailableLocation.Util.Value<Recursion<L, D, Opts>, Extra> : never;
+  export type ThreadMessage<E$1 extends EdgeBase<any, any>, D extends SupportedDepths, Opts extends ExportOptions> = E$1 extends ThreadMessage.Edge<infer U extends Vertex<any>, infer T extends Vertex<any>, infer Extra extends object> ? ThreadMessage.Util.Value<Recursion<U, D, Opts>, Recursion<T, D, Opts>, Extra> : never;
   export {};
 }
 type _MinDepthType = any;
-type TryPrettify<T> = 0 extends (1 & T) ? _MinDepthType : Prettify<T>;
+type TryPrettify<T$1> = 0 extends (1 & T$1) ? _MinDepthType : Prettify<T$1>;
 type InternalIdKeys = IDKey | PrivateIDKey;
-type PartialIf<T extends object, Condition extends boolean | undefined> = Condition extends true ? Partial<T> : T;
-type OmitPrivateIdIf<T extends object, Condition extends boolean | undefined> = Condition extends true ? Omit<T, PrivateIDKey> : T;
+type PartialIf<T$1 extends object, Condition extends boolean | undefined> = Condition extends true ? Partial<T$1> : T$1;
+type OmitPrivateIdIf<T$1 extends object, Condition extends boolean | undefined> = Condition extends true ? Omit<T$1, PrivateIDKey> : T$1;
 type _DeepVertexExport<V extends Vertex<Collection>, D extends SupportedDepths, Opts extends ExportOptions> = D extends MinDepth ? _MinDepthType : Prettify<OmitPrivateIdIf<PartialIf<{ [K in keyof Pick<V, InternalIdKeys>]: V[K] }, Opts['optionalId']>, Opts['omitPrivateId']> & { [K in keyof Omit<OmitInternalVertexKeys<OmitEdges<V>>, InternalIdKeys>]: V[K] } & { [K in keyof PickEdges<V>]: [V[K]] extends [never] ? never : NonNullable<V[K]> extends EdgeWrapper<infer M, infer E extends EdgeBase<any, any> | null | undefined> ? (SetMultiplicity<TryPrettify<E extends EdgeBase<any, any> ? (HandleEdge.Plain<E, D, Opts> | HandleEdge.Wrapped<E, D, Opts> | HandleEdge.Coalesced<E, D, Opts> | HandleEdge.GroupWithExclude<E, D, Opts> | HandleEdge.AvailableLocation<E, D, Opts> | HandleEdge.ThreadMessage<E, D, Opts>) : E>, M> | ExtractNullish<V[K]>) : never }>;
 /**
  * Recursively transforms a Vertex type into a deeply exported, plain object structure.

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

@@ -24,8 +24,8 @@ type EdgeIsValid<T extends EdgeBase<any, any>> = [T] extends [{
 }] ? true : false;
 declare namespace Plain {
   namespace Util {}
-  type Edge<V extends Vertex<Collection>> = EdgeBase<EdgeTypeIdValues['PLAIN'], NoneIsUnion<[V]> extends never ? true : false> & {
-    [EDGE_VALUE_KEY]: V;
+  type Edge<V$1 extends Vertex<Collection>> = EdgeBase<EdgeTypeIdValues['PLAIN'], NoneIsUnion<[V$1]> extends never ? true : false> & {
+    [EDGE_VALUE_KEY]: V$1;
   };
 }
 declare namespace Wrapped {
@@ -35,8 +35,8 @@ declare namespace Wrapped {
     };
     type Value<K extends string, To, Extra = object> = Extra & { [k in K]: To };
   }
-  type Edge<K extends string, V extends Vertex<Collection>, E extends object = object> = EdgeBase<EdgeTypeIdValues['WRAPPED'], NoneIsUnion<[K, V]> extends never ? true : false> & {
-    [EDGE_VALUE_KEY]: Util.Value<K, V, E>;
+  type Edge<K extends string, V$1 extends Vertex<Collection>, E extends object = object> = EdgeBase<EdgeTypeIdValues['WRAPPED'], NoneIsUnion<[K, V$1]> extends never ? true : false> & {
+    [EDGE_VALUE_KEY]: Util.Value<K, V$1, E>;
   };
 }
 declare namespace Coalesced {
@@ -53,15 +53,15 @@ declare namespace Coalesced {
     type makePartial<T, O extends Options> = O extends {
       optional: true;
     } ? Partial<T> : T;
-    export type ToModel<V extends Vertex<Collection>> = V extends Vertex<infer C> ? C extends 'events' ? C | 'courseevents' : C : never;
+    export type ToModel<V$1 extends Vertex<Collection>> = V$1 extends Vertex<infer C> ? C extends 'events' ? C | 'courseevents' : C : never;
     export type Value<To, ToModel, Opts extends Util.Options = object, Extra = object> = Extra & makePartial<{
       [Keys.TO]: To;
       [Keys.TO_MODEL]: ToModel;
     }, Opts>;
     export {};
   }
-  type Edge<V extends Vertex<Collection>, Opts extends Util.Options = object, E extends object = object> = EdgeBase<EdgeTypeIdValues['COALESCED'], NoneIsUnion<[V]> extends never ? true : false> & {
-    [EDGE_VALUE_KEY]: Util.Value<V, Util.ToModel<V>, Opts, E>;
+  type Edge<V$1 extends Vertex<Collection>, Opts extends Util.Options = object, E extends object = object> = EdgeBase<EdgeTypeIdValues['COALESCED'], NoneIsUnion<[V$1]> extends never ? true : false> & {
+    [EDGE_VALUE_KEY]: Util.Value<V$1, Util.ToModel<V$1>, Opts, E>;
   };
 }
 declare namespace GroupWithExclude {

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

@@ -0,0 +1,6 @@
+import { Collection, PseudoCollection, RealCollection, Vertex, VertexFactory } from "./vertex.js";
+import { AvailableLocation, Coalesced, EdgeWrapper, GroupWithExclude, Plain, ThreadMessage, Wrapped } from "./edges.js";
+import { AssertNoInvalidExpandKeys } from "./custom-vertex-export/assert-no-invalid-expand-keys.js";
+import { CustomVertexExport } from "./custom-vertex-export/index.js";
+import { DeepVertexExport, MixedVertexExport, MixedWithOptionalIdVertexExport } from "./deep-vertex-export/index.js";
+import { SerializedVertexExport } from "./serialized-vertex-export.js";

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

@@ -5,55 +5,51 @@ 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 extends keyof any> = O extends { [P in K]: infer T } ? T : O extends { [P in K]?: infer T } ? T | undefined : never;
+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;
 /**
  * keyof { a1: ..., a2: ..., ... } | { b1: ..., b2: ..., ... } | ... => 'a1' | 'a2' | ... | 'b1' | 'b2' | ...
  */
-type AllKeys<U> = U extends any ? keyof U : never;
+type AllKeys<U$1> = U$1 extends any ? keyof U$1 : never;
 declare namespace MakeMixedNs {
-  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);
+  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);
   export {};
 }
 /**
  * Merges a union of types into a single type by combining properties of object types and merging array element types.
  */
-type MakeMixed<T> = MakeMixedNs.MakeMixed<T>;
+type MakeMixed<T$1> = MakeMixedNs.MakeMixed<T$1>;
 /**
  * Deep partial type that allows for partial properties at any level of nesting.
  */
-type DeepPartial<T> = T extends Array<infer U> ? Array<DeepPartial<U>> : T extends object ? { [K in keyof T]?: DeepPartial<T[K]> } : T;
+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;
 /**
  * A deep version of NonNullable<T> that recursively removes null and undefined from all properties and nested properties.
  */
-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;
+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;
 /**
  * Lets a type pass if it is a union type, otherwise returns `never`.
  */
-type IsUnion<T> = _IsUnion<T> extends true ? T : never;
-/**
- * Lets a type pass if it is not a union type, otherwise returns `never`.
- */
-
+type IsUnion<T$1> = _IsUnion<T$1> extends true ? T$1 : never;
 /**
  * Returns never if any type in the tuple is a union, otherwise returns the tuple.
  */
-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;
+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;
 /**
  * Returns `true` if every element in the tuple is `true`, otherwise returns `false`.
  * Returns `never` for an empty tuple.
  */
-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;
+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;
 /**
  * Returns the tail of a tuple, or `never` if the tuple is empty.
  */
-type Tail<T extends any[]> = T extends [any, ...infer V extends [any, ...any[]]] ? Tail<V> : T extends [infer U] ? U : never;
+type Tail<T$1 extends any[]> = T$1 extends [any, ...infer V extends [any, ...any[]]] ? Tail<V> : T$1 extends [infer U] ? U : never;
 /**
  * Prettify<T>
  * Materializes T into a plain object type for clearer tooltips and stable structural equality.
@@ -70,15 +66,15 @@ type Tail<T extends any[]> = T 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> = { [K in keyof T]: T[K] } & {};
+type Prettify<T$1> = { [K in keyof T$1]: T$1[K] } & {};
 /**
  * Wraps the given type T into an array if its multiplicity M is 'array'.
  */
-type SetMultiplicity<T, M = EdgeMultiplicity> = M extends 'array' ? T[] : T;
+type SetMultiplicity<T$1, M = EdgeMultiplicity> = M extends 'array' ? T$1[] : T$1;
 /**
  * Extracts null and undefined from a type T, resulting in `null | undefined` if both are present, otherwise `null`, `undefined`, or `never`.
  */
-type ExtractNullish<T> = Extract<T, null | undefined>;
+type ExtractNullish<T$1> = Extract<T$1, 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

@@ -7,26 +7,26 @@ import { FLATTEN_KEY, _Flatten } from "./util.js";
 
 //#region src/core/interfaces/vertices/util/vertex-query/index.d.ts
 declare namespace HandleEdge {
-  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> ? ({
+  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> ? ({
     [FLATTEN_KEY]: true;
   } & { [k in K]: V extends any ? _VertexQuery<V, D> : never }) : never;
-  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>) ? {
+  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>) ? {
     [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 extends EdgeBase<any, any>, D extends SupportedDepths> = E extends GroupWithExclude.Edge<infer G extends Vertex<Collection>, infer P extends Vertex<Collection>, object> ? {
+  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> ? {
     [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 extends EdgeBase<any, any>, D extends SupportedDepths> = E extends AvailableLocation.Edge<infer L extends Vertex<Collection>, object> ? {
+  type AvailableLocation<E$1 extends EdgeBase<any, any>, D extends SupportedDepths> = E$1 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> ? {
+  type ThreadMessage<E$1 extends EdgeBase<any, any>, D extends SupportedDepths> = E$1 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;
@@ -35,17 +35,17 @@ declare namespace HandleEdge {
 /**
  *
  */
-type _VertexQuery<V extends Vertex<Collection>, D extends SupportedDepths> = D extends MinDepth ? {
-  [SELECT_KEY]: Array<AllKeysOf<V>>;
+type _VertexQuery<V$1 extends Vertex<Collection>, D extends SupportedDepths> = D extends MinDepth ? {
+  [SELECT_KEY]: Array<AllKeysOf<V$1>>;
 } : {
-  [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 }>>;
+  [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>> | HandleEdge.ThreadMessage<NonNullable<E>, Decrement<D>>) : never }>>;
 } & {
-  [SELECT_KEY]: Array<AllKeysOf<V>>;
+  [SELECT_KEY]: Array<AllKeysOf<V$1>>;
 };
 /**
  *
  */
-type VertexQuery<V extends Vertex<Collection>> = DeepPartial<_VertexQuery<V, MaxDepth>>;
+type VertexQuery<V$1 extends Vertex<Collection>> = DeepPartial<_VertexQuery<V$1, MaxDepth>>;
 //#endregion
 export { VertexQuery };
 //# sourceMappingURL=index.d.ts.map

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

@@ -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, PublicIDKey, RealCollection, Vertex, VertexFactory };
+export { Collection, IDKey, IDType, OmitInternalVertexKeys, OmitVertexProperties, PickVertexProperties, PrivateIDKey, PrivateIDType, PseudoCollection, PublicIDKey, RealCollection, Vertex, VertexFactory };
 //# sourceMappingURL=vertex.d.ts.map

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

@@ -1,6 +1,7 @@
 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";
@@ -47,16 +48,16 @@ type VertexRecord = {
   users: UserVertex;
   threads: ThreadVertex;
 };
-type BaseQueryRecord<C extends keyof VertexRecord> = VertexQuery<VertexRecord[C]>;
+type BaseQueryRecord<C$1 extends keyof VertexRecord> = VertexQuery<VertexRecord[C$1]>;
 /**
  * See {@link createVertexQuery}
  */
-declare class VertexQuery$1<C extends keyof VertexRecord, Q extends BaseQueryRecord<C> & AssertNoInvalidExpandKeys<VertexRecord[C], Q>> {
+declare class VertexQuery$1<C$1 extends keyof VertexRecord, Q$1 extends BaseQueryRecord<C$1> & AssertNoInvalidExpandKeys<VertexRecord[C$1], Q$1>> {
   private readonly _collection;
   private readonly _query;
-  constructor(_collection: C, _query: Q);
-  get collection(): C;
-  get query(): Q;
+  constructor(_collection: C$1, _query: Q$1);
+  get collection(): C$1;
+  get query(): Q$1;
 }
 /**
  * Infers the result type for a query created via createVertexQuery.
@@ -81,27 +82,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 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>;
+  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 thread<Q$1 extends VertexQuery<ThreadVertex> & AssertNoInvalidExpandKeys<ThreadVertex, Q$1>>(query: Q$1): VertexQuery$1<"threads", Q$1>;
+  function user<Q$1 extends VertexQuery<UserVertex> & AssertNoInvalidExpandKeys<UserVertex, Q$1>>(query: Q$1): VertexQuery$1<"users", Q$1>;
 }
 //#endregion
 export { Infer, VertexQuery$1 as VertexQuery, createVertexQuery };

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 { 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"}
+{"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,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;;;CACrL,SAAS,OAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,WAAoB,MAAM;;;CACrL,SAAS,KAA+G,OAAU;AAAE,SAAO,IAAI,YAAY,SAAoB,MAAM"}

package/dist/core/to/configurations.js

@@ -4,9 +4,8 @@ import { omitEdgesAndInternalProperties } from "./util.js";
 var configurations_default = (configurations, _options) => {
 	return configurations.map((x) => {
 		const edges = {};
-		const nonEdges = omitEdgesAndInternalProperties(x, edges);
 		return {
-			...nonEdges,
+			...omitEdgesAndInternalProperties(x, edges),
 			...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;EAEpE,MAAM,WAAW,+BAA+B,GAAG;AAEnD,SAAO;GAAE,GAAG;GAAU,GAAG"}
+{"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"}

package/dist/core/to/courses.js

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

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"}
+{"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"}

package/dist/core/to/events.js

@@ -30,9 +30,8 @@ var events_default = (events, options) => {
 			inLocations: x.inLocations?.map((x$1) => x$1 ? getVertexId(x$1, options) : null),
 			threads: void 0
 		};
-		const nonEdges = omitEdgesAndInternalProperties(x, edges);
 		return {
-			...nonEdges,
+			...omitEdgesAndInternalProperties(x, edges),
 			...edges
 		};
 	});