@league-of-foundry-developers/foundry-vtt-types 9.280.0 → 12.331.1-beta

package/src/types/config.d.mts

@@ -0,0 +1,331 @@
+import type Document from "../foundry/common/abstract/document.d.mts";
+import type { fields } from "../foundry/common/data/module.d.mts";
+import type { InterfaceToObject, MaybeEmpty, MustConform } from "./helperTypes.d.mts";
+import type { DeepPartial } from "./utils.d.mts";
+
+declare global {
+  /**
+   * Some global variables (such as {@link game}) are only initialized after certain events have happened during the
+   * initialization of Foundry VTT. For that reason, the correct types for these variables include the types for the
+   * uninitialized state.
+   *
+   * While this is correct from a type checking perspective, it can be inconvenient to have to type guard these global
+   * variables everywhere. Some users might prefer the convenience over the 100% correctness in type checking.
+   *
+   * For this reason, this interface provides a way for users to configure certain global variables to be typed more
+   * leniently, i.e., as the types of their initialized state. This is done via declaration merging. To do so merge in
+   * a property with the name of the event that should be assumed to have been run.
+   *
+   * The currently supported hooks are:
+   * - init
+   * - i18nReady
+   * - setup
+   * - ready
+   *
+   * You can also set the special key "none" to make the default behavior set the variable to `undefined` instead of a union.
+   *
+   * @example
+   * ```typescript
+   * declare global {
+   *   interface AssumeHookRan {
+   *     setup: never; // the type doesn't matter
+   *   }
+   * }
+   *
+   * const referenceToGame: Game = game; // ok! :)
+   * ```
+   */
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  interface AssumeHookRan {}
+
+  /**
+   * This interface is used to configure the used document classes at a type
+   * level. Module and system authors should use declaration merging to provide
+   * the types of their configured document classes. It is extremely important
+   * that this is kept in sync with the configuration that actually happens at
+   * runtime.
+   *
+   * @example
+   * ```typescript
+   * // myActor.ts
+   * class MyActor extends Actor {}
+   *
+   * // entryPoint.ts
+   * import { MyActor } from "./myActor"
+   *
+   * hooks.once("init", () => {
+   *   CONFIG.Actor.documentClass = typeof MyActor;
+   * });
+   *
+   * declare global {
+   *   interface DocumentClassConfig {
+   *     Actor: typeof MyActor
+   *   }
+   * }
+   * ```
+   */
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  interface DocumentClassConfig {}
+
+  /**
+   * This interface is used to configure the used object classes at a type
+   * level. Module and system authors should use declaration merging to provide
+   * the types of their configured object classes. It is extremely important
+   * that this is kept in sync with the configuration that actually happens at
+   * runtime.
+   *
+   * @example
+   * ```typescript
+   * // myToken.ts
+   * class MyToken extends Token {}
+   *
+   * // entryPoint.ts
+   * import { MyToken } from "./myToken"
+   *
+   * Hooks.once("init", () => {
+   *   CONFIG.Token.objectClass = MyToken;
+   * });
+   *
+   * declare global {
+   *   interface PlaceableObjectClassConfig {
+   *     Token: typeof MyToken;
+   *   }
+   * }
+   * ```
+   */
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  interface PlaceableObjectClassConfig {}
+
+  /**
+   * This interface together with {@link SourceConfig} is used to configure the
+   * types of the `data`  and `data._source` properties of the
+   * {@link foundry.documents.BaseActor} and {@link foundry.documents.BaseItem}
+   * classes. System authors should use declaration merging to provide the types
+   * that match their `template.json` file. It is also very important for these
+   * types to stay in sync with the `template.json` file, otherwise unexpected
+   * runtime errors might appear.
+   *
+   * @example
+   * ```typescript
+   * interface ArmorDataSourceData {
+   *   armorValue: number;
+   * }
+   *
+   * interface ArmorDataSource {
+   *   type: "armor";
+   *   data: ArmorDataSourceData;
+   * }
+   *
+   * interface WeaponDataSourceData {
+   *   damagePerHit: number;
+   *   attackSpeed: number;
+   * }
+   *
+   * interface WeaponDataSource {
+   *   type: "weapon";
+   *   data: WeaponDataSourceData;
+   * }
+   *
+   * interface ArmorDataPropertiesData extends ArmorDataSourceData {
+   *   weight: number;
+   * }
+   *
+   * interface ArmorDataProperties {
+   *   type: "armor";
+   *   data: ArmorDataPropertiesData;
+   * }
+   *
+   * interface WeaponDataPropertiesData extends WeaponDataSourceData {
+   *   damage: number;
+   * }
+   *
+   * interface WeaponDataProperties {
+   *   type: "weapon";
+   *   data: WeaponDataPropertiesData;
+   * }
+   *
+   * type MyItemDataSource = ArmorDataSource | WeaponDataSource;
+   * type MyItemDataProperties = ArmorDataProperties | WeaponDataProperties;
+   *
+   * declare global {
+   *   interface DataConfig {
+   *     Item: MyItemDataProperties;
+   *   }
+   *
+   *   interface SourceConfig {
+   *     Item: MyItemDataSource;
+   *   }
+   * }
+   * const item = await Item.create({
+   *   name: "Axe",
+   *   type: "weapon",
+   *   attackSpeed: 1,
+   *   damage: 5
+   * });
+   *
+   * if(item.data.type === "weapon") {
+   *   const damage: number = item.data.data.damage;
+   * }
+   *
+   * if(item.data._source.type === "armor") {
+   *   const armorValue = item.data._source.data.armorValue;
+   * }
+   * ```
+   */
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  interface DataConfig {}
+
+  /**
+   * Configure the return type of the `getData` method for AppV1 Applications.
+   *
+   * mode - The mode of the return type.
+   * - if mode is "partial", the return type is a partial of the data object, and will allow for any Record\<string,unknown\> to be returned, regardless of the actual data object.
+   * - if mode is "exact", the return type is the exact data object, and will not allow for any additional properties to be returned.
+   * - if mode is "object", the return type is a generic object, and will allow for any object to be returned, regardless of the actual data object.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  interface GetDataConfig {}
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  interface DataModelConfig {}
+
+  /** @see {@link DataConfig} */
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  interface SourceConfig {}
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  interface FlagConfig {}
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  interface WebRTCConfig {}
+
+  /**
+   * Injects extra data for modules from `game.module.get("module-id")`.
+   * @see {@link RequiredModules} for removing the `undefined` type for required modules.
+   *  @example
+   * ```typescript
+   * interface ModuleConfig {
+   *   "module-id": {
+   *     api: APIObject;
+   *   };
+   * }
+   * const moduleApi: APIObject | undefined = game.module.get("module-id")?.api;
+   * ```
+   */
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  interface ModuleConfig {}
+
+  /**
+   * Removes `undefined` for modules listed as keys here from the return type of `game.module.get`.
+   * Useful if a module is a required dependency.
+   * @see {@link ModuleConfig} for adding useful properties to the returned modules, like APIs.
+   * @example
+   * ```typescript
+   * interface RequiredModules {
+   *   "module-id": true;
+   * }
+   * const module: Game.ModuleData<foundry.packages.ModuleData> = game.module.get("module-id");
+   * ```
+   */
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  interface RequiredModules {}
+
+  interface SettingConfig {
+    "core.animateRollTable": boolean;
+    "core.chatBubbles": fields.BooleanField<{ initial: true }>;
+    "core.chatBubblesPan": fields.BooleanField<{ initial: true }>;
+    "core.combatTrackerConfig": MaybeEmpty<{ resource: string; skipDefeated: boolean }>;
+    "core.compendiumConfiguration": Partial<Record<string, CompendiumCollection.Configuration>>;
+    "core.coneTemplateType": "round" | "flat";
+    "core.colorSchema": fields.StringField<{
+      required: true;
+      blank: true;
+      initial: "";
+      choices: {
+        "": "SETTINGS.ColorSchemeDefault";
+        dark: "SETTINGS.ColorSchemeDark";
+        light: "SETTINGS.ColorSchemeLight";
+      };
+    }>;
+    "core.combatTheme": fields.StringField<{
+      required: true;
+      blank: false;
+      initial: "none";
+      choices: () => {
+        [K in keyof CONFIG.Combat.Sounds]: string;
+      };
+    }>;
+    "core.defaultDrawingConfig": MaybeEmpty<foundry.documents.BaseDrawing["_source"]>;
+    "core.defaultToken": DeepPartial<foundry.documents.BaseToken>;
+    "core.disableResolutionScaling": boolean;
+    "core.fontSize": number;
+    "core.fpsMeter": boolean;
+    "core.globalAmbientVolume": number;
+    "core.globalInterfaceVolume": number;
+    "core.globalPlaylistVolume": number;
+    "core.keybindings": Record<string, KeybindingActionBinding[]>;
+    "core.language": fields.StringField<{
+      required: true;
+      blank: false;
+      initial: NonNullable<typeof game.i18n>["lang"];
+      choices: typeof CONFIG.supportedLanguages;
+    }>;
+    "core.leftClickRelease": fields.BooleanField<{ initial: true }>;
+    "core.lightAnimation": boolean;
+    "core.maxFPS": number;
+    "core.mipmap": boolean;
+    "core.moduleConfiguration": Record<string, boolean>;
+    "core.noCanvas": fields.BooleanField<{ initial: false }>;
+    "core.notesDisplayToggle": boolean;
+    "core.nue.shownTips": boolean;
+    "core.performanceMode": fields.NumberField<{
+      required: true;
+      nullable: true;
+      initial: null;
+      choices: {
+        [CONST.CANVAS_PERFORMANCE_MODES.LOW]: "SETTINGS.PerformanceModeLow";
+        [CONST.CANVAS_PERFORMANCE_MODES.MED]: "SETTINGS.PerformanceModeMed";
+        [CONST.CANVAS_PERFORMANCE_MODES.HIGH]: "SETTINGS.PerformanceModeHigh";
+        [CONST.CANVAS_PERFORMANCE_MODES.MAX]: "SETTINGS.PerformanceModeMax";
+      };
+    }>;
+    "core.permissions": Game.Permissions;
+    "core.pixelRatioResolutionScaling": fields.BooleanField<{ initial: true }>;
+    "core.playlist.playingLocation": "top" | "bottom";
+    "core.rollMode": fields.StringField<{
+      required: true;
+      blank: false;
+      initial: typeof CONST.DICE_ROLL_MODES.PUBLIC;
+      choices: typeof CONFIG.Dice.rollModes;
+    }>;
+    "core.rtcClientSettings": typeof AVSettings.DEFAULT_CLIENT_SETTINGS;
+    "core.rtcWorldSettings": typeof AVSettings.DEFAULT_WORLD_SETTINGS;
+    "core.scrollingStatusText": fields.BooleanField<{ initial: true }>;
+    "core.sheetClasses": {
+      [Key in Document.Type as Document.SubTypesOf<Key> extends string ? Key : never]?: Record<
+        Document.SubTypesOf<Key> & string,
+        string
+      >;
+    };
+    "core.time": fields.NumberField<{ required: true; nullable: false; initial: 0 }>;
+    "core.tokenDragPreview": boolean;
+    "core.visionAnimation": boolean;
+  }
+}
+
+type ValidDataModel = {
+  readonly [DocumentName in foundry.abstract.Document.SystemType]?: {
+    // Recommended to be a TypeDataModel subclass but DataModel is also technically valid.
+    readonly [DocumentType in string]?: foundry.abstract.DataModel.Any;
+  };
+};
+
+type MustBeValid<T extends ValidDataModel> = T;
+
+type _TestValidDataModelConfig = MustConform<DataModelConfig, ValidDataModel>;
+
+interface ValidSettingConfig {
+  readonly [K: string]: ClientSettings.Type;
+}
+
+type _TestValidSettingConfig = MustConform<InterfaceToObject<SettingConfig>, ValidSettingConfig>;

