@league-of-foundry-developers/foundry-vtt-types 13.340.1 → 13.345.1

package/src/utils/index.d.mts

@@ -1,5 +1,7 @@
 import type { Document } from "../foundry/common/abstract/_module.d.mts";
 
+export {};
+
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
 type ConfiguredModuleData<Name extends string> = Name extends keyof ModuleConfig ? ModuleConfig[Name] : {};
 
@@ -27,12 +29,21 @@ export type LoggingLevels = "debug" | "log" | "info" | "warn" | "error";
 /**
  * `GetKey` accesses a property while intentionally ignoring index signatures. This means `GetKey<Record<string, unknown>, "foo">` will return `never`.
  */
-// Note(LukeAbby): There are two tricky cases:
-// - `T = {}` would regularly always return `unknown`. The fix here adding a single dummy property with `{ _?: unknown } & T`.
-// - `T = never` would regularly always return `unknown`. The fix here is checking if `any` is assignable to it.
-export type GetKey<T, K extends PropertyKey, D = never> = [any] extends [T] ? _GetKey<{ _?: unknown } & T, K, D> : D;
-
-type _GetKey<T, K extends PropertyKey, D> = T extends { readonly [_ in K]?: infer V } ? V : D;
+// Note(LukeAbby): There are five tricky cases:
+// - `T = {}` and `T = object` could easily return `unknown` and must be excluded.
+// - `T = never` might either distribute out or return `unknown`. The fix here is checking if `any` is assignable to it.
+// - `T = { prop?: U }` with `exactOptionalPropertyTypes` should return `U | undefined` not `U`.
+// - `T` has getters `GetKey` should still access it, this means checking `keyof T` is not helpful.
+export type GetKey<T, K extends PropertyKey, D = never> = [object] extends [T] // Handle `{}` and `object`
+  ? D
+  : [any] extends [T] // Handle never
+    ? _GetKey<T, K, D>
+    : D;
+
+// Note(LukeAbby): This uses `infer _V` specifically to avoid index signatures.
+// However it isn't `T extends { readonly [_ in K]?: infer V } ? V : D` as under
+// `exactOptionalPropertyTypes` this would not include `undefined` whereas `T[K]` does.
+type _GetKey<T, K extends PropertyKey, D> = T extends { readonly [_ in K]?: infer _V } ? T[K] : D;
 
 /**
  * `Partial` is usually the wrong type.
@@ -51,7 +62,7 @@ type _GetKey<T, K extends PropertyKey, D> = T extends { readonly [_ in K]?: infe
  *   `Object.assign({}, defaultOptions, options)`,
  *   `foundry.utils.mergeObject(defaultOptions, options)`, or so on.
  *
- *   Note that {@link foundry.utils.mergeObject | `foundry.utils.mergeObject`}
+ *   Note that {@linkcode foundry.utils.mergeObject}
  *   also expands the object. So once `ExpandsTo` exists you should also use
  *   that helper type.
  *
@@ -65,14 +76,7 @@ type _GetKey<T, K extends PropertyKey, D> = T extends { readonly [_ in K]?: infe
  *   The most common time this shows up is with the pattern
  *   `exampleFunction({ prop = "foo" } = {}) { ... }`.
  */
