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

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

@@ -1,41 +0,0 @@
-import { VertexFactory } from "./util/vertex.mjs";
-import { EdgeWrapper, Plain } from "./util/edges.mjs";
-import "./util/index.mjs";
-import { Day } from "./properties/days.mjs";
-import { Interval } from "./properties/intervals.mjs";
-import { Tag } from "./properties/tags.mjs";
-import { MaximumScheduleSpan } from "./properties/maximum-schedule-span.mjs";
-import { PlannedScheduledDuration } from "./properties/planned-scheduled-duration.mjs";
-import { RootIntervalVertex } from "./root-intervals.mjs";
-import { BelongsTo } from "./properties/belongs-to.mjs";
-import { PersonVertex } from "./persons.mjs";
-import { ExceptionVertex } from "./exceptions.mjs";
-import { LockedTimeVertex } from "./locked-times.mjs";
-
-//#region src/core/interfaces/vertices/teachers.d.ts
-type TeacherVertex = VertexFactory<'teachers', BelongsTo & {
-  tags?: Tag[];
-  signature?: string;
-  minBreakLength?: number; /** @deprecated replaced by defaultMaximumScheduleSpan */
-  maxNumWorkingHours?: number | false; /** @deprecated replaced by defaultMaximumScheduleSpan */
-  maxNumDailyWorkingHours?: number | number[] | false;
-  plannedScheduledDuration?: PlannedScheduledDuration;
-  maximumScheduleSpan?: MaximumScheduleSpan;
-  forbidOverlappingEvents?: boolean;
-  disableDayLengthPunishment?: boolean;
-  weight?: number;
-  /**
-   * @note an empty array is the same as undefined
-   */
-  intervals?: Interval[];
-  days?: Day[];
-  rootInterval?: EdgeWrapper<'single', Plain.Edge<RootIntervalVertex>>;
-  lockedTimes?: EdgeWrapper<'array', Plain.Edge<LockedTimeVertex>>;
-  lunch?: EdgeWrapper<'array', Plain.Edge<LockedTimeVertex>>;
-  complementaryTimes?: EdgeWrapper<'array', Plain.Edge<LockedTimeVertex>>;
-  exceptions?: EdgeWrapper<'array', Plain.Edge<ExceptionVertex>>;
-  person?: EdgeWrapper<'single', Plain.Edge<PersonVertex>>;
-}>;
-//#endregion
-export { TeacherVertex };
-//# sourceMappingURL=teachers.d.mts.map

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

@@ -1,33 +0,0 @@
-import { VertexFactory } from "./util/vertex.mjs";
-import { Coalesced, EdgeWrapper, Plain, ThreadMessage } from "./util/edges.mjs";
-import "./util/index.mjs";
-import { UserVertex } from "./users.mjs";
-import { EventVertex } from "./events.mjs";
-
-//#region src/core/interfaces/vertices/threads.d.ts
-type State = {
-  view?: 'data-tables' | 'editor';
-  filter?: Record<string, string>;
-  selector: string;
-};
-type ThreadVertex = VertexFactory<'threads', {
-  source?: EdgeWrapper<'single', Coalesced.Edge<EventVertex>>;
-  state?: State;
-  messages: EdgeWrapper<'array', ThreadMessage.Edge<UserVertex, UserVertex, {
-    id: string;
-    content: string;
-    edited?: boolean;
-    createdAt?: string | Date;
-    updatedAt?: string | Date;
-  }>>;
-  taggedPersons?: EdgeWrapper<'array', Plain.Edge<UserVertex>>;
-  color?: string;
-  resolved?: boolean;
-  positionMeta?: {
-    x: number;
-    y: number;
-  };
-}>;
-//#endregion
-export { ThreadVertex };
-//# sourceMappingURL=threads.d.mts.map

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