package/src/types/configuredDocuments.d.mts

@@ -0,0 +1,103 @@
+import type { Document } from "../foundry/common/abstract/module.d.mts";
+import type { ConformRecord, InterfaceToObject, MakeConform, MustConform } from "./helperTypes.d.mts";
+
+type DocumentConform<T> = MakeConform<T, Document.AnyConstructor>;
+
+// This interface holds all documents without configuration.
+// It is structured this way to create a place for errors to show up if the type complexity grows too great.
+interface _DefaultDocuments {
+  ActiveEffect: typeof ActiveEffect;
+  ActorDelta: typeof ActorDelta;
+  Actor: typeof Actor;
+  Adventure: typeof Adventure;
+  Card: typeof Card;
+  Cards: typeof Cards;
+  ChatMessage: typeof ChatMessage;
+  Combat: typeof Combat;
+  Combatant: typeof Combatant;
+  FogExploration: typeof FogExploration;
+  Folder: typeof Folder;
+  Item: typeof Item;
+  JournalEntryPage: typeof JournalEntryPage;
+  JournalEntry: typeof JournalEntry;
+  Macro: typeof Macro;
+  PlaylistSound: typeof PlaylistSound;
+  Playlist: typeof Playlist;
+  RollTable: typeof RollTable;
+  Scene: typeof Scene;
+  Setting: typeof Setting;
+  TableResult: typeof TableResult;
+  User: typeof User;
+
+  // Placeables have corresponding document classes.
+  AmbientLight: typeof AmbientLightDocument;
+  AmbientSound: typeof AmbientSoundDocument;
+  Drawing: typeof DrawingDocument;
+  MeasuredTemplate: typeof MeasuredTemplateDocument;
+  Note: typeof NoteDocument;
+  Tile: typeof TileDocument;
+  Token: typeof TokenDocument;
+  Wall: typeof WallDocument;
+}
+
+type TestDefaultDocumentsValid = MustConform<
+  InterfaceToObject<_DefaultDocuments>,
+  Record<string, Document.AnyConstructor>
+>;
+
+type ConformedDefault = ConformRecord<_DefaultDocuments, Document.AnyConstructor>;
+
+export interface DefaultDocuments extends ConformedDefault {}
+
+// Note(LukeAbby): This helper type is structured this way to make it as simple as possible for TypeScript to figure out that it's always a Document.
+// This also uses `ConcreteDocumentType extends keyof DocumentClassConfig` instead of `GetKey` or equivalent for the critical purposes of stymying circular errors.
+// See https://gist.github.com/LukeAbby/f9561689e5cad8a4b1e9cb92a8c63982 for more information.
+type ConfiguredDocument<ConcreteDocumentType extends Document.Type> =
+  ConcreteDocumentType extends keyof DocumentClassConfig
+    ? DocumentClassConfig[ConcreteDocumentType]
+    : DefaultDocuments[ConcreteDocumentType];
+
+// This interface exists as a way to catch circular errors easier.
+// This makes it more verbose than it might seem it has to be but it's important to stay this way.
+interface _ConfiguredDocuments {
+  ActiveEffect: ConfiguredDocument<"ActiveEffect">;
+  ActorDelta: ConfiguredDocument<"ActorDelta">;
+  Actor: ConfiguredDocument<"Actor">;
+  Adventure: ConfiguredDocument<"Adventure">;
+  Card: ConfiguredDocument<"Card">;
+  Cards: ConfiguredDocument<"Cards">;
+  ChatMessage: ConfiguredDocument<"ChatMessage">;
+  Combat: ConfiguredDocument<"Combat">;
+  Combatant: ConfiguredDocument<"Combatant">;
+  FogExploration: ConfiguredDocument<"FogExploration">;
+  Folder: ConfiguredDocument<"Folder">;
+  Item: ConfiguredDocument<"Item">;
+  JournalEntryPage: ConfiguredDocument<"JournalEntryPage">;
+  JournalEntry: ConfiguredDocument<"JournalEntry">;
+  Macro: ConfiguredDocument<"Macro">;
+  PlaylistSound: ConfiguredDocument<"PlaylistSound">;
+  Playlist: ConfiguredDocument<"Playlist">;
+  RollTable: ConfiguredDocument<"RollTable">;
+  Scene: ConfiguredDocument<"Scene">;
+  Setting: ConfiguredDocument<"Setting">;
+  TableResult: ConfiguredDocument<"TableResult">;
+  User: ConfiguredDocument<"User">;
+
+  AmbientLight: ConfiguredDocument<"AmbientLight">;
+  AmbientSound: ConfiguredDocument<"AmbientSound">;
+  Drawing: ConfiguredDocument<"Drawing">;
+  MeasuredTemplate: ConfiguredDocument<"MeasuredTemplate">;
+  Note: ConfiguredDocument<"Note">;
+  Tile: ConfiguredDocument<"Tile">;
+  Token: ConfiguredDocument<"Token">;
+  Wall: ConfiguredDocument<"Wall">;
+}
+
+type TestConfiguredDocumentsValid = MustConform<
+  InterfaceToObject<_ConfiguredDocuments>,
+  Record<string, Document.AnyConstructor>
+>;
+
+type ConformedConfigured = ConformRecord<_ConfiguredDocuments, Document.AnyConstructor>;
+
+export interface ConfiguredDocuments extends _ConfiguredDocuments {}

