@royalschedule/maps 4.1.4 → 4.1.5

package/dist/core/interfaces/vertices/util/keys-of.d.mts

@@ -0,0 +1,26 @@
+import { Collection, OmitInternalVertexKeys, Vertex } from "./vertex.mjs";
+import { EdgeBase, EdgeValueKey, EdgeWrapper } from "./edges.mjs";
+import { AllKeys } from "./util.mjs";
+import { ExpandKey, RemoveNeverValues, SelectKey } from "./common.mjs";
+import { VertexQuery } from "./vertex-query/index.mjs";
+
+//#region src/core/interfaces/vertices/util/keys-of.d.ts
+/**
+ * Returns all possible keys of a vertex, including nested keys in dot-notation for edges.
+ */
+type AllKeysOf<V extends Vertex<Collection>> = keyof { [K in keyof RemoveNeverValues<OmitInternalVertexKeys<V>> as NonNullable<V[K]> extends EdgeWrapper<any, infer E extends EdgeBase<any, any> | null | undefined> ? EdgeValueKey extends keyof NonNullable<E> ? NonNullable<E>[EdgeValueKey] extends Vertex<Collection> ? K : AllKeys<NonNullable<E>[EdgeValueKey]> extends (infer S extends string) ? K | `${K}.${S}` : never : never : K]-?: true };
+/**
+ * combines keys from 'select' and 'expand' and defaults to all keys if neither is specified
+ */
+type _CombinePaths<V extends Vertex<any>, Q extends VertexQuery<V>> = ExpandKey extends keyof Q ? SelectKey extends keyof Q ? NonNullable<Q[SelectKey]>[number] | keyof Q[ExpandKey] : keyof Q[ExpandKey] : SelectKey extends keyof Q ? NonNullable<Q[SelectKey]>[number] : keyof OmitInternalVertexKeys<V>;
+/**
+ * Replaces all top-level keys with the full paths of their children, if they have any.
+ */
+type _FlattenKeys<Keys, AvailableKeys> = Keys extends (infer K extends string) ? [Extract<AvailableKeys, `${K}.${string}`>] extends [never] ? K : Extract<AvailableKeys, `${K}.${string}`> : never;
+/**
+ * Given a vertex type and expand/select paths, returns the corresponding fully flattened (using dot-notation) keys.
+ */
+type KeysOf<V extends Vertex<any>, Q extends VertexQuery<V>> = _FlattenKeys<_CombinePaths<V, Q>, AllKeysOf<V>>;
+//#endregion
+export { AllKeysOf, KeysOf };
+//# sourceMappingURL=keys-of.d.mts.map

package/dist/core/interfaces/vertices/util/serialized-vertex-export.d.mts

@@ -0,0 +1,11 @@
+import { Collection, Vertex } from "./vertex.mjs";
+import { CustomVertexExport } from "./custom-vertex-export/index.mjs";
+
+//#region src/core/interfaces/vertices/util/serialized-vertex-export.d.ts
+/**
+ *
+ */
+type SerializedVertexExport<V extends Vertex<Collection>> = CustomVertexExport<V, object>;
+//#endregion
+export { SerializedVertexExport };
+//# sourceMappingURL=serialized-vertex-export.d.mts.map

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

@@ -0,0 +1,79 @@
+import { EdgeMultiplicity } from "./edges.mjs";
+
+//#region src/core/interfaces/vertices/util/util.d.ts
+/**
+ * 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;
+/**
+ * keyof { a1: ..., a2: ..., ... } | { b1: ..., b2: ..., ... } | ... => 'a1' | 'a2' | ... | 'b1' | 'b2' | ...
+ */
+type AllKeys<U> = U extends any ? keyof U : 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);
+  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>;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * Lets a type pass if it is a union type, otherwise returns `never`.
+ */
+type IsUnion<T> = _IsUnion<T> extends true ? T : 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;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * Prettify<T>
+ * Materializes T into a plain object type for clearer tooltips and stable structural equality.
+ *
+ * Preserves:
+ * - Keys, property types, and readonly/optional modifiers (homomorphic mapping).
+ *
+ * Useful for:
+ * - Flattening intersections and mapped types into a single object-like shape so
+ *   libraries like ts-expect's TypeEqual consider two equivalent types equal.
+ *
+ * Notes:
+ * - Does not change semantics or add/remove properties.
+ * - 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] } & {};
+/**
+ * Wraps the given type T into an array if its multiplicity M is 'array'.
+ */
+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> = Extract<T, null | undefined>;
+//#endregion
+export { AllKeys, AllTrue, DeepNonNullable, DeepPartial, ExtractNullish, IsUnion, MakeMixed, NoneIsUnion, Prettify, SetMultiplicity, Tail };
+//# sourceMappingURL=util.d.mts.map

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