-export type IntentionalPartial<T extends object, K extends AllKeysOf<T> = AllKeysOf<T>> = PrettifyType<
-  {
-    [K2 in keyof T as Extract<K2, K>]?: T[K2];
-  } & {
-    // Note(LukeAbby): This effectively inlines `Omit<T, K>`, hoping for
-    [K2 in keyof T as Exclude<K2, K>]: T[K2];
-  }
->;
+export type IntentionalPartial<T extends object> = Partial<T>;
 
 /**
  * This type is used to make a constraint where `T` must be statically known to overlap with `U`.
@@ -271,29 +275,6 @@ export type ToMethod<T extends AnyFunction> = {
   method(...args: Parameters<T>): ReturnType<T>;
 }["method"];
 
-export type ConfiguredSheetClass<T extends Document.AnyConstructor> = GetKey<
-  GetKey<CONFIG, T["metadata"]["name"]>,
-  "sheetClass",
-  T
->;
-
-export type ObjectClass<T extends Document.AnyConstructor> = GetKey<
-  GetKey<CONFIG, T["metadata"]["name"]>,
-  "objectClass",
-  T
->;
-
-export type LayerClass<T extends Document.AnyConstructor> = GetKey<
-  GetKey<CONFIG, T["metadata"]["name"]>,
-  "layerClass",
-  T
->;
-
-/**
- * Actual document types that go in folders
- */
-export type FolderDocumentTypes = Exclude<foundry.CONST.FOLDER_DOCUMENT_TYPES, "Compendium">;
-
 export type MaybeEmpty<T extends AnyObject> =
   | T
   | {
@@ -304,9 +285,11 @@ export type MaybeEmpty<T extends AnyObject> =
  * The following uses `extends object` instead of `AnyObject` to allow `O = typeof SomeClass`
  */
 export type PropertiesOfType<O extends object, T> = {
-  [K in keyof O]: [O[K], T] extends [T, O[K]] ? K : never;
+  [K in keyof O]: _KeyOfType<O[K], K, T>;
 }[keyof O];
 
+type _KeyOfType<V, K, T> = V extends T ? K : never;
+
 declare class Branded<in out BrandName extends string> {
   #brand: BrandName;
 }
@@ -505,12 +488,15 @@ export type UnionToIntersection<U> = (U extends unknown ? (arg: U) => void : nev
  */
 // Allowing passing any `object` is done because it's more convenient for the end user.
 // Note that `{}` should always be assignable to `DeepPartial<T>`.
-export type DeepPartial<T extends object> = {
-  [K in keyof T]?: _DeepPartial<T[K]>;
-};
+export type DeepPartial<T extends object> = _DeepPartial<T>;
 
-// This type has to be factored out for distributivity.
-type _DeepPartial<T> = T extends object ? (T extends AnyArray | AnyFunction | AnyConstructor ? T : DeepPartial<T>) : T;
+type _DeepPartial<T> = T extends object
+  ? T extends AnyArray | AnyFunction | AnyConstructor
+    ? T
+    : {
+        [K in keyof T]?: _DeepPartial<T[K]>;
+      }
+  : T;
 
 /**
  * Gets all possible keys of `T`. This is useful because if `T` is a union type
@@ -533,7 +519,7 @@ export type AllKeysOf<T extends object> = T extends unknown ? keyof T : never;
  *   `Object.assign({}, defaultOptions, options)`,
  *   `foundry.utils.mergeObject(defaultOptions, options)`, or so on.
  *
- *   Note that {@link foundry.utils.mergeObject | `foundry.utils.mergeObject`}
+ *   Note that {@linkcode foundry.utils.mergeObject}
  *   also expands the object. So once `ExpandsTo` exists you should also use
  *   that helper type.
  *
@@ -549,14 +535,9 @@ export type AllKeysOf<T extends object> = T extends unknown ? keyof T : never;
  *
  * @internal
  */
-export type InexactPartial<T extends object, K extends AllKeysOf<T> = AllKeysOf<T>> = PrettifyType<
-  {
-    [K2 in keyof T as Extract<K2, K>]?: T[K2] | undefined;
-  } & {
-    // Note(LukeAbby): This effectively inlines `Omit<T, K>` hoping for slightly better performance.
-    [K2 in keyof T as Exclude<K2, K>]: T[K2];
-  }
->;
+export type InexactPartial<T extends object> = {
+  [K in keyof T]?: T[K] | undefined;
+};
 
 /**
  * Makes select properties in `T` optional and explicitly allows both `null` and
@@ -574,7 +555,7 @@ export type InexactPartial<T extends object, K extends AllKeysOf<T> = AllKeysOf<
  *   `Object.assign({}, defaultOptions, options)`,
  *   `foundry.utils.mergeObject(defaultOptions, options)`, or so on.
  *
- *   Note that {@link foundry.utils.mergeObject | `foundry.utils.mergeObject`}
+ *   Note that {@linkcode foundry.utils.mergeObject}
  *   also expands the object. So once `ExpandsTo` exists you should also use
  *   that helper type.
  *
@@ -590,14 +571,9 @@ export type InexactPartial<T extends object, K extends AllKeysOf<T> = AllKeysOf<
  *
  * @internal
  */
-export type NullishProps<T extends object, K extends AllKeysOf<T> = AllKeysOf<T>> = PrettifyType<
-  {
-    [K2 in keyof T as Extract<K2, K>]?: T[K2] | null | undefined;
-  } & {
-    // Note(LukeAbby): This effectively inlines `Omit<T, K>` hoping for slightly better performance.
-    [K2 in keyof T as Exclude<K2, K>]: T[K2];
-  }
->;
+export type NullishProps<T extends object> = {
+  [K in keyof T]?: T[K] | null | undefined;
+};
 
 /**
  * Expand an object that contains keys in dotted notation
@@ -658,20 +634,56 @@ export type Titlecase<S extends string> = S extends `${infer A} ${infer B}`
  * Nested properties of type `object` are merged recursively unless the property
  * in `U` is an `Array`.
  *
- * @typeParam T - The base type that `U` will be merged into.
- * @typeParam U - The type that will be merged into `T`.
+ * @template T - The base type that `U` will be merged into.
+ * @template U - The type that will be merged into `T`.
  */
-export type Merge<T, U> =
-  IsObject<U> extends true
-    ? IsObject<T> extends true
-      ? SimpleMerge<
-          T,
-          {
-            [K in keyof U]: T extends { readonly [_ in K]?: infer V } ? Merge<V, U[K]> : U[K];
-          }
-        >
-      : U
-    : U;
+export type Merge<T, U> = U extends object ? (T extends object ? _Merge<T, U> : U) : U;
+
+type _Merge<T extends object, U extends object> = T extends AnyArray
+  ? U extends AnyArray
+    ? MergeArray<T, U>
+    : _MergeObject<T, U>
+  : _MergeObject<T, U>;
+
+type _MergeObject<T extends object, U extends object> = U extends AnyObject
+  ? T extends AnyObject
+    ? _MergePlainObject<T, U>
+    : _MergeComplexObject<T, U>
+  : _MergeComplexObject<T, U>;
+
+type MergeArray<T extends AnyArray, U extends AnyArray> = number extends U["length"] | T["length"]
+  ? Array<T[number] | U[number]>
+  : [...U, ...DropFirstN<T, U["length"]>];
+
+type DropFirstN<
+  T extends AnyArray,
+  DropN extends number,
+  Accumulator extends AnyArray = [],
+> = Accumulator["length"] extends DropN
+  ? T
+  : T extends [unknown, ...infer Items]
+    ? DropFirstN<Items, DropN, [...Accumulator, 1]>
+    : [];
+
+// TODO(LukeAbby): This needs to be more complex as to account for stuff like optionality correctly.
+type _MergePlainObject<T extends object, U extends object> = {
+  [K in keyof T as K extends keyof U ? never : K]: T[K];
+} & {
+  [K in keyof U]: T extends { readonly [_ in K]?: infer V } ? Merge<V, U[K]> : U[K];
+};
+
+interface _MergeComplexObject<T extends object, U extends object> extends _Override<T, _MergePlainObject<T, U>> {}
+
+/**
+ * Overrides properties of `T` with properties in `U`. Be careful using this type as its internal
+ * implementation is likely a bit shaky.
+ *
+ * Note: `U` must NOT be a union. If it is unexpected behavior may occur.
+ */
+export type Override<T extends object, U extends object> = T extends unknown ? _Override<T, U> : never;
+
+// @ts-expect-error - This pattern is inherently an error.
+interface _Override<T extends object, U extends object> extends U, T {}
 
 /**
  * Returns whether the type is a plain object. Excludes functions, arrays, and constructors while still being friendly to interfaces.
@@ -695,8 +707,8 @@ export type IsObject<T> = T extends object ? (T extends AnyArray | AnyFunction |
 
 /**
  * A simple, non-recursive merge type.
- * @typeParam Target - the target type to merge into
- * @typeParam Override - the type whose properties override the ones in Target
+ * @template Target - the target type to merge into
+ * @template Override - the type whose properties override the ones in Target
  */
 export type SimpleMerge<Target, Override> = Omit<Target, keyof Override> & Override;
 
@@ -796,7 +808,7 @@ export type AnyMutableObject = {
 /**
  * Use this type to allow any array. This allows readonly arrays which is
  * generally what you want. If you need a mutable array use the
- * {@link MutableArray | `MutableArray`} type instead of the builtin `T[]` or
+ * {@linkcode MutableArray} type instead of the builtin `T[]` or
  * `Array` types. This allows us to be more explicit about intent.
  *
  * Consider being more specific if possible. You should generally try to use a
@@ -811,7 +823,7 @@ export type AnyArray = readonly unknown[];
 /**
  * Use this type to allow a mutable array of type `T`. Only use this if the
  * array can be soundly mutated. Otherwise you should be using
- * `readonly T[]` or {@link ReadonlyArray | `ReadonlyArray`}
+ * `readonly T[]` or {@linkcode ReadonlyArray}
  */
 export type MutableArray<T> = Array<T>;
 
@@ -834,9 +846,9 @@ export type AnyFunction = (...args: never) => unknown;
 /**
  * Use this type to allow any class, abstract class, or class-like constructor.
  *
- * See {@link AnyConcreteConstructor | `AnyConcreteConstructor`} if you cannot
+ * See {@linkcode AnyConcreteConstructor} if you cannot
  * allow abstract classes. Please also consider writing a comment
- * explaining why {@link AnyConcreteConstructor | `AnyConcreteConstructor`} is
+ * explaining why {@linkcode AnyConcreteConstructor} is
  * necessary.
  *
  * @example
@@ -856,7 +868,7 @@ export type AnyConstructor = abstract new (...args: never) => unknown;
  *
  * Use this type only when abstract classes would be problematic such as the
  * base type of a mixin. Please consider writing a comment explaining why.
- * See {@link AnyConstructor | `AnyConstructor`} to also allow abstract classes.
+ * See {@linkcode AnyConstructor} to also allow abstract classes.
  *
  * @example
  * ```ts
@@ -874,26 +886,26 @@ export type AnyConcreteConstructor = new (...args: never) => unknown;
 /**
  * This type is equivalent to `Promise<T>` but exists to give an explicit signal
  * that this is not a mistake. When Foundry accepts an asynchronous callback the
- * vast majority of the time it is best to use {@link MaybePromise | `MaybePromise`}.
+ * vast majority of the time it is best to use {@linkcode MaybePromise}.
  *
  * By doing it this way the maximum flexibility is given to the definer of the
  * callback. This is okay because typically asynchronous callbacks are simply
  * awaited, meaning that there's no noticeable difference between a `Promise`
- * and {@link MaybePromise | `MaybePromise`}. Even functions like
- * {@link Promise.allSettled | `Promise.allSettled`} function correctly
- * with {@link MaybePromise | `MaybePromise`}.
+ * and {@linkcode MaybePromise}. Even functions like
+ * {@linkcode Promise.allSettled} function correctly
+ * with {@linkcode MaybePromise}.
  *
- * Do not use this type or {@link MaybePromise | `MaybePromise`} for the return
+ * Do not use this type or {@linkcode MaybePromise} for the return
  * type of asynchronous methods on classes. For example for
  * {@link foundry.abstract.Document._preCreate | `Document#_preCreate`} the typing
  * should be `Promise<void>` and not this type. In theory we could use
- * {@link MaybePromise | `MaybePromise`} in this context as well but this seems
+ * {@linkcode MaybePromise} in this context as well but this seems
  * more likely to be confusing than to be helpful.
  *
  * Use this type only in the rare case where a callback's return type must be a
  * `Promise`, for example if `promise.then` or `promise.catch` is explicitly
  * called. Please also writing a comment explaining why
- * {@link MaybePromise | `MaybePromise`} is problematic in this context.
+ * {@linkcode MaybePromise} is problematic in this context.
  */
 export type MustBePromise<T> = Promise<T>;
 
@@ -903,7 +915,7 @@ export type MustBePromise<T> = Promise<T>;
  * callback instead.
  *
  * If it is not sound to provide a non-Promise for whatever reason, see
- * {@link MustBePromise | `MustBePromise`} to declare this more explicitly than simply writing
+ * {@linkcode MustBePromise} to declare this more explicitly than simply writing
  * `Promise<T>`.
  *
  * This should generally not be used in asynchronous methods. For example in
@@ -937,13 +949,11 @@ export type NonNullish = {};
  *
  * Use instead of `{}` when you want to represent an empty object. `{}` actually
  * allows any type that is not `null` or `undefined`. see
- * {@link NonNullish | `NonNullish`} if you want that behavior.
+ * {@linkcode NonNullish} if you want that behavior.
  */
 // It would be unsound to merge into so an interface is not used.
 export type EmptyObject = Record<string, never>;
 
-declare const empty: unique symbol;
-
 /**
  * This helper type helps emulate index signatures for types with incompatible concrete keys.
  *
@@ -981,12 +991,6 @@ export type ShapeWithIndexSignature<
   readonly [K in keyof T & IndexSignature]: K extends keyof PrimaryShape ? PrimaryShape[K] : IndexType;
 };
 
-/**
- * Defer is a utility type that allows you to defer the evaluation of a type.
- * The use cases for this are extremely advanced. In essence they have to do with breaking cycles in evaluation.
- */
-export type Defer<T> = [T][T extends any ? 0 : never];
-
 export type MustBeValidUuid<Uuid extends string, Type extends Document.Type = Document.Type> = _MustBeValidUuid<
   Uuid,
   Uuid,
@@ -1027,11 +1031,6 @@ type _MustBeValidUuid<
       : InvalidUuid<OriginalUuid>
     : `${Type}.${string}` | `${string}.${string}.${Type}.${string}`;
 
-/**
- * Drops the first element of an array
- */
-type DropFirst<T extends AnyArray> = T extends [infer _1, ...infer V] ? V : T;
-
 /**
  * This type is used when you want to use `unknown` in a union. This works because while `T | unknown`
  * will reduce to `unknown`. However by comparison the only way that `T | LazyUnknown` can reduce is
@@ -1044,7 +1043,7 @@ type DropFirst<T extends AnyArray> = T extends [infer _1, ...infer V] ? V : T;
  *
  * The type `{}` isn't actually the type for an empty object. It allows anything except
  * `null`/`undefined` which is why `{} | null | undefined` allows anything to be assigned to it.
- * See {@link NonNullish | `NonNullish`} for a further explanation on why `{}` allows anything
+ * See {@linkcode NonNullish} for a further explanation on why `{}` allows anything
  * besides `null`/`undefined`.
  */
 export type LazyUnknown = NonNullish | null | undefined;
@@ -1092,11 +1091,11 @@ export type Coalesce<T, D, CoalesceType = undefined> = T extends CoalesceType ?
 
 /**
  * Coalesces specifically `null | undefined`. Behaves like `??` does at runtime.
- * See {@link Coalesce | `Coalesce`}.
+ * See {@linkcode Coalesce}.
  */
 export type NullishCoalesce<T, D> = T extends null | undefined ? D : T;
 
-interface EarlierHook {
+export interface EarlierHook {
   none: never;
   init: "none";
   i18nInit: "none" | "init";
@@ -1105,7 +1104,7 @@ interface EarlierHook {
 }
 
 /**
- * A hook that's valid to use in {@link AssumeHookRan | `AssumeHookRan`}
+ * A hook that's valid to use in {@linkcode AssumeHookRan}
  */
 export type InitializationHook = keyof EarlierHook;
 
@@ -1119,7 +1118,7 @@ export type InitializationHook = keyof EarlierHook;
  * HooksRan<"init">;     // "none" | "init"
  * HooksRan<"i18nInit">; // "none" | "init" | "i18nInit"
  * HooksRan<"setup">;    // "none" | "init" | "i18nInit" | "setup"
- * HooksRan<"setup">;    // "none" | "init" | "i18nInit" | "setup" | "ready"
+ * HooksRan<"ready">;    // "none" | "init" | "i18nInit" | "setup" | "ready"
  * ```
  */
 export type HooksRan<T extends InitializationHook> = EarlierHook[T] | T;
@@ -1133,7 +1132,7 @@ export type InitializedOn<
   InitializedTo,
   InitializedOnHook extends InitializationHook,
   BeforeInitialization = InitializedTo | undefined,
-> = Extract<HooksRan<ValidHooksRan>, InitializedOnHook> extends never ? InitializedTo : BeforeInitialization;
+> = [InitializedOnHook] extends [HooksRan<ValidHooksRan>] ? InitializedTo : BeforeInitialization;
 
 /**
  * Returns the inputted type. This may seem like a useless type but it exists due to limitations
@@ -1244,12 +1243,16 @@ export type Identity<T extends object> = T;
  */
 export type DiscriminatedUnion<U extends object> = _DiscriminatedUnion<U, AllKeysOf<U>>;
 
-type _DiscriminatedUnion<U extends object, AllKeys extends AllKeysOf<U>> = U extends unknown
-  ? {
-      [K in keyof U]: U[K];
-    } & {
-      readonly [K in Exclude<AllKeys, keyof U>]?: never;
-    }
+// Note(LukeAbby): The `extends object` is effectively the same as `extends unknown` but used here
+// to keep `Document.SystemOfType<Document.ModuleSubType>` from being `unknown` in dependencies.
+// Inlining `Extract<..., object>` by comparison causes issues, specifically in not counting as
+// covaraint. This isn't an ideal change to make but it works.
+type _DiscriminatedUnion<U extends object, AllKeys extends AllKeysOf<U>> = U extends object
+  ? [Exclude<AllKeys, keyof U>] extends [never]
+    ? U
+    : U & {
+        readonly [K in Exclude<AllKeys, keyof U>]?: never;
+      }
   : never;
 
 /**
@@ -1266,7 +1269,7 @@ export type PickValue<T extends object, Value> = {
 };
 
 /**
- * Represnts a valid JSON value.
+ * Represents a valid JSON value.
  */
 export type JSONValue =
   | {
@@ -1284,3 +1287,123 @@ export type JSONValue =
  * simplifies to `typeof SomeConstructor`.
  */
 export type PhantomConstructor = new (...args: any[]) => unknown;
+
+/**
+ * Effectively equivalent to `str.split(delimiter)` at the type level.
+ */
+export type SplitString<S extends string, Delimiter extends string> = Delimiter extends ""
+  ? ToCharacters<S>
+  : _SplitString<S, Delimiter>;
+
+type ToCharacters<S, Return extends string[] = []> = S extends `${infer C}${infer Rest}`
+  ? ToCharacters<Rest, [...Return, C]>
+  : Return;
+
+type _SplitString<
+  S extends string,
+  Delimiter extends string,
+  Return extends string[] = [],
+> = S extends `${infer Prefix}${Delimiter}${infer Suffix}`
+  ? _SplitString<Suffix, Delimiter, [...Return, Prefix]>
+  : S extends ""
+    ? []
+    : [...Return, S];
+
+export type DeepReadonly<T extends object> = T extends AnyObject | AnyArray
+  ? { readonly [K in keyof T]: _DeepReadonly<T[K]> }
+  : DeepReadonlyComplex<T>;
+
+type _DeepReadonly<T> = T extends object ? DeepReadonly<T> : T;
+
+interface DeepReadonlyComplex<T extends object> extends _DeepReadonlyComplex<T> {}
+
+// @ts-expect-error - This pattern is intrinsically an error.
+// Note(LukeAbby): The two levels here, `DeepReadonlyComplex` and `_DeepReadonlyComplex`, could just be one.
+// However it gives a better type display as two levels.
+interface _DeepReadonlyComplex<T extends object, R extends object = { readonly [K in keyof T]: _DeepReadonly<T[K]> }>
+  extends R,
+    T {}
+
+/**
+ * Currently indistinguishable from `DotKeys` but will eventually avoid `readonly` keys.
+ */
+export type MutableDotKeys<T extends object> = DotKeys<T>;
+
+/**
+ * Currently indistinguishable from `DotKeys` but will eventually avoid keys that can't be deleted.
+ */
+export type DeletableDotKeys<T extends object> = DotKeys<T>;
+
+/**
+ * Gets the valid dotkeys for `T`. Currently only gets keys that are in all items in a union. Later
+ * configuration to loosen this will exist.
+ */
+export type DotKeys<T extends object> = {
+  [K in keyof T]: K | (K extends string ? _DotKeys<T[K], `${K}.`, [T]> : never);
+}[keyof T];
+
+type _DotKeys<T, Prefix extends string = "", Stack extends unknown[] = []> = T extends object
+  ? true extends InStack<T, Stack, 10>
+    ? never
+    : {
+        [K in keyof T]: K extends string ? `${Prefix}${K}` | _DotKeys<T[K], `${Prefix}${K}.`, [T, ...Stack]> : never;
+      }[keyof T]
+  : never;
+
+type InStack<T, Stack extends unknown[], MaxDepth extends number = 99> = Stack["length"] extends MaxDepth
+  ? true
+  : {
+      [K in keyof Stack & `${number}`]: IdentityEquals<T, Stack[K]>;
+    }[keyof Stack & `${number}`];
+
+type IdentityEquals<T, U> =
+  (<V>() => V extends T ? true : false) extends <V>() => V extends U ? true : false ? true : false;
+
+/**
+ * Gets a dot property on `T`.
+ */
+export type GetProperty<T extends object, K extends DotKeys<T>> = _GetProperty<T, K>;
+
+/**
+ * This is causing an issue with TS-Go. See https://github.com/microsoft/typescript-go/issues/1278.
+ */
+type _GetProperty<T, K, Depth extends number[] = []> = K extends keyof T
+  ? T[K]
+  : K extends `${infer First}.${infer Rest}`
+    ? First extends keyof T
+      ? _GetProperty<T[First], Rest, [1, ...Depth]>
+      : never
+    : never;
+
+/**
+ * @deprecated Replaced by {@linkcode Document.SheetClassFor}
+ */
+export type ConfiguredSheetClass<T extends Document.AnyConstructor> = GetKey<
+  GetKey<CONFIG, T["metadata"]["name"]>,
+  "sheetClass",
+  T
+>;
+
+/**
+ * @deprecated Replaced by {@linkcode Document.ObjectClassFor}
+ */
+export type ObjectClass<T extends Document.AnyConstructor> = GetKey<
+  GetKey<CONFIG, T["metadata"]["name"]>,
+  "objectClass",
+  T
+>;
+
+/**
+ * @deprecated Replaced by {@linkcode Document.LayerClassFor}
+ */
+export type LayerClass<T extends Document.AnyConstructor> = GetKey<
+  GetKey<CONFIG, T["metadata"]["name"]>,
+  "layerClass",
+  T
+>;
+
+/**
+ * Actual document types that go in folders
+ * @deprecated No replacement as this was deemed too niche.
+ */
+export type FolderDocumentTypes = Exclude<foundry.CONST.FOLDER_DOCUMENT_TYPES, "Compendium">;

package/tsconfig.base.json

@@ -0,0 +1,24 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig.json",
+  "compilerOptions": {
+    "types": [],
+    "allowImportingTsExtensions": true,
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "exactOptionalPropertyTypes": true,
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "noEmit": true,
+    "noImplicitOverride": true,
+    "strict": true,
+    "target": "ESNext",
+    "verbatimModuleSyntax": true,
+    "noUncheckedSideEffectImports": true,
+    "noUncheckedIndexedAccess": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "incremental": true,
+    "rootDir": ".",
+    "allowJs": true,
+    "checkJs": true
+  }
+}

package/tsconfig.json

@@ -1,29 +1,12 @@
 {
   "$schema": "https://json.schemastore.org/tsconfig.json",
+  "extends": "./tsconfig.base.json",
   "compilerOptions": {
-    "types": [],
-    "allowImportingTsExtensions": true,
-    "allowSyntheticDefaultImports": true,
-    "esModuleInterop": true,
-    "exactOptionalPropertyTypes": true,
-    "module": "ESNext",
-    "moduleResolution": "Bundler",
-    "noEmit": true,
-    "noImplicitOverride": true,
-    "strict": true,
-    "target": "ESNext",
-    "verbatimModuleSyntax": true,
-    "noUncheckedSideEffectImports": true,
-    "noUncheckedIndexedAccess": true,
-    "incremental": true
+    "types": []
   },
-
-  // This root project includes nothing on purpose.
-  "include": [],
-
-  "references": [
-    { "path": "./src/tsconfig.json" },
-    { "path": "./tsconfig.miscellaneous.json" },
-    { "path": "./tests/tsconfig.json" }
-  ]
+  // Annoyingly, TypeScript doesn't include hidden files by default for whatever reason.
+  "include": ["**/*", ".*", ".**/**/*"],
+  // `src/index-lenient.d.mts` is skipped because it sets `AssumeHookRan` which has some pretty global effects that would make it easy to write broken code.
+  // `tests` also mess around with configuration, add a lot of overhead, and currently don't all pass.
+  "exclude": ["src/index-lenient.d.mts", "tests", "test", "cvise"]
 }