@royalschedule/maps 4.0.15 → 4.0.16

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

@@ -0,0 +1,51 @@
+import { ExpandKey, SelectKey } from "../common.js";
+
+//#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$1> = K$1 extends keyof Obj ? Obj[K$1] : never;
+/**
+ * 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$1> = [A] extends [never] ? never : { [K in keyof A & keyof B$1]: K extends SelectKey ? NonNullable<A[K]> extends (infer V1)[] ? NonNullable<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.
+ *
+ * @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$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.
+ */
+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.ts.map

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

@@ -0,0 +1,64 @@
+import { Collection, IDKey, IDType, OmitInternalVertexKeys, PrivateIDKey, PrivateIDType, Vertex } from "../vertex.js";
+import { AvailableLocation, Coalesced, EdgeBase, EdgeWrapper, GroupWithExclude, Plain, Wrapped } from "../edges.js";
+import { ExtractNullish, Prettify, SetMultiplicity } from "../util.js";
+import { Decrement, MaxDepth, MinDepth, OmitEdges, PickEdges, SupportedDepths } from "../common.js";
+
+//#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$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 _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>) : 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).
+ * - 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, IDTypes, MixedVertexExport, MixedWithOptionalIdVertexExport };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,105 @@
+import { Collection, Vertex } from "./vertex.js";
+import { AllTrue, IsUnion, NoneIsUnion } from "./util.js";
+
+//#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';
+};
+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$1 extends Vertex<Collection>> = EdgeBase<EdgeTypeIdValues['PLAIN'], NoneIsUnion<[V$1]> extends never ? true : false> & {
+    [EDGE_VALUE_KEY]: V$1;
+  };
+}
+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$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 {
+  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$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$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 {
+  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>;
+  };
+}
+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, Wrapped };
+//# sourceMappingURL=edges.d.ts.map

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

@@ -0,0 +1,5 @@
+import { Collection, PseudoCollection, RealCollection, Vertex, VertexFactory } from "./vertex.js";
+import { AvailableLocation, Coalesced, EdgeWrapper, GroupWithExclude, Plain, Wrapped } from "./edges.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/keys-of.d.ts

@@ -0,0 +1,27 @@
+import { Collection, OmitInternalVertexKeys, Vertex } from "./vertex.js";
+import { EdgeBase, EdgeValueKey, EdgeWrapper } from "./edges.js";
+import { AllKeys } from "./util.js";
+import { ExpandKey, RemoveNeverValues, SelectKey } from "./common.js";
+import { VertexQuery } from "./vertex-query/index.js";
+
+//#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.ts.map

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

@@ -0,0 +1,12 @@
+import { Collection, Vertex } from "./vertex.js";
+import { CustomVertexExport } from "./custom-vertex-export/index.js";
+
+//#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.ts.map

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

@@ -0,0 +1,76 @@
+import { EdgeMultiplicity } from "./edges.js";
+
+//#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$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$1> = U$1 extends any ? keyof U$1 : never;
+declare namespace MakeMixedNs {
+  type ExtractArrayType<T$1> = T$1 extends Array<any> ? T$1 : never;
+  type ExtractObjectType<T$1> = T$1 extends Array<any> ? never : T$1 extends object ? T$1 : never;
+  type _MakeMixedArray<T$1 extends any[]> = [T$1] extends [never] ? never : (T$1 extends Array<infer U> ? U : never) extends infer U ? Array<MakeMixed<U>> : never;
+  type _MakeMixedObject<T$1 extends object> = [T$1] extends [never] ? never : { [K in AllKeys<T$1>]: MakeMixed<GetByKey<T$1, K>> };
+  export type MakeMixed<T$1> = (ExtractArrayType<T$1> extends (infer V extends any[]) ? _MakeMixedArray<V> : never) | (ExtractObjectType<T$1> extends (infer V extends object) ? _MakeMixedObject<V> : never) | (T$1 extends object ? never : T$1);
+  export {};
+}
+/**
+ * Merges a union of types into a single type by combining properties of object types and merging array element types.
+ */
+type MakeMixed<T$1> = MakeMixedNs.MakeMixed<T$1>;
+/**
+ * Deep partial type that allows for partial properties at any level of nesting.
+ */
+type DeepPartial<T$1> = T$1 extends Array<infer U> ? Array<DeepPartial<U>> : T$1 extends object ? { [K in keyof T$1]?: DeepPartial<T$1[K]> } : T$1;
+type _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$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$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$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$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.
+ *
+ * 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$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$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$1> = Extract<T$1, null | undefined>;
+//#endregion
+export { AllKeys, AllTrue, DeepPartial, ExtractNullish, IsUnion, MakeMixed, NoneIsUnion, Prettify, SetMultiplicity, Tail };
+//# sourceMappingURL=util.d.ts.map

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

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

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

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