@@ -0,0 +1,50 @@
+import { Collection, Vertex } from "../vertex.mjs";
+import { AvailableLocation, Coalesced, EdgeBase, EdgeMultiplicity, EdgeWrapper, GroupWithExclude, Plain, ThreadMessage, Wrapped } from "../edges.mjs";
+import { DeepPartial, MakeMixed } from "../util.mjs";
+import { Decrement, EXPAND_KEY, InvalidEdgeMessage, MaxDepth, MinDepth, PickEdges, RemoveNeverValues, SELECT_KEY, SupportedDepths } from "../common.mjs";
+import { AllKeysOf } from "../keys-of.mjs";
+import { FLATTEN_KEY, _Flatten } from "./util.mjs";
+
+//#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> ? ({
+    [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>) ? {
+    [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> ? {
+    [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> ? {
+    [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 extends Vertex<Collection>, D extends SupportedDepths> = D extends MinDepth ? {
+  [SELECT_KEY]: Array<AllKeysOf<V>>;
+} : {
+  [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>>;
+};
+/**
+ *
+ */
+type VertexQuery<V extends Vertex<Collection>> = DeepPartial<_VertexQuery<V, MaxDepth>>;
+//#endregion
+export { VertexQuery };
+//# sourceMappingURL=index.d.mts.map

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

@@ -0,0 +1,13 @@
+//#region src/core/interfaces/vertices/util/vertex-query/util.d.ts
+declare const FLATTEN_KEY = "__flatten";
+type FlattenKey = typeof FLATTEN_KEY;
+/**
+ * Flattens an object by replacing all keys that have a `{ [FLATTEN_KEY]: true }` marker with their child keys in dot-notation.
+ */
+type _Flatten<T extends object> = { [K in _FlattenedEntries<T> as K extends [infer A, any] ? A : never]: K extends [any, infer B] ? B : never };
+type _FlattenedEntries<T extends object> = { [K in keyof T]: T[K] extends {
+  [FLATTEN_KEY]: true;
+} ? { [S in keyof Omit<T[K], FlattenKey>]: [`${K & string}.${S & string}`, T[K][S]] }[keyof Omit<T[K], FlattenKey>] : [K, T[K]] }[keyof T];
+//#endregion
+export { FLATTEN_KEY, _Flatten };
+//# sourceMappingURL=util.d.mts.map

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

@@ -0,0 +1,68 @@
+import { ObjectId } from "../../../../common/types.mjs";
+
+//#region src/core/interfaces/vertices/util/vertex.d.ts
+/**
+ *
+ */
+type RealCollection = 'settings' | 'divisionSettings' | 'exceptions' | 'groups' | 'teachers' | 'locations' | 'configurations' | 'courses' | 'events' | 'generations' | 'lockedTimes' | 'linkedEventsSets' | 'periods' | 'rootIntervals' | 'persons' | 'syllabuses' | 'divisions' | 'companies' | 'users' | 'threads' | 'conversations' | 'messages';
+/**
+ *
+ */
+type PseudoCollection = 'scheduleEvents' | 'calendarEvents' | 'students';
+/**
+ *
+ */
+type Collection = RealCollection | PseudoCollection;
+declare const ID_KEY = "id";
+type IDKey = typeof ID_KEY;
+type IDType = string;
+declare const PRIVATE_ID_KEY = "_id";
+type PrivateIDKey = typeof PRIVATE_ID_KEY;
+type PrivateIDType = ObjectId;
+declare const PUBLIC_ID_KEY = "ids";
+type PublicIDKey = typeof PUBLIC_ID_KEY;
+declare const VERTEX_COLLECTION_KEY = "__vertex_collection";
+type VertexCollectionKey = typeof VERTEX_COLLECTION_KEY;
+type InternalVertexKeys = VertexCollectionKey;
+type OmitInternalVertexKeys<T extends object> = Omit<T, InternalVertexKeys>;
+type CollectionIsRecord = {
+  exceptions: 'exception';
+  groups: 'group';
+  teachers: 'teacher';
+  locations: 'location';
+  configurations: 'configuration';
+  courses: 'course';
+  events: 'event';
+  scheduleEvents: 'event';
+  generations: 'generation';
+  settings: 'setting';
+  divisionSettings: 'setting';
+  lockedTimes: 'lockedTime';
+  linkedEventsSets: 'linkedEventsSet';
+  periods: 'period';
+  rootIntervals: 'rootInterval';
+  persons: 'person';
+  syllabuses: 'syllabus';
+  divisions: 'division';
+};
+type CollectionToIs<C extends Collection> = C extends keyof CollectionIsRecord ? CollectionIsRecord[C] : never;
+type Vertex<C extends Collection> = {
+  [ID_KEY]: IDType;
+  [PRIVATE_ID_KEY]: PrivateIDType;
+  [PUBLIC_ID_KEY]?: string;
+  is?: CollectionToIs<C>;
+  displayName?: string;
+  createdAt?: string;
+  updatedAt?: string;
+  /**
+   * @deprecated promote to an edge?
+   */
+  lastModifiedBy?: string; /** A helper property used solely by typescript to infer the a vertex */
+  [VERTEX_COLLECTION_KEY]: C;
+};
+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 };
+//# sourceMappingURL=vertex.d.mts.map

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

@@ -0,0 +1,115 @@
+import { VertexQuery as VertexQuery$1 } from "./util/vertex-query/index.mjs";
+import { AssertNoInvalidExpandKeys } from "./util/custom-vertex-export/assert-no-invalid-expand-keys.mjs";
+import { CustomVertexExport } from "./util/custom-vertex-export/index.mjs";
+import "./util/index.mjs";
+import { PeriodVertex } from "./periods.mjs";
+import { RootIntervalVertex } from "./root-intervals.mjs";
+import { DivisionSettingsVertex } from "./division-settings.mjs";
+import { GenerationVertex } from "./generations.mjs";
+import { DivisionVertex } from "./divisions.mjs";
+import { PersonVertex } from "./persons.mjs";
+import { LocationVertex } from "./locations.mjs";
+import { LinkedEventsSetVertex } from "./linked-events-sets.mjs";
+import { UserVertex } from "./users.mjs";
+import { ThreadVertex } from "./threads.mjs";
+import { SyllabusVertex } from "./syllabuses.mjs";
+import { CalendarEventVertex, EventVertex, ScheduleEventVertex } from "./events.mjs";
+import { CourseVertex } from "./courses.mjs";
+import { ExceptionVertex } from "./exceptions.mjs";
+import { GroupVertex } from "./groups.mjs";
+import { LockedTimeVertex } from "./locked-times.mjs";
+import { TeacherVertex } from "./teachers.mjs";
+import { CompanyVertex } from "./companies.mjs";
+import { ConfigurationVertex } from "./configurations.mjs";
+import { MessageVertex } from "./messages.mjs";
+import { ConversationVertex } from "./conversations.mjs";
+
+//#region src/core/interfaces/vertices/vertex-query.d.ts
+type VertexRecord = {
+  divisions: DivisionVertex;
+  divisionSettings: DivisionSettingsVertex;
+  settings: DivisionSettingsVertex;
+  teachers: TeacherVertex;
+  exceptions: ExceptionVertex;
+  events: EventVertex;
+  scheduleEvents: ScheduleEventVertex;
+  calendarEvents: CalendarEventVertex;
+  courses: CourseVertex;
+  generations: GenerationVertex;
+  groups: GroupVertex;
+  locations: LocationVertex;
+  lockedTimes: LockedTimeVertex;
+  linkedEventsSets: LinkedEventsSetVertex;
+  periods: PeriodVertex;
+  persons: PersonVertex;
+  students: PersonVertex;
+  rootIntervals: RootIntervalVertex;
+  syllabuses: SyllabusVertex;
+  configurations: ConfigurationVertex;
+  companies: CompanyVertex;
+  users: UserVertex;
+  threads: ThreadVertex;
+  conversations: ConversationVertex;
+  messages: MessageVertex;
+};
+type BaseQueryRecord<C extends keyof VertexRecord> = VertexQuery$1<VertexRecord[C]>;
+/**
+ * See {@link createVertexQuery}
+ */
+declare class VertexQuery<C extends keyof VertexRecord, Q extends BaseQueryRecord<C> & AssertNoInvalidExpandKeys<VertexRecord[C], Q>> {
+  private readonly _collection;
+  private readonly _query;
+  constructor(_collection: C, _query: Q);
+  get collection(): C;
+  get query(): Q;
+}
+/**
+ * Infers the result type for a query created via createVertexQuery.
+ *
+ * @example
+ * const personQuery = createVertexQuery('persons', { select: ['id', 'firstName'] });
+ * type PersonType = Infer<typeof personQuery>;
+ */
+type Infer<T extends VertexQuery<any, any>> = T extends VertexQuery<infer C, infer Q> ? CustomVertexExport<VertexRecord[C], Q> : never;
+/**
+ * Builds a typed vertex query for a given vertex type using a select/expand shape.
+ *
+ * Use together with Infer<T> to obtain the serialized result type.
+ *
+ * @typeParam Q - The select/expand query shape for that vertex.
+ *
+ * @example
+ * const groupQuery = createVertexQuery.group({
+ *   select: ['id', 'displayName'],
+ *   expand: { members: { select: ['id'] } }
+ * });
+ * type GroupType = Infer<typeof groupQuery>;
+ */
+declare namespace createVertexQuery {
+  function division<Q extends VertexQuery$1<DivisionVertex> & AssertNoInvalidExpandKeys<DivisionVertex, Q>>(query: Q): VertexQuery<"divisions", Q>;
+  function settings<Q extends VertexQuery$1<DivisionSettingsVertex> & AssertNoInvalidExpandKeys<DivisionSettingsVertex, Q>>(query: Q): VertexQuery<"settings", Q>;
+  function exception<Q extends VertexQuery$1<ExceptionVertex> & AssertNoInvalidExpandKeys<ExceptionVertex, Q>>(query: Q): VertexQuery<"exceptions", Q>;
+  function event<Q extends VertexQuery$1<EventVertex> & AssertNoInvalidExpandKeys<EventVertex, Q>>(query: Q): VertexQuery<"events", Q>;
+  function scheduleEvent<Q extends VertexQuery$1<ScheduleEventVertex> & AssertNoInvalidExpandKeys<ScheduleEventVertex, Q>>(query: Q): VertexQuery<"scheduleEvents", Q>;
+  function calendarEvent<Q extends VertexQuery$1<CalendarEventVertex> & AssertNoInvalidExpandKeys<CalendarEventVertex, Q>>(query: Q): VertexQuery<"calendarEvents", Q>;
+  function course<Q extends VertexQuery$1<CourseVertex> & AssertNoInvalidExpandKeys<CourseVertex, Q>>(query: Q): VertexQuery<"courses", Q>;
+  function generation<Q extends VertexQuery$1<GenerationVertex> & AssertNoInvalidExpandKeys<GenerationVertex, Q>>(query: Q): VertexQuery<"generations", Q>;
+  function location<Q extends VertexQuery$1<LocationVertex> & AssertNoInvalidExpandKeys<LocationVertex, Q>>(query: Q): VertexQuery<"locations", Q>;
+  function lockedTime<Q extends VertexQuery$1<LockedTimeVertex> & AssertNoInvalidExpandKeys<LockedTimeVertex, Q>>(query: Q): VertexQuery<"lockedTimes", Q>;
+  function linkedEventsSet<Q extends VertexQuery$1<LinkedEventsSetVertex> & AssertNoInvalidExpandKeys<LinkedEventsSetVertex, Q>>(query: Q): VertexQuery<"linkedEventsSets", Q>;
+  function period<Q extends VertexQuery$1<PeriodVertex> & AssertNoInvalidExpandKeys<PeriodVertex, Q>>(query: Q): VertexQuery<"periods", Q>;
+  function person<Q extends VertexQuery$1<PersonVertex> & AssertNoInvalidExpandKeys<PersonVertex, Q>>(query: Q): VertexQuery<"persons", Q>;
+  function student<Q extends VertexQuery$1<PersonVertex> & AssertNoInvalidExpandKeys<PersonVertex, Q>>(query: Q): VertexQuery<"students", Q>;
+  function rootInterval<Q extends VertexQuery$1<RootIntervalVertex> & AssertNoInvalidExpandKeys<RootIntervalVertex, Q>>(query: Q): VertexQuery<"rootIntervals", Q>;
+  function syllabus<Q extends VertexQuery$1<SyllabusVertex> & AssertNoInvalidExpandKeys<SyllabusVertex, Q>>(query: Q): VertexQuery<"syllabuses", Q>;
+  function group<Q extends VertexQuery$1<GroupVertex> & AssertNoInvalidExpandKeys<GroupVertex, Q>>(query: Q): VertexQuery<"groups", Q>;
+  function teacher<Q extends VertexQuery$1<TeacherVertex> & AssertNoInvalidExpandKeys<TeacherVertex, Q>>(query: Q): VertexQuery<"teachers", Q>;
+  function configuration<Q extends VertexQuery$1<ConfigurationVertex> & AssertNoInvalidExpandKeys<ConfigurationVertex, Q>>(query: Q): VertexQuery<"configurations", Q>;
+  function thread<Q extends VertexQuery$1<ThreadVertex> & AssertNoInvalidExpandKeys<ThreadVertex, Q>>(query: Q): VertexQuery<"threads", Q>;
+  function user<Q extends VertexQuery$1<UserVertex> & AssertNoInvalidExpandKeys<UserVertex, Q>>(query: Q): VertexQuery<"users", Q>;
+  function conversation<Q extends VertexQuery$1<ConversationVertex> & AssertNoInvalidExpandKeys<ConversationVertex, Q>>(query: Q): VertexQuery<"conversations", Q>;
+  function message<Q extends VertexQuery$1<MessageVertex> & AssertNoInvalidExpandKeys<MessageVertex, Q>>(query: Q): VertexQuery<"messages", Q>;
+}
+//#endregion
+export { Infer, VertexQuery, createVertexQuery };
+//# sourceMappingURL=vertex-query.d.mts.map

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

@@ -0,0 +1,118 @@
+import { expectType } from "ts-expect";
+
+//#region src/core/interfaces/vertices/vertex-query.ts
+expectType(true);
+/**
+* See {@link createVertexQuery}
+*/
+var VertexQuery = class {
+	constructor(_collection, _query) {
+		this._collection = _collection;
+		this._query = _query;
+	}
+	get collection() {
+		return this._collection;
+	}
+	get query() {
+		return this._query;
+	}
+};
+let createVertexQuery;
+(function(_createVertexQuery) {
+	function division(query) {
+		return new VertexQuery("divisions", query);
+	}
+	_createVertexQuery.division = division;
+	function settings(query) {
+		return new VertexQuery("settings", query);
+	}
+	_createVertexQuery.settings = settings;
+	function exception(query) {
+		return new VertexQuery("exceptions", query);
+	}
+	_createVertexQuery.exception = exception;
+	function event(query) {
+		return new VertexQuery("events", query);
+	}
+	_createVertexQuery.event = event;
+	function scheduleEvent(query) {
+		return new VertexQuery("scheduleEvents", query);
+	}
+	_createVertexQuery.scheduleEvent = scheduleEvent;
+	function calendarEvent(query) {
+		return new VertexQuery("calendarEvents", query);
+	}
+	_createVertexQuery.calendarEvent = calendarEvent;
+	function course(query) {
+		return new VertexQuery("courses", query);
+	}
+	_createVertexQuery.course = course;
+	function generation(query) {
+		return new VertexQuery("generations", query);
+	}
+	_createVertexQuery.generation = generation;
+	function location(query) {
+		return new VertexQuery("locations", query);
+	}
+	_createVertexQuery.location = location;
+	function lockedTime(query) {
+		return new VertexQuery("lockedTimes", query);
+	}
+	_createVertexQuery.lockedTime = lockedTime;
+	function linkedEventsSet(query) {
+		return new VertexQuery("linkedEventsSets", query);
+	}
+	_createVertexQuery.linkedEventsSet = linkedEventsSet;
+	function period(query) {
+		return new VertexQuery("periods", query);
+	}
+	_createVertexQuery.period = period;
+	function person(query) {
+		return new VertexQuery("persons", query);
+	}
+	_createVertexQuery.person = person;
+	function student(query) {
+		return new VertexQuery("students", query);
+	}
+	_createVertexQuery.student = student;
+	function rootInterval(query) {
+		return new VertexQuery("rootIntervals", query);
+	}
+	_createVertexQuery.rootInterval = rootInterval;
+	function syllabus(query) {
+		return new VertexQuery("syllabuses", query);
+	}
+	_createVertexQuery.syllabus = syllabus;
+	function group(query) {
+		return new VertexQuery("groups", query);
+	}
+	_createVertexQuery.group = group;
+	function teacher(query) {
+		return new VertexQuery("teachers", query);
+	}
+	_createVertexQuery.teacher = teacher;
+	function configuration(query) {
+		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;
+	function conversation(query) {
+		return new VertexQuery("conversations", query);
+	}
+	_createVertexQuery.conversation = conversation;
+	function message(query) {
+		return new VertexQuery("messages", query);
+	}
+	_createVertexQuery.message = message;
+})(createVertexQuery || (createVertexQuery = {}));
+
+//#endregion
+export { createVertexQuery };
+//# sourceMappingURL=vertex-query.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vertex-query.mjs","names":[],"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 { LinkedEventsSetVertex } from './linked-events-sets';\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 { ConversationVertex } from './conversations';\nimport type { MessageVertex } from './messages';\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  linkedEventsSets: LinkedEventsSetVertex;\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  conversations:    ConversationVertex;\n  messages:         MessageVertex;\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 linkedEventsSet<Q extends Query<LinkedEventsSetVertex > & AssertNoInvalidExpandKeys<LinkedEventsSetVertex,  Q>> (query: Q) { return new VertexQuery('linkedEventsSets', 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  export function conversation   <Q extends Query<ConversationVertex    > & AssertNoInvalidExpandKeys<ConversationVertex,     Q>> (query: Q) { return new VertexQuery('conversations',    query) }\n  export function message        <Q extends Query<MessageVertex         > & AssertNoInvalidExpandKeys<MessageVertex,          Q>> (query: Q) { return new VertexQuery('messages',         query) }\n}"],"mappings":";;;AA4DE,WAAyC,KAAK;;;;AAMhD,IAAa,cAAb,MAGE;CACA,YACE,AAAiB,aACjB,AAAiB,QACjB;EAFiB;EACA;;CAGnB,IAAI,aAAc;AAAE,SAAO,KAAK;;CAChC,IAAI,QAAc;AAAE,SAAO,KAAK;;;;;CA6CzB,SAAS,SAAiH,OAAU;AAAE,SAAO,IAAI,YAAY,aAAoB,MAAM;;;CACvL,SAAS,SAAiH,OAAU;AAAE,SAAO,IAAI,YAAY,YAAoB,MAAM;;;CACvL,SAAS,UAAiH,OAAU;AAAE,SAAO,IAAI,YAAY,cAAoB,MAAM;;;CACvL,SAAS,MAAiH,OAAU;AAAE,SAAO,IAAI,YAAY,UAAoB,MAAM;;;CACvL,SAAS,cAAiH,OAAU;AAAE,SAAO,IAAI,YAAY,kBAAoB,MAAM;;;CACvL,SAAS,cAAiH,OAAU;AAAE,SAAO,IAAI,YAAY,kBAAoB,MAAM;;;CACvL,SAAS,OAAiH,OAAU;AAAE,SAAO,IAAI,YAAY,WAAoB,MAAM;;;CACvL,SAAS,WAAiH,OAAU;AAAE,SAAO,IAAI,YAAY,eAAoB,MAAM;;;CACvL,SAAS,SAAiH,OAAU;AAAE,SAAO,IAAI,YAAY,aAAoB,MAAM;;;CACvL,SAAS,WAAiH,OAAU;AAAE,SAAO,IAAI,YAAY,eAAoB,MAAM;;;CACvL,SAAS,gBAAiH,OAAU;AAAE,SAAO,IAAI,YAAY,oBAAoB,MAAM;;;CACvL,SAAS,OAAiH,OAAU;AAAE,SAAO,IAAI,YAAY,WAAoB,MAAM;;;CACvL,SAAS,OAAiH,OAAU;AAAE,SAAO,IAAI,YAAY,WAAoB,MAAM;;;CACvL,SAAS,QAAiH,OAAU;AAAE,SAAO,IAAI,YAAY,YAAoB,MAAM;;;CACvL,SAAS,aAAiH,OAAU;AAAE,SAAO,IAAI,YAAY,iBAAoB,MAAM;;;CACvL,SAAS,SAAiH,OAAU;AAAE,SAAO,IAAI,YAAY,cAAoB,MAAM;;;CACvL,SAAS,MAAiH,OAAU;AAAE,SAAO,IAAI,YAAY,UAAoB,MAAM;;;CACvL,SAAS,QAAiH,OAAU;AAAE,SAAO,IAAI,YAAY,YAAoB,MAAM;;;CACvL,SAAS,cAAiH,OAAU;AAAE,SAAO,IAAI,YAAY,kBAAoB,MAAM;;;CACvL,SAAS,OAAiH,OAAU;AAAE,SAAO,IAAI,YAAY,WAAoB,MAAM;;;CACvL,SAAS,KAAiH,OAAU;AAAE,SAAO,IAAI,YAAY,SAAoB,MAAM;;;CACvL,SAAS,aAAiH,OAAU;AAAE,SAAO,IAAI,YAAY,iBAAoB,MAAM;;;CACvL,SAAS,QAAiH,OAAU;AAAE,SAAO,IAAI,YAAY,YAAoB,MAAM"}

package/dist/core/to/configurations.mjs

@@ -0,0 +1,16 @@
+import { omitEdgesAndInternalProperties } from "./util.mjs";
+
+//#region src/core/to/configurations.ts
+var configurations_default = (configurations, _options) => {
+	return configurations.map((x) => {
+		const edges = {};
+		return {
+			...omitEdgesAndInternalProperties(x, edges),
+			...edges
+		};
+	});
+};
+
+//#endregion
+export { configurations_default as default };
+//# sourceMappingURL=configurations.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"configurations.mjs","names":[],"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,MAAM,QAA8D,EACnE;AAGD,SAAO;GAAE,GAFQ,+BAA+B,GAAG,MAAM;GAEnC,GAAG;GAAO;GAChC"}

package/dist/core/to/courses.mjs

@@ -0,0 +1,40 @@
+import { getVertexId } from "../util.mjs";
+import { omitEdgesAndInternalProperties } from "./util.mjs";
+
+//#region src/core/to/courses.ts
+var courses_default = (courses, options) => {
+	return courses.map((x) => {
+		const edges = {
+			period: x.period ? getVertexId(x.period, options) : void 0,
+			syllabus: x.syllabus ? getVertexId(x.syllabus, options) : void 0,
+			events: x.events?.map((x) => getVertexId(x, options)),
+			lockedTimes: x.lockedTimes?.map((x) => getVertexId(x, options)),
+			exceptions: x.exceptions?.map((x) => getVertexId(x, options)),
+			teachers: x.teachers?.map((x) => ({
+				...x,
+				to: getVertexId(x.to, options)
+			})),
+			participants: x.participants?.map((x) => ({
+				...x,
+				to: getVertexId(x.to, options)
+			})),
+			groups: x.groups?.map((x) => ({
+				...x,
+				to: getVertexId(x.to, options),
+				exclude: x.exclude?.map((y) => getVertexId(y, options))
+			})),
+			locations: x.locations?.map((x) => ({
+				...x,
+				locations: [getVertexId(x.locations[0], options)]
+			}))
+		};
+		return {
+			...omitEdgesAndInternalProperties(x, edges),
+			...edges
+		};
+	});
+};
+
+//#endregion
+export { courses_default as default };
+//# sourceMappingURL=courses.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"courses.mjs","names":[],"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        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,MAAM,QAAuD;GAC3D,QAAc,EAAE,SAAiB,YAAY,EAAE,QAAgB,QAAQ,GAAG;GAC1E,UAAc,EAAE,WAAiB,YAAY,EAAE,UAAgB,QAAQ,GAAG;GAC1E,QAAc,EAAE,QAAc,KAAI,MAAK,YAAY,GAAG,QAAQ,CAAC;GAC/D,aAAc,EAAE,aAAc,KAAI,MAAK,YAAY,GAAG,QAAQ,CAAC;GAC/D,YAAc,EAAE,YAAc,KAAI,MAAK,YAAY,GAAG,QAAQ,CAAC;GAC/D,UAAc,EAAE,UAAc,KAAI,OAAM;IAAE,GAAG;IAAG,IAAI,YAAY,EAAE,IAAI,QAAQ;IAAE,EAAE;GAClF,cAAc,EAAE,cAAc,KAAI,OAAM;IAAE,GAAG;IAAG,IAAI,YAAY,EAAE,IAAI,QAAQ;IAAE,EAAE;GAClF,QAAc,EAAE,QAAc,KAAI,OAAM;IAAE,GAAG;IAAG,IAAI,YAAY,EAAE,IAAI,QAAQ;IAAE,SAAS,EAAE,SAAS,KAAI,MAAK,YAAY,GAAG,QAAQ,CAAC;IAAE,EAAE;GACzI,WAAc,EAAE,WAAc,KAAI,OAAM;IAAE,GAAG;IAAG,WAAW,CAAC,YAAY,EAAE,UAAU,IAAI,QAAQ,CAAC;IAAc,EAAE;GAClH;AAGD,SAAO;GAAE,GAFQ,+BAA+B,GAAG,MAAM;GAEnC,GAAG;GAAO;GAChC"}

package/dist/core/to/division.mjs

@@ -0,0 +1,10 @@
+import { pick } from "lodash-es";
+
+//#region src/core/to/division.ts
+var division_default = (division, options) => {
+	return pick(division, "displayName", "start", "end");
+};
+
+//#endregion
+export { division_default as default };
+//# sourceMappingURL=division.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"division.mjs","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.mjs

@@ -0,0 +1,42 @@
+import { getVertexId } from "../util.mjs";
+import { omitEdgesAndInternalProperties } from "./util.mjs";
+
+//#region src/core/to/events.ts
+var events_default = (events, options) => {
+	return events.map((x) => {
+		const edges = {
+			period: x.period ? getVertexId(x.period, options) : void 0,
+			linkedEventsSet: x.linkedEventsSet ? getVertexId(x.linkedEventsSet, options) : void 0,
+			course: x.course ? getVertexId(x.course, options) : void 0,
+			lockedTimes: x.lockedTimes?.map((x) => getVertexId(x, options)),
+			exceptions: x.exceptions?.map((x) => getVertexId(x, options)),
+			teachers: x.teachers?.map((x) => ({
+				...x,
+				to: getVertexId(x.to, options)
+			})),
+			participants: x.participants?.map((x) => ({
+				...x,
+				to: getVertexId(x.to, options)
+			})),
+			groups: x.groups?.map((x) => ({
+				...x,
+				to: getVertexId(x.to, options),
+				exclude: x.exclude?.map((y) => getVertexId(y, options))
+			})),
+			locations: x.locations?.map((x) => ({
+				...x,
+				locations: [getVertexId(x.locations[0], options)]
+			})),
+			inLocations: x.inLocations?.map((x) => x ? getVertexId(x, options) : null),
+			threads: void 0
+		};
+		return {
+			...omitEdgesAndInternalProperties(x, edges),
+			...edges
+		};
+	});
+};
+
+//#endregion
+export { events_default as default };
+//# sourceMappingURL=events.mjs.map