@@ -1,11 +0,0 @@
-import { VertexFactory } from "./util/vertex.mjs";
-import "./util/index.mjs";
-
-//#region src/core/interfaces/vertices/users.d.ts
-type UserVertex = VertexFactory<'users', {
-  username: string;
-  color?: string;
-}>;
-//#endregion
-export { UserVertex };
-//# sourceMappingURL=users.d.mts.map

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

@@ -1,28 +0,0 @@
-import { Collection, OmitVertexProperties, PickVertexProperties, Vertex } from "./vertex.mjs";
-import { EdgeMultiplicity, EdgeWrapper } from "./edges.mjs";
-import { Tail } from "./util.mjs";
-
-//#region src/core/interfaces/vertices/util/common.d.ts
-type IsAny<T> = 0 extends (1 & T) ? true : false;
-/**
- * Picks all properties of a vertex that are edges to other vertices. (we ignore explicit any types)
- */
-type PickEdges<V extends Vertex<Collection>> = { [K in keyof V as NonNullable<V[K]> extends EdgeWrapper<EdgeMultiplicity, any> ? IsAny<V[K]> extends true ? never : K : never]: V[K] };
-/**
- * Omits all properties of a vertex that are edges to other vertices.
- */
-type OmitEdges<V extends Vertex<Collection>> = PickVertexProperties<V> & OmitVertexProperties<{ [K in keyof V as NonNullable<V[K]> extends EdgeWrapper<EdgeMultiplicity, any> ? never : K]: V[K] }>;
-declare const SELECT_KEY = "select";
-type SelectKey = typeof SELECT_KEY;
-declare const EXPAND_KEY = "expand";
-type ExpandKey = typeof EXPAND_KEY;
-type InvalidEdgeMessage = 'INVALID VERTEX EDGE';
-type RemoveNeverValues<T extends object> = { [K in keyof T as T[K] extends never ? never : K]: T[K] };
-type DepthDecrementMap = [never, 0, 1, 2, 3];
-type SupportedDepths = DepthDecrementMap[number];
-type MaxDepth = Tail<DepthDecrementMap>;
-type MinDepth = Extract<SupportedDepths, 0>;
-type Decrement<T extends SupportedDepths> = DepthDecrementMap[T];
-//#endregion
-export { Decrement, EXPAND_KEY, ExpandKey, InvalidEdgeMessage, MaxDepth, MinDepth, OmitEdges, PickEdges, RemoveNeverValues, SELECT_KEY, SelectKey, SupportedDepths };
-//# sourceMappingURL=common.d.mts.map

package/dist/core/interfaces/vertices/util/custom-vertex-export/assert-no-invalid-expand-keys.d.mts

@@ -1,16 +0,0 @@
-import { Collection, Vertex } from "../vertex.mjs";
-import { DeepNonNullable } from "../util.mjs";
-import { ExpandKey } from "../common.mjs";
-import { VertexQuery } from "../vertex-query/index.mjs";
-import { Lookup } from "./util.mjs";
-
-//#region src/core/interfaces/vertices/util/custom-vertex-export/assert-no-invalid-expand-keys.d.ts
-type _AssertNoInvalidExpandKeys<Selected extends object, Available extends object> = { [K in keyof Selected]: K extends keyof Available ? Lookup<Selected[K], ExpandKey, false> extends infer a extends object ? Lookup<Available[K], ExpandKey, false> extends infer b extends object ? _AssertNoInvalidExpandKeys<a, b> : 'wtf!?' : never : `invalid expand key: ${K & string}` }[keyof Selected];
-/**
- * Recursively asserts that all keys in the 'expand' section of Q are valid.
- * If any invalid keys are found, a descriptive string literal type is returned, otherwise `unknown` is returned.
- */
-type AssertNoInvalidExpandKeys<V extends Vertex<Collection>, Q extends VertexQuery<V>> = ExpandKey & keyof Q extends never ? unknown : [_AssertNoInvalidExpandKeys<DeepNonNullable<Q>[ExpandKey], DeepNonNullable<VertexQuery<V>>[ExpandKey]>] extends [infer T] ? [T] extends [never] ? unknown : T : never;
-//#endregion
-export { AssertNoInvalidExpandKeys };
-//# sourceMappingURL=assert-no-invalid-expand-keys.d.mts.map

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