@@ -0,0 +1,70 @@
+import { Types } from "mongoose";
+
+//#region src/core/interfaces/vertices/util/vertex.d.ts
+
+/**
+ *
+ */
+type RealCollection = 'settings' | 'divisionSettings' | 'exceptions' | 'groups' | 'teachers' | 'locations' | 'configurations' | 'courses' | 'events' | 'generations' | 'lockedTimes' | 'overlapGroups' | 'periods' | 'rootIntervals' | 'persons' | 'syllabuses' | 'divisions' | 'companies' | 'users';
+/**
+ *
+ */
+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 = Types.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';
+  overlapGroups: 'overlapGroup';
+  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.ts.map

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

@@ -0,0 +1,102 @@
+import { VertexQuery } from "./util/vertex-query/index.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";
+import { GenerationVertex } from "./generations.js";
+import { DivisionVertex } from "./divisions.js";
+import { PersonVertex } from "./persons.js";
+import { LocationVertex } from "./locations.js";
+import { CalendarEventVertex, EventVertex, ScheduleEventVertex } from "./events.js";
+import { OverlapGroupVertex } from "./overlap-groups.js";
+import { SyllabusVertex } from "./syllabuses.js";
+import { CourseVertex } from "./courses.js";
+import { ExceptionVertex } from "./exceptions.js";
+import { GroupVertex } from "./groups.js";
+import { LockedTimeVertex } from "./locked-times.js";
+import { TeacherVertex } from "./teachers.js";
+import { CompanyVertex } from "./companies.js";
+import { UserVertex } from "./users.js";
+import { ConfigurationVertex } from "./configurations.js";
+
+//#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;
+  overlapGroups: OverlapGroupVertex;
+  periods: PeriodVertex;
+  persons: PersonVertex;
+  students: PersonVertex;
+  rootIntervals: RootIntervalVertex;
+  syllabuses: SyllabusVertex;
+  configurations: ConfigurationVertex;
+  companies: CompanyVertex;
+  users: UserVertex;
+};
+type BaseQueryRecord<C$1 extends keyof VertexRecord> = VertexQuery<VertexRecord[C$1]>;
+/**
+ * See {@link createVertexQuery}
+ */
+declare class VertexQuery$1<C$1 extends keyof VertexRecord, Q$1 extends BaseQueryRecord<C$1>> {
+  private readonly _collection;
+  private readonly _query;
+  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.
+ *
+ * @example
+ * const personQuery = createVertexQuery('persons', { select: ['id', 'firstName'] });
+ * type PersonType = Infer<typeof personQuery>;
+ */
+type Infer<T extends VertexQuery$1<any, any>> = T extends VertexQuery$1<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$1 extends VertexQuery<DivisionVertex>>(query: Q$1): VertexQuery$1<"divisions", Q$1>;
+  function settings<Q$1 extends VertexQuery<DivisionSettingsVertex>>(query: Q$1): VertexQuery$1<"divisionSettings", Q$1>;
+  function exception<Q$1 extends VertexQuery<ExceptionVertex>>(query: Q$1): VertexQuery$1<"exceptions", Q$1>;
+  function event<Q$1 extends VertexQuery<EventVertex>>(query: Q$1): VertexQuery$1<"events", Q$1>;
+  function scheduleEvent<Q$1 extends VertexQuery<ScheduleEventVertex>>(query: Q$1): VertexQuery$1<"scheduleEvents", Q$1>;
+  function calendarEvent<Q$1 extends VertexQuery<CalendarEventVertex>>(query: Q$1): VertexQuery$1<"calendarEvents", Q$1>;
+  function course<Q$1 extends VertexQuery<CourseVertex>>(query: Q$1): VertexQuery$1<"courses", Q$1>;
+  function generation<Q$1 extends VertexQuery<GenerationVertex>>(query: Q$1): VertexQuery$1<"generations", Q$1>;
+  function location<Q$1 extends VertexQuery<LocationVertex>>(query: Q$1): VertexQuery$1<"locations", Q$1>;
+  function lockedTime<Q$1 extends VertexQuery<LockedTimeVertex>>(query: Q$1): VertexQuery$1<"lockedTimes", Q$1>;
+  function overlapGroup<Q$1 extends VertexQuery<OverlapGroupVertex>>(query: Q$1): VertexQuery$1<"overlapGroups", Q$1>;
+  function period<Q$1 extends VertexQuery<PeriodVertex>>(query: Q$1): VertexQuery$1<"periods", Q$1>;
+  function person<Q$1 extends VertexQuery<PersonVertex>>(query: Q$1): VertexQuery$1<"persons", Q$1>;
+  function rootInterval<Q$1 extends VertexQuery<RootIntervalVertex>>(query: Q$1): VertexQuery$1<"rootIntervals", Q$1>;
+  function syllabus<Q$1 extends VertexQuery<SyllabusVertex>>(query: Q$1): VertexQuery$1<"syllabuses", Q$1>;
+  function group<Q$1 extends VertexQuery<GroupVertex>>(query: Q$1): VertexQuery$1<"groups", Q$1>;
+  function teacher<Q$1 extends VertexQuery<TeacherVertex>>(query: Q$1): VertexQuery$1<"teachers", Q$1>;
+}
+//#endregion
+export { Infer, VertexQuery$1 as VertexQuery, createVertexQuery };
+//# sourceMappingURL=vertex-query.d.ts.map