package/src/types/helperTypes.d.mts

@@ -0,0 +1,261 @@
+import type { DatabaseOperationMap, Operation } from "../foundry/common/abstract/document.d.mts";
+import type Document from "../foundry/common/abstract/document.d.mts";
+import type { ConfiguredDocuments } from "./configuredDocuments.d.mts";
+import type { AnyObject, EmptyObject } from "./utils.d.mts";
+
+export type ModuleRequiredOrOptional<Name extends string> = Name extends keyof RequiredModules ? never : undefined;
+
+export type ConfiguredModuleData<Name extends string> = Name extends keyof ModuleConfig
+  ? ModuleConfig[Name]
+  : EmptyObject;
+
+export type ConfiguredModule<Name extends string> =
+  ModuleRequiredOrOptional<Name> extends never
+    ? ConfiguredModuleData<Name>
+    :
+        | ({ active: true } & ConfiguredModuleData<Name>)
+        // flawed, can't use `key in module` this way, but omitting the Partial Record type kills nullish
+        // collocating, which is probably the better DX.
+        | ({ active: false } & Record<keyof ConfiguredModuleData<Name>, undefined>);
+
+/** Keys of functions of console.log / globalThis.logger */
+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 `{ _?: any } & T`.
+// - `T = never` would regularly always return `unknown`. The fix here is adding `_GetKey` which makes the type distributive and therefore `never` as an input becomes `never` in the output.
+export type GetKey<T, K extends PropertyKey, D = never> = _GetKey<{ _?: any } & T, K, D>;
+
+type _GetKey<T, K extends PropertyKey, D> = T extends { readonly [_ in K]?: infer V } ? V : D;
+
+/**
+ * `Partial` is usually the wrong type.
+ * In order to make it easier to audit unintentional uses of `Partial` this type is provided.
+ */
+export type IntentionalPartial<T> = Partial<T>;
+
+/**
+ * This type is used to make a constraint where `T` must be statically known to overlap with `U`.
+ */
+export type OverlapsWith<T, U> = [T & U] extends [never] ? U : T;
+
+/**
+ * Use this whenever a type is given that should match some constraint but is
+ * not guaranteed to. For example when additional properties can be declaration
+ * merged into an interface. When the type does not conform then `ConformTo` is
+ * used instead.
+ *
+ * See `MustConform` for a version that throws a compilation error when the type
+ * cannot be statically known to conform.
+ */
+export type MakeConform<T, ConformTo> = T extends ConformTo ? T : ConformTo;
+
+/**
+ * This is useful when you want to ensure that a type conforms to a certain
+ * constraint. If it is not guaranteed to conform then a compilation error is
+ * thrown. This makes it too conservative in some cases.
+ */
+export type MustConform<T extends ConformTo, ConformTo> = T;
+
+/**
+ * This allows you to treat all interfaces as a plain object. But beware, if the
+ * interface represents a function, array, or constructor then these will be
+ * stripped from the interface.
+ *
+ * This is generally intended for cases where an interface is given in order to
+ * be declaration merged and then must be assigned to a plain object type.
+ *
+ * The constraint `T extends object` is used because `object` includes functions
+ * and arrays etc. This is crucial to allow interfaces to be given to this type.
+ */
+export type InterfaceToObject<T extends object> = {
+  // Mapped types are no-ops on most types (even primitives like string) but for
+  // functions, classes, and arrays they convert them to "proper" objects by
+  // stripping constructors/function signatures. One side effect is a type like
+  // `() => number` will result in `{}`.
+  [K in keyof T]: T[K];
+};
+
+/**
+ * Replaces the type `{}` with `Record<string, never>` which is usually a better
+ * representation of an empty object. The type `{}` actually allows any type be
+ * assigned to it except for `null` and `undefined`.
+ *
+ * The theory behind this is that all non-nullish types allow
+ * you to access any property on them without erroring. Primitive types like
+ * `number` will not store the property but it still will not error to simply
+ * try to get and set properties.
+ *
+ * The type `{}` can appear for example after operations like `Omit` if it
+ * removes all properties rom an object, because an empty interface was given,
+ * or so on.
+ *
+ * @example
+ * ```ts
+ * type ObjectArray<T extends Record<string, unknown>> = T[];
+ *
+ * // As you would hope a union can't be assigned. It errors with:
+ * // "type 'string' is not assignable to type 'Record<string, unknown>'."
+ * type UnionErrors = ObjectArray<string | { x: number }>;
+ *
+ * // However, this works.
+ * type EmptyObjectArray = ObjectArray<{}>;
+ *
+ * // But it allows likely unsound behavior like this:
+ * const emptyObject: EmptyObjectArray = [1, "foo", () => 3];
+ *
+ * // So it may be better to define `ObjectArray` like so:
+ * type ObjectArray<T extends Record<string, unknown>> = HandleEmptyObject<T>[];
+ *
+ * // If it were, then this line would error appropriately!
+ * const emptyObject: EmptyObjectArray = [1, "foo", () => 3];
+ * ```
+ */
+export type HandleEmptyObject<
+  T extends Record<string, unknown>,
+  D extends Record<string, unknown> = Record<string, never>,
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+> = [{}] extends [T] ? D : T;
+
+/**
+ * This is a helper type that allows you to ensure that a record conforms to a
+ * certain shape. This is useful when you want to ensure that a record has all
+ * keys of a certain type.
+ *
+ * When a value does not conform it is replaced with `never` to indicate that
+ * there is an issue.
+ */
+export type ConformRecord<T extends object, V> = {
+  [K in keyof T]: T[K] extends V ? T[K] : never;
+};
+
+/**
+ * This is a helper type that gets the right DatabaseOperation (including the
+ * proper options) for a particular Document type.
+ */
+export type DatabaseOperationsFor<
+  Name extends Document.Type,
+  ConcreteOperation extends Operation,
+> = DatabaseOperationMap[Name][ConcreteOperation];
+
+// Deprecated types, to be removed in the first stable v12 release or at the latest v13.
+
+/**
+ * @deprecated {@link Document.SystemType | `Document.SystemType`}.
+ */
+type DocumentTypeWithTypeData = Document.SystemType;
+
+/**
+ * @deprecated {@link Document.AnyConstructor | `Document.ConstructorDataFor`}.
+ */
+export type ConstructorDataType<T extends Document.AnyConstructor> = Document.ConstructorDataFor<T>;
+
+/**
+ * @deprecated {@link Document.AnyConstructor | `Document.AnyConstructor`}.
+ */
+export type DocumentConstructor = Document.AnyConstructor;
+
+/**
+ * @deprecated {@link Document.ToConfiguredClass | `Document.ToConfiguredClass`}.
+ */
+export type ConfiguredDocumentClass<ConcreteDocument extends Document.AnyConstructor> =
+  Document.ToConfiguredClass<ConcreteDocument>;
+
+/**
+ * @deprecated {@link Document.ToConfiguredInstance | `Document.Configured.Instance`}.
+ */
+export type ConfiguredDocumentInstance<ConcreteDocument extends Document.AnyConstructor> =
+  Document.ToConfiguredInstance<ConcreteDocument>;
+
+/**
+ * @deprecated {@link Document.Type | `Document.Type`}.
+ */
+export type DocumentType = Document.Type;
+
+/**
+ * @deprecated {@link Document.PlaceableType | `Document.PlaceableType`}.
+ */
+export type PlaceableDocumentType = Document.PlaceableType;
+
+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
+  | {
+      [K in keyof T]?: never;
+    };
+
+/**
+ * @deprecated {@link Document.SubTypesOf | `Document.SubTypesOf`}.
+ */
+export type DocumentSubTypes<T extends Document.Type> = Document.SubTypesOf<T>;
+
+/**
+ * @deprecated {@link Document.ConfiguredClassForName | `Document.ConfiguredClassForName`}.
+ */
+export type ConfiguredDocumentClassForName<Name extends Document.Type> = ConfiguredDocuments[Name];
+
+/**
+ * @deprecated {@link Document.ConfiguredInstanceForName | `Document.ConfiguredInstanceForName`}.
+ */
+export type ConfiguredDocumentInstanceForName<Name extends Document.Type> = Document.ConfiguredInstanceForName<Name>;
+
+/**
+ * @deprecated {@link Document.ConfiguredObjectClassForName | `Document.ConfiguredObjectClassForName`}.
+ */
+export type ConfiguredObjectClassForName<Name extends Document.PlaceableType> =
+  Document.ConfiguredObjectClassForName<Name>;
+
+/**
+ * @deprecated {@link PlaceablesLayer.ConfiguredClassForName | `PlaceablesLayer.ConfiguredClassForName`}.
+ */
+export type ConfiguredLayerClassForName<Name extends Document.PlaceableType> = CONFIG[Name]["layerClass"];
+
+/**
+ * See {@link Document.ConfiguredDataForName | `Document.ConfiguredDataForName`}.
+ */
+export type ConfiguredData<Name extends string> = Document.ConfiguredDataForName<MakeConform<Name, Document.Type>>;
+
+/**
+ * See {@link Document.ConfiguredDataForName | `Document.ConfiguredDataForName`}.
+ */
+export type ConfiguredSource<Name extends string> = Document.ConfiguredDataForName<MakeConform<Name, Document.Type>>;
+
+/**
+ * See {@link Document.ConfiguredFlagsForName | `Document.ConfiguredFlagsForName`}.
+ */
+export type ConfiguredFlags<Name extends string> = Document.ConfiguredFlagsForName<MakeConform<Name, Document.Type>>;
+
+/**
+ * @deprecated {@link Document.ToObjectFalseType | `Document.ToObjectFalseType`}.
+ */
+export type ToObjectFalseType<T> = Document.ToObjectFalseType<MakeConform<T, Document.Internal.Instance.Any>>;
+
+/**
+ * @deprecated {@link PropertyKey | `PropertyKey`}
+ */
+export type AnyKey = keyof any;