@@ -1,34 +0,0 @@
-import { Collection, Vertex } from "../vertex.mjs";
-import { AvailableLocation, Coalesced, EdgeBase, EdgeWrapper, GroupWithExclude, Plain, ThreadMessage, Wrapped } from "../edges.mjs";
-import { ExtractNullish, Prettify, SetMultiplicity } from "../util.mjs";
-import { ExpandKey, OmitEdges, PickEdges } from "../common.mjs";
-import { KeysOf } from "../keys-of.mjs";
-import { VertexQuery } from "../vertex-query/index.mjs";
-import { ExtractChildKeys, ExtractChildObject, ExtractParentKeys, IntersectExpandSelectPath, Lookup, RelaxedPick } from "./util.mjs";
-import { AssertNoInvalidExpandKeys } from "./assert-no-invalid-expand-keys.mjs";
-
-//#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 _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 }>;
-/**
- * Recursively exports a Vertex type to a plain object structure,
- * selecting and expanding properties and edges according to the provided expand/select path.
- * - Non-edge properties are included based on selection.
- * - Edge properties are exported and expanded according to their type (Plain, Coalesced, GroupWithExclude, AvailableLocation, ThreadMessage).
- * - Handles edge multiplicity (single/array) and optional/null cases.
- * - Invalid or unsupported edge unions are filtered out as `never`.
- * - Supports dot-notation for nested property selection and expansion.
- */
-type CustomVertexExport<V extends Vertex<Collection>, Q extends VertexQuery<V> & AssertNoInvalidExpandKeys<V, Q>> = _CustomVertexExport<V, Q>;
-//#endregion
-export { CustomVertexExport };
-//# sourceMappingURL=index.d.mts.map

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

@@ -1,52 +0,0 @@
-import { DeepNonNullable } from "../util.mjs";
-import { ExpandKey, SelectKey } from "../common.mjs";
-
-//#region src/core/interfaces/vertices/util/custom-vertex-export/util.d.ts
-/**
- * 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;
-/**
- * Intersect two expand/select specifications.
- *
- * - For the SelectKey ('select'): returns an array whose element type is the
- *   intersection of the element types from A and B, preserving null/undefined from A.
- * - For the ExpandKey ('expand'): keeps only keys present in both A and B and
- *   recurses into their sub-specs.
- * - Other keys are dropped.
- *
- * 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 };
-/**
- * Extracts the parent keys from a set of dot-notation keys.
- *
- * @example
- * Keys: 'a' | 'b.1' | 'c.2' | 'd'  =>  'a' | 'b' | 'c' | 'd'
- */
-type ExtractParentKeys<Keys extends keyof any> = Keys extends `${infer B}.${string}` ? B : Keys;
-/**
- * Extracts the child keys from a set of dot-notation keys, given a parent key.
- *
- * @example
- * ParentKey: 'a'
- * Keys:      'a' | 'a.1' | 'a.2' | 'b.1' | 'c'  =>  '1' | '2'
- */
-type ExtractChildKeys<Keys extends keyof any, ParentKey extends string> = Keys extends `${ParentKey}.${infer K}` ? K : never;
-/**
- * Extracts the child object from an object, given a parent key.
- *
- * @example
- * 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] };
-/**
- * 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.
- */
-type RelaxedPick<T extends object | null | undefined, Keys extends keyof any> = Extract<T, null | undefined> | (T extends object ? { [K in keyof NonNullable<T> as K extends Keys ? K : never]: NonNullable<T>[K] } : never);
-//#endregion
-export { ExtractChildKeys, ExtractChildObject, ExtractParentKeys, IntersectExpandSelectPath, Lookup, RelaxedPick };
-//# sourceMappingURL=util.d.mts.map

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

@@ -1,65 +0,0 @@
-import { Collection, IDKey, IDType, OmitInternalVertexKeys, PrivateIDKey, PrivateIDType, Vertex } from "../vertex.mjs";
-import { AvailableLocation, Coalesced, EdgeBase, EdgeWrapper, GroupWithExclude, Plain, ThreadMessage, Wrapped } from "../edges.mjs";
-import { ExtractNullish, Prettify, SetMultiplicity } from "../util.mjs";
-import { Decrement, MaxDepth, MinDepth, OmitEdges, PickEdges, SupportedDepths } from "../common.mjs";
-
-//#region src/core/interfaces/vertices/util/deep-vertex-export/index.d.ts
-type ExportOptions = {
-  mixed?: boolean;
-  optionalId?: boolean;
-  omitPrivateId?: boolean;
-};
-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 _MinDepthType = any;
-type TryPrettify<T> = 0 extends (1 & T) ? _MinDepthType : Prettify<T>;
-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 _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.
- * - Non-edge properties are preserved as-is.
- * - Edge properties are expanded according to their edge type (Plain, Coalesced, GroupWithExclude, AvailableLocation, ThreadMessage ).
- * - Invalid or unsupported edge unions are filtered out as `never`.
- * - Handles multiplicity (single/array) and optional/null edge cases.
- * - There is a maximum recursion depth to increase performance.
- * - Once the maximum depth is reached, all vertices are represented as `any`.
- */
-type DeepVertexExport<V extends Vertex<Collection>> = _DeepVertexExport<V, MaxDepth, {
-  mixed: false;
-  optionalId: false;
-}>;
-/**
- * Similar to {@link DeepVertexExport}, but each edge is represented as both the fully expanded object
- * and the vertex ID (`string | ObjectId`).
- */
-type MixedVertexExport<V extends Vertex<Collection>> = _DeepVertexExport<V, MaxDepth, {
-  mixed: true;
-  optionalId: false;
-}>;
-/**
- * Similar to {@link MixedVertexExport}, but the ID fields (`_id` and `id`) are optional.
- */
-type MixedWithOptionalIdVertexExport<V extends Vertex<Collection>> = _DeepVertexExport<V, MaxDepth, {
-  mixed: true;
-  optionalId: true;
-}>;
-/**
- * Similar to {@link DeepVertexExport}, but omits the private ID field (`_id`) from the exported type.
- */
-type DeepVertexExportOmitPrivateId<V extends Vertex<Collection>> = _DeepVertexExport<V, MaxDepth, {
-  omitPrivateId: true;
-}>;
-//#endregion
-export { DeepVertexExport, DeepVertexExportOmitPrivateId, MixedVertexExport, MixedWithOptionalIdVertexExport };
-//# sourceMappingURL=index.d.mts.map

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

@@ -1,123 +0,0 @@
-import { Collection, Vertex } from "./vertex.mjs";
-import { AllTrue, IsUnion, NoneIsUnion } from "./util.mjs";
-
-//#region src/core/interfaces/vertices/util/edges.d.ts
-declare const EDGE_TYPE_ID_KEY = "__edge_type_id";
-declare const EDGE_INVALID_KEY = "__invalid";
-declare const EDGE_VALUE_KEY = "__value";
-type EdgeValueKey = typeof EDGE_VALUE_KEY;
-type EdgeTypeIdValues = {
-  PLAIN: 'PLAIN';
-  WRAPPED: 'WRAPPED';
-  COALESCED: 'COALESCED';
-  GROUP_WITH_EXCLUDE: 'GROUP_WITH_EXCLUDE';
-  AVAILABLE_LOCATION: 'AVAILABLE_LOCATION';
-  THREAD_MESSAGE: 'THREAD_MESSAGE';
-};
-type EdgeTypeIdValue = (EdgeTypeIdValues)[keyof EdgeTypeIdValues];
-type EdgeBase<ID extends EdgeTypeIdValue, Invalid extends boolean> = {
-  [EDGE_TYPE_ID_KEY]: ID;
-  [EDGE_INVALID_KEY]: Invalid;
-};
-type EdgeIsValid<T extends EdgeBase<any, any>> = [T] extends [{
-  [EDGE_INVALID_KEY]: false;
-}] ? 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;
-  };
-}
-declare namespace Wrapped {
-  namespace Util {
-    type Options<T extends string> = {
-      key: T;
-    };
-    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>;
-  };
-}
-declare namespace Coalesced {
-  namespace Util {
-    export namespace Keys {
-      const TO = "to";
-      type To = typeof TO;
-      const TO_MODEL = "toModel";
-      type ToModel = typeof TO_MODEL;
-    }
-    export type Options = {
-      optional?: boolean;
-    };
-    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 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>;
-  };
-}
-declare namespace GroupWithExclude {
-  namespace Util {
-    namespace Keys {
-      const TO = "to";
-      type To = typeof TO;
-      const EXCLUDE = "exclude";
-      type Exclude = typeof EXCLUDE;
-    }
-    type Value<To, Exclude, Extra = object> = Extra & {
-      [Keys.TO]: To;
-      [Keys.EXCLUDE]?: Exclude[];
-    };
-  }
-  type Edge<G extends Vertex<Collection>, P extends Vertex<Collection>, E extends object = object> = EdgeBase<EdgeTypeIdValues['GROUP_WITH_EXCLUDE'], NoneIsUnion<[G, P]> extends never ? true : false> & {
-    [EDGE_VALUE_KEY]: Util.Value<G, P[], E>;
-  };
-}
-declare namespace AvailableLocation {
-  namespace Util {
-    namespace Keys {
-      const LOCATIONS = "locations";
-      type Locations = typeof LOCATIONS;
-    }
-    type Value<L, Extra = object> = Extra & {
-      [Keys.LOCATIONS]: [L];
-    };
-  }
-  type Edge<L extends Vertex<Collection>, E extends object = object> = EdgeBase<EdgeTypeIdValues['AVAILABLE_LOCATION'], NoneIsUnion<[L]> extends never ? true : false> & {
-    [EDGE_VALUE_KEY]: Util.Value<L, E>;
-  };
-}
-declare namespace ThreadMessage {
-  namespace Util {
-    namespace Keys {
-      const USER = "user";
-      type User = typeof USER;
-      const TAGGED_PERSONS = "taggedPersons";
-      type TaggedPersons = typeof TAGGED_PERSONS;
-    }
-    type Value<P, T, Extra = object> = Extra & {
-      [Keys.USER]: P;
-      [Keys.TAGGED_PERSONS]?: T[];
-    };
-  }
-  type Edge<P extends Vertex<Collection>, T extends Vertex<Collection>, E extends object = object> = EdgeBase<EdgeTypeIdValues['THREAD_MESSAGE'], NoneIsUnion<[P, T]> extends never ? true : false> & {
-    [EDGE_VALUE_KEY]: Util.Value<P, T, E>;
-  };
-}
-type AllowedEdgeType<T extends EdgeBase<EdgeTypeIdValue, boolean>> = IsUnion<T> extends never ? true : T extends Coalesced.Edge<any, any> ? true : false;
-type EdgeMultiplicity = 'single' | 'array';
-type EdgeWrapper<M extends EdgeMultiplicity, T extends EdgeBase<EdgeTypeIdValue, boolean> | null | undefined> = AllTrue<[AllowedEdgeType<NonNullable<T>>, EdgeIsValid<NonNullable<T>>]> extends false ? never : {
-  __edge_multiplicity: M;
-  __edge_type: T;
-};
-//#endregion
-export { AvailableLocation, Coalesced, EdgeBase, EdgeMultiplicity, EdgeValueKey, EdgeWrapper, GroupWithExclude, Plain, ThreadMessage, Wrapped };
-//# sourceMappingURL=edges.d.mts.map

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

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

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

@@ -1,26 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,13 +0,0 @@
-//#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