Repository: League-of-Foundry-Developers/foundry-vtt-types
Pull request #2538 (2024-03-28 17:49:11)

CONFIG updates
Some ts-expect-error on account of the missing DataModel setup, but that can be handled later. The previous v10 updates to this somehow missed out on the DetectionMode stuff.


Patch:
diff --git a/README.md b/README.md
index 9d2481556..de8621026 100644
--- a/README.md
+++ b/README.md
@@ -7,10 +7,6 @@
 TypeScript type definitions for [Foundry Virtual Tabletop](https://foundryvtt.com/) (unofficial)
 
 [![League Discord Server](https://img.shields.io/discord/732325252788387980?label=League%20of%20Extraordinary%20Foundry%20VTT%20Developers)](https://discord.gg/52DNPzqm2Z)
-![GitHub V9 issues by-label](https://img.shields.io/github/issues-raw/League-of-Foundry-Developers/foundry-vtt-types/foundry%20V9?color=%23fe631d)
-![GitHub closed V9 issues by-label](https://img.shields.io/github/issues-closed-raw/League-of-Foundry-Developers/foundry-vtt-types/foundry%20V9?color=%23fe631d)
-![GitHub V10 issues by-label](https://img.shields.io/github/issues-raw/League-of-Foundry-Developers/foundry-vtt-types/foundry%20V10?color=%23fe631d)
-![GitHub closed V10 issues by-label](https://img.shields.io/github/issues-closed-raw/League-of-Foundry-Developers/foundry-vtt-types/foundry%20V10?color=%23fe631d)
 [![npm (tag)](https://img.shields.io/npm/v/@league-of-foundry-developers/foundry-vtt-types/latest)](https://www.npmjs.com/package/@league-of-foundry-developers/foundry-vtt-types)
 
 </div>
@@ -19,7 +15,7 @@ TypeScript type definitions for [Foundry Virtual Tabletop](https://foundryvtt.co
 
 We aim to support the latest release of each Foundry VTT version (0.7, 0.8, 9, etc.), starting with 0.7.
 
-At the moment, versions 0.7, 0.8, and 9 are fully supported. Work on support for version 10 is just starting out. See the [open foundry V10 issues](https://github.com/League-of-Foundry-Developers/foundry-vtt-types/issues?q=is%3Aopen+is%3Aissue+label%3A%22foundry+V10%22) to keep track of the progress.
+At the moment, versions 0.7, 0.8, and 9 are fully supported. Work on support for version 11 is well underway, but involves some catchup on Version 11. See the [open foundry V10 issues](https://github.com/League-of-Foundry-Developers/foundry-vtt-types/issues?q=is%3Aopen+is%3Aissue+label%3A%22foundry+V10%22) as well as the [Version 11 tracking issue](https://github.com/League-of-Foundry-Developers/foundry-vtt-types/issues/2461) to view the current progress
 
 ## Installation
 
@@ -74,8 +70,8 @@ Add foundry-vtt-types to your types section in your `tsconfig.json`:
 {
   "compilerOptions": {
     "types": ["@league-of-foundry-developers/foundry-vtt-types"],
-    "module": "Node16",
-    "moduleResolution": "Node16",
+    "module": "ES2022",
+    "moduleResolution": "Bundler",
     "esModuleInterop": true,
     "strictNullChecks": true
   }
@@ -84,7 +80,7 @@ Add foundry-vtt-types to your types section in your `tsconfig.json`:
 
 This will make the type definitions available globally in your project.
 
-Make sure you are using `"module": "Node16"` and `"moduleResolution": "Node16"`, too. It is required for some
+Make sure you are using `"module": "ES2022"` and `"moduleResolution": "Bundler"`, too. It is required for some
 dependencies to be resolved correctly.
 
 Also make sure to set `"strictNullChecks": true` because otherwise, some conditional types used in the type definitions
diff --git a/src/foundry/client/config.d.mts b/src/foundry/client/config.d.mts
index c4b0068b8..2e6671a24 100644
--- a/src/foundry/client/config.d.mts
+++ b/src/foundry/client/config.d.mts
@@ -4,10 +4,11 @@ import type * as CONST from "../common/constants.d.mts";
 import type { StatusEffect } from "./data/documents/token.d.mts";
 
 // FIXME: Replace with imports for for the right things or remove when implemented
-type DetectInvisibilityVisionMode = VisionMode;
-type TremorSenseVisionMode = VisionMode;
 type DataModel = unknown;
-declare const ColorManager: unknown;
+// @ts-expect-error Class isn't implemented yet
+declare class ActorDelta extends ClientDocumentMixin() {}
+// @ts-expect-error Class isn't implemented yet
+declare class JournalEntryPage extends ClientDocumentMixin() {}
 
 declare global {
   /**
@@ -28,8 +29,13 @@ declare global {
       /** @defaultValue `false` */
       documents: boolean;
 
-      /** @defaultValue `false` */
-      fog: boolean;
+      fog: {
+        /** @defaultValue `false` */
+        extractor: boolean;
+
+        /** @defaultValue `false` */
+        manager: boolean;
+      };
 
       /** @defaultValue `false` */
       hooks: boolean;
@@ -116,14 +122,23 @@ declare global {
       /** @defaultValue `[]` */
       compendiumIndexFields: string[];
 
+      /** @defaultValue `"ui/banners/actor-banner.webp"` */
+      compendiumBanner: string;
+
       /** @defaultValue `"fas fa-user"` */
       sidebarIcon: string;
 
       /** @defaultValue `{}` */
-      systemDataModels: Record<string, DataModel>;
+      dataModels: Record<string, DataModel>;
 
       /** @defaultValue `{}` */
       typeLabels: Record<string, string>;
+
+      /** @defaultValue `{}` */
+      typeIcons: Record<string, string>;
+
+      /** @defaultValue `{}` */
+      trackableAttributes: Record<string, string>;
     };
 
     /**
@@ -138,7 +153,10 @@ declare global {
       /** @defaultValue `[]` */
       compendiumIndexFields: string[];
 
-      /** @defaultValue `"fa-solid fa-folder-tree"` */
+      /** @defaultValue `"ui/banners/adventure-banner.webp"` */
+      compendiumBanner: string;
+
+      /** @defaultValue `"fa-solid fa-treasure-chest"` */
       sidebarIcon: string;
     };
 
@@ -159,7 +177,7 @@ declare global {
       sidebarIcon: string;
 
       /** @defaultValue `{}` */
-      systemDataModels: Record<string, DataModel>;
+      dataModels: Record<string, DataModel>;
 
       /**
        * @defaultValue
@@ -179,6 +197,19 @@ declare global {
        * ```
        */
       presets: Record<string, CONFIG.Cards.Preset>;
+
+      /** @defaultValue `{}` */
+      typeLabels: Record<string, string>;
+
+      typeIcons: {
+        /** @defaultValue `"fas fa-cards"` */
+        deck: string;
+        /** @defaultValue `"fa-duotone fa-cards"` */
+        hand: string;
+        /** @defaultValue `"fa-duotone fa-layer-group"` */
+        pile: string;
+        [x: string]: string;
+      };
     };
 
     /**
@@ -245,18 +276,25 @@ declare global {
     };
 
     /**
-     * Configuration for dice rolling behaviors in the Foundry VTT client
+     * Configuration for dice rolling behaviors in the Foundry Virtual Tabletop client
      */
     Dice: {
-      /** @defaultValue `[Die, FateDie]` */
+      /**
+       * The Dice types which are supported.
+       * @defaultValue `[Die, FateDie]`
+       */
       types: Array<ConstructorOf<DiceTerm>>;
 
       rollModes: CONFIG.Dice.RollModes;
 
-      /** @defaultValue `[Roll]` */
+      /**
+       * Configured Roll class definitions
+       * @defaultValue `[Roll]`
+       */
       rolls: Array<ConstructorOf<Roll>>;
 
       /**
+       * Configured DiceTerm class definitions
        * @defaultValue
        * ```typescript
        * {
@@ -272,15 +310,21 @@ declare global {
        */
       termTypes: Record<string, ConstructorOf<RollTerm>>;
 
+      /**
+       * Configured roll terms and the classes they map to.
+       */
       terms: {
         c: typeof Coin;
         d: typeof Die;
         f: typeof FateDie;
       } & Record<string, ConstructorOf<DiceTerm>>;
 
-      /** @defaultValue `MersenneTwister.random` */
+      /**
+       * A function used to provide random uniform values.
+       * @defaultValue `MersenneTwister.random`
+       */
       randomUniform: () => number;
-    };
+    } & Record<string, ConstructorOf<Roll>>; // Common pattern
 
     /**
      * Configuration for the FogExploration document
@@ -320,11 +364,14 @@ declare global {
       /** @defaultValue `[]` */
       compendiumIndexFields: string[];
 
+      /** @defaultValue `"ui/banners/item-banner.webp"` */
+      compendiumBanner: string;
+
       /** @defaultValue `"fas fa-suitcase"` */
       sidebarIcon: string;
 
       /** @defaultValue `{}` */
-      systemDataModels: Record<string, DataModel>;
+      dataModels: Record<string, DataModel>;
 
       /** @defaultValue `{}` */
       typeLabels: Record<string, string>;
@@ -340,6 +387,12 @@ declare global {
       /** @defaultValue `Journal` */
       collection: ConstructorOf<Journal>;
 
+      /** @defaultValue `[]` */
+      compendiumIndexFields: string[];
+
+      /** @defaultValue `"ui/banners/journalentry-banner.webp"` */
+      compendiumBanner: string;
+
       noteIcons: {
         /** @defaultValue `"icons/svg/anchor.svg"` */
         Anchor: string;
@@ -440,6 +493,9 @@ declare global {
       /** @defaultValue `[]` */
       compendiumIndexFields: string[];
 
+      /** @defaultValue `"ui/banners/macro-banner.webp"` */
+      compendiumBanner: string;
+
       /** @defaultValue `"fas fa-code"` */
       sidebarIcon: string;
     };
@@ -457,6 +513,9 @@ declare global {
       /** @defaultValue `[]` */
       compendiumIndexFields: string[];
 
+      /** @defaultValue `"ui/banners/playlist-banner.webp"` */
+      compendiumBanner: string;
+
       /** @defaultValue `"fas fa-music"` */
       sidebarIcon: string;
 
@@ -474,9 +533,12 @@ declare global {
       /** @defaultValue `RollTables` */
       collection: ConstructorOf<RollTables>;
 
-      /** @defaultValue `[]` */
+      /** @defaultValue `["formula"]` */
       compendiumIndexFields: string[];
 
+      /** @defaultValue `"ui/banners/rolltable-banner.webp"` */
+      compendiumBanner: string;
+
       /** @defaultValue `"fas fa-th-list"` */
       sidebarIcon: string;
 
@@ -500,6 +562,9 @@ declare global {
       /** @defaultValue `[]` */
       compendiumIndexFields: string[];
 
+      /** @defaultValue `"ui/banners/scene-banner.webp"` */
+      compendiumBanner: string;
+
       /** @defaultValue `"fas fa-map"` */
       sidebarIcon: string;
     };
@@ -542,6 +607,9 @@ declare global {
       /** @defaultValue `0.25` */
       darknessLightPenalty: number;
 
+      /** @defaultValue `/Edg|Firefox|Electron/` */
+      videoPremultiplyRgx: RegExp;
+
       dispositionColors: {
         /** @defaultValue `0xe72124` */
         HOSTILE: number;
@@ -560,6 +628,9 @@ declare global {
 
         /** @defaultValue `0xff9829` */
         CONTROLLED: number;
+
+        /** @defaultValue `0xA612D4` */
+        SECRET: number;
       };
 
       /** @defaultValue `0x000000` */
@@ -590,10 +661,19 @@ declare global {
       fogManager: typeof FogManager;
 
       /** @defaultValue `ColorManager` */
-      colorManager: typeof ColorManager;
-
-      /** @defaultValue `ClockwiseSweepPolygon` */
-      losBackend: typeof PointSourcePolygon;
+      colorManager: typeof CanvasColorManager;
+
+      polygonBackends: {
+        /** @defaultValue `typeof ClockwiseSweepPolygon` */
+        sight: typeof PointSourcePolygon;
+        /** @defaultValue `typeof ClockwiseSweepPolygon` */
+        light: typeof PointSourcePolygon;
+        /** @defaultValue `typeof ClockwiseSweepPolygon` */
+        sound: typeof PointSourcePolygon;
+        /** @defaultValue `typeof ClockwiseSweepPolygon` */
+        move: typeof PointSourcePolygon;
+      };
+      visibilityFilter: typeof VisibilityFilter;
 
       /** @defaultValue `Ruler` */
       rulerClass: typeof Ruler;
@@ -603,6 +683,9 @@ declare global {
         luminosity: number;
       };
 
+      /** @defaultValue `0.8` */
+      dragSpeedModifier: number;
+
       /** @defaultValue `3.0` */
       maxZoom: number;
 
@@ -638,6 +721,31 @@ declare global {
           colorationShader: ConstructorOf<AbstractBaseShader>;
         };
 
+        revolving: {
+          /** @defaultValue `"LIGHT.AnimationRevolving"` */
+          label: string;
+
+          /** @defaultValue `LightSource.prototype.animateTime` */
+          animation: CONFIG.Canvas.LightAnimationFunction;
+
+          /** @defaultValue `RevolvingColorationShader` */
+          colorationShader: ConstructorOf<AbstractBaseShader>;
+        };
+
+        siren: {
+          /** @defaultValue `"LIGHT.AnimationSiren"` */
+          label: string;
+
+          /** @defaultValue `LightSource.prototype.animateTorch` */
+          animation: CONFIG.Canvas.LightAnimationFunction;
+
+          /** @defaultValue `SirenIlluminationShader` */
+          illuminationShader: ConstructorOf<AbstractBaseShader>;
+
+          /** @defaultValue `SirenIlluminationShader` */
+          colorationShader: ConstructorOf<AbstractBaseShader>;
+        };
+
         pulse: {
           /** @defaultValue `"LIGHT.AnimationPulse"` */
           label: string;
@@ -908,28 +1016,13 @@ declare global {
          *   label: "VISION.ModeBasicVision",
          *   vision: {
          *     defaults: { attenuation: 0, contrast: 0, saturation: 0, brightness: 0 }
+         *     preferred: true // Takes priority over other vision modes
          *   }
          * })
          * ```
          */
         basic: VisionMode;
 
-        /**
-         * Detect Invisibility
-         * @defaultValue
-         * ```typescript
-         * new DetectInvisibilityVisionMode({
-         *   id: "detectInvisibility",
-         *   label: "VISION.ModeDetectInvisibility",
-         *   vision: {
-         *     darkness: { adaptive: false },
-         *     defaults: { attenuation: 0, contrast: 0, saturation: 0, brightness: 0 }
-         *   }
-         * })
-         * ```
-         */
-        detectInvisibility: DetectInvisibilityVisionMode;
-
         /**
          * Darkvision
          * @defaultValue
@@ -939,7 +1032,7 @@ declare global {
          *   label: "VISION.ModeDarkvision",
          *     canvas: {
          *       shader: ColorAdjustmentsSamplerShader,
-         *       uniforms: { enable: true, contrast: 0, saturation: -1.0, brightness: 0 }
+         *       uniforms: { contrast: 0, saturation: -1.0, brightness: 0 }
          *   },
          *   lighting: {
          *     levels: {
@@ -948,6 +1041,7 @@ declare global {
          *   background: { visibility: VisionMode.LIGHTING_VISIBILITY.REQUIRED }
          *   },
          *   vision: {
+         *     darkness: { adaptive: false },
          *     defaults: { attenuation: 0, contrast: 0, saturation: -1.0, brightness: 0 }
          *   }
          * })
@@ -964,20 +1058,20 @@ declare global {
          *   label: "VISION.ModeMonochromatic",
          *   canvas: {
          *     shader: ColorAdjustmentsSamplerShader,
-         *     uniforms: { enable: true, contrast: 0, saturation: -1.0, brightness: 0 }
+         *     uniforms: { contrast: 0, saturation: -1.0, brightness: 0 }
          *   },
          *   lighting: {
          *     background: {
          *       postProcessingModes: ["SATURATION"],
-         *       uniforms: { saturation: -1.0 }
+         *       uniforms: { saturation: -1.0, tint: [1, 1, 1] }
          *     },
          *     illumination: {
          *       postProcessingModes: ["SATURATION"],
-         *       uniforms: { saturation: -1.0 }
+         *       uniforms: { saturation: -1.0, tint: [1, 1, 1] }
          *     },
          *     coloration: {
          *       postProcessingModes: ["SATURATION"],
-         *       uniforms: { saturation: -1.0 }
+         *       uniforms: { saturation: -1.0, tint: [1, 1, 1] }
          *     }
          *   },
          *   vision: {
@@ -999,7 +1093,7 @@ declare global {
          *   tokenConfig: false,
          *   canvas: {
          *     shader: ColorAdjustmentsSamplerShader,
-         *     uniforms: { enable: true, contrast: -0.75, saturation: -1, exposure: -0.3 }
+         *     uniforms: { contrast: -0.75, saturation: -1, exposure: -0.3 }
          *   },
          *   lighting: {
          *     background: { visibility: VisionMode.LIGHTING_VISIBILITY.DISABLED },
@@ -1019,12 +1113,12 @@ declare global {
          * Tremorsense
          * @defaultValue
          * ```typescript
-         * new TremorSenseVisionMode({
+         * new VisionMode({
          *   id: "tremorsense",
          *   label: "VISION.ModeTremorsense",
          *   canvas: {
          *     shader: ColorAdjustmentsSamplerShader,
-         *     uniforms: { enable: true, contrast: 0, saturation: -0.8, exposure: -0.65 }
+         *     uniforms: { contrast: 0, saturation: -0.8, exposure: -0.65 }
          *   },
          *   lighting: {
          *     background: { visibility: VisionMode.LIGHTING_VISIBILITY.DISABLED },
@@ -1037,10 +1131,10 @@ declare global {
          *     background: { shader: WaveBackgroundVisionShader },
          *     coloration: { shader: WaveColorationVisionShader }
          *   }
-         * })
+         * }, {animated: true})
          * ```
          */
-        tremorsense: TremorSenseVisionMode;
+        tremorsense: VisionMode;
 
         /**
          * Light Amplification
@@ -1051,17 +1145,21 @@ declare global {
          *   label: "VISION.ModeLightAmplification",
          *   canvas: {
          *     shader: AmplificationSamplerShader,
-         *     uniforms: { enable: true, contrast: 0, saturation: -0.5, exposure: -0.25, tint: [0.48, 1.0, 0.48] }
+         *     uniforms: { saturation: -0.5, tint: [0.38, 0.8, 0.38] }
          *   },
          *   lighting: {
-         *     background: { visibility: VisionMode.LIGHTING_VISIBILITY.DISABLED },
+         *     background: {
+         *       visibility: VisionMode.LIGHTING_VISIBILITY.REQUIRED,
+         *       postProcessingModes: ["SATURATION", "EXPOSURE"],
+         *       uniforms: { saturation: -0.5, exposure: 1.5, tint: [0.38, 0.8, 0.38] }
+         *     },
          *     illumination: {
-         *       postProcessingModes: ["EXPOSURE"],
-         *       uniforms: { exposure: 0.8 }
+         *       postProcessingModes: ["SATURATION"],
+         *       uniforms: { saturation: -0.5 }
          *     },
          *     coloration: {
-         *       postProcessingModes: ["SATURATION", "TINT", "EXPOSURE"],
-         *       uniforms: { saturation: -0.75, exposure: 8.0, tint: [0.48, 1.0, 0.48] }
+         *       postProcessingModes: ["SATURATION", "EXPOSURE"],
+         *       uniforms: { saturation: -0.5, exposure: 1.5, tint: [0.38, 0.8, 0.38] }
          *     },
          *     levels: {
          *       [VisionMode.LIGHTING_LEVELS.DIM]: VisionMode.LIGHTING_LEVELS.BRIGHT,
@@ -1080,6 +1178,25 @@ declare global {
       };
     };
 
+    /**
+     * The set of DetectionMode definitions which are available to be used for visibility detection.
+     */
+    detectionModes: {
+      [key: string]: DetectionMode;
+
+      basicSight: DetectionModeBasicSight;
+
+      seeInvisibility: DetectionModeInvisibility;
+
+      senseInvisibility: DetectionModeInvisibility;
+
+      feelTremor: DetectionModeTremor;
+
+      seeAll: DetectionModeAll;
+
+      senseAll: DetectionModeAll;
+    };
+
     /**
      * Configure the default Token text style so that it may be reused and overridden by modules
      * @defaultValue
@@ -1107,15 +1224,181 @@ declare global {
      * Available Weather Effects implementations
      */
     weatherEffects: {
-      /** @defaultValue `AutumnLeavesWeatherEffect` */
-      leaves: ConstructorOf<SpecialEffect>;
+      [key: string]: CONFIG.WeatherAmbienceConfiguration;
 
-      /** @defaultValue `RainWeatherEffect` */
-      rain: ConstructorOf<SpecialEffect>;
+      /**
+       * @defaultValue
+       * ```ts
+       * {
+       *   id: "leaves",
+       *   label: "WEATHER.AutumnLeaves",
+       *   effects: [{
+       *     id: "leavesParticles",
+       *     effectClass: AutumnLeavesWeatherEffect
+       *   }]
+       * }
+       * ```
+       */
+      leaves: CONFIG.WeatherAmbienceConfiguration;
+
+      /**
+       * @defaultValue
+       * ```ts
+       * {
+       *   id: "rain",
+       *   label: "WEATHER.Rain",
+       *   filter: {
+       *     enabled: false
+       *   },
+       *   effects: [{
+       *     id: "rainShader",
+       *     effectClass: WeatherShaderEffect,
+       *     shaderClass: RainShader,
+       *     blendMode: PIXI.BLEND_MODES.SCREEN,
+       *     config: {
+       *       opacity: 0.25,
+       *       tint: [0.7, 0.9, 1.0],
+       *       intensity: 1,
+       *       strength: 1,
+       *       rotation: 0.2618,
+       *       speed: 0.2,
+       *     }
+       *   }]
+       * }
+       * ```
+       */
+      rain: CONFIG.WeatherAmbienceConfiguration;
+
+      /**
+       * @defaultValue
+       * ```
+       * {
+       *   id: "rainStorm",
+       *   label: "WEATHER.RainStorm",
+       *   filter: {
+       *     enabled: false
+       *   },
+       *   effects: [{
+       *     id: "fogShader",
+       *     effectClass: WeatherShaderEffect,
+       *     shaderClass: FogShader,
+       *     blendMode: PIXI.BLEND_MODES.SCREEN,
+       *     performanceLevel: 2,
+       *     config: {
+       *       slope: 1.5,
+       *       intensity: 0.050,
+       *       speed: -55.0,
+       *       scale: 25,
+       *     }
+       *   },
+       *   {
+       *     id: "rainShader",
+       *     effectClass: WeatherShaderEffect,
+       *     shaderClass: RainShader,
+       *     blendMode: PIXI.BLEND_MODES.SCREEN,
+       *     config: {
+       *       opacity: 0.45,
+       *       tint: [0.7, 0.9, 1.0],
+       *       intensity: 1.5,
+       *       strength: 1.5,
+       *       rotation: 0.5236,
+       *       speed: 0.30,
+       *     }
+       *   }]
+       * }
+       * ```
+       */
+      rainStorm: CONFIG.WeatherAmbienceConfiguration;
+
+      /**
+       * @defaultValue
+       * ```
+       * {
+       *   id: "fog",
+       *   label: "WEATHER.Fog",
+       *   filter: {
+       *     enabled: false
+       *   },
+       *   effects: [{
+       *     id: "fogShader",
+       *     effectClass: WeatherShaderEffect,
+       *     shaderClass: FogShader,
+       *     blendMode: PIXI.BLEND_MODES.SCREEN,
+       *     config: {
+       *       slope: 0.45,
+       *       intensity: 0.4,
+       *       speed: 0.4,
+       *     }
+       *   }]
+       * }
+       * ```
+       */
+      fog: CONFIG.WeatherAmbienceConfiguration;
+
+      /**
+       * @defaultValue
+       * ```
+       * {
+       *   id: "snow",
+       *   label: "WEATHER.Snow",
+       *   filter: {
+       *     enabled: false
+       *   },
+       *   effects: [{
+       *     id: "snowShader",
+       *     effectClass: WeatherShaderEffect,
+       *     shaderClass: SnowShader,
+       *     blendMode: PIXI.BLEND_MODES.SCREEN,
+       *     config: {
+       *       tint: [0.85, 0.95, 1],
+       *       direction: 0.5,
+       *       speed: 2,
+       *       scale: 2.5,
+       *     }
+       *   }]
+       * }
+       * ```
+       * */
+      snow: CONFIG.WeatherAmbienceConfiguration;
 
-      /** @defaultValue `SnowWeatherEffect` */
-      snow: ConstructorOf<SpecialEffect>;
-    } & Record<string, ConstructorOf<SpecialEffect>>;
+      /**
+       * @defaultValue
+       * ```
+       * {
+       *   id: "blizzard",
+       *   label: "WEATHER.Blizzard",
+       *   filter: {
+       *     enabled: false
+       *   },
+       *   effects: [{
+       *     id: "snowShader",
+       *     effectClass: WeatherShaderEffect,
+       *     shaderClass: SnowShader,
+       *     blendMode: PIXI.BLEND_MODES.SCREEN,
+       *     config: {
+       *       tint: [0.95, 1, 1],
+       *       direction: 0.80,
+       *       speed: 8,
+       *       scale: 2.5,
+       *     }
+       *   },
+       *   {
+       *     id: "fogShader",
+       *     effectClass: WeatherShaderEffect,
+       *     shaderClass: FogShader,
+       *     blendMode: PIXI.BLEND_MODES.SCREEN,
+       *     performanceLevel: 2,
+       *     config: {
+       *       slope: 1.0,
+       *       intensity: 0.15,
+       *       speed: -4.0,
+       *     }
+       *   }]
+       * }
+       * ```
+       */
+      blizzard: CONFIG.WeatherAmbienceConfiguration;
+    };
 
     /**
      * The control icons used for rendering common HUD operations
@@ -1168,6 +1451,9 @@ declare global {
 
       /** @defaultValue `"icons/svg/door-locked-outline.svg"` */
       doorLocked: string;
+
+      /** @defaultValue `"icons/svg/wall-direction.svg"` */
+      wallDirection: string;
     } & Record<string, string>;
 
     /**
@@ -1176,6 +1462,16 @@ declare global {
      * ```typescript
      * {
      *   Arial: { editor: true; fonts: [] };
+     *   Amiri: {
+     *     editor: true,
+     *     fonts: [
+     *       {urls: ["fonts/amiri/amiri-regular.woff2"]},
+     *       {urls: ["fonts/amiri/amiri-bold.woff2"], weight: 700}
+     *     ]
+     *   },
+     *   "Bruno Ace": {editor: true, fonts: [
+     *     {urls: ["fonts/bruno-ace/bruno-ace.woff2"]}
+     *   ]},
      *   Courier: { editor: true; fonts: [] };
      *   "Courier New": { editor: true; fonts: [] };
      *   "Modesto Condensed": {
@@ -1226,162 +1522,162 @@ declare global {
      * [
      *   {
      *     id: "dead";
-     *     label: "EFFECT.StatusDead";
+     *     name: "EFFECT.StatusDead";
      *     icon: "icons/svg/skull.svg";
      *   },
      *   {
      *     id: "unconscious";
-     *     label: "EFFECT.StatusUnconscious";
+     *     name: "EFFECT.StatusUnconscious";
      *     icon: "icons/svg/unconscious.svg";
      *   },
      *   {
      *     id: "sleep";
-     *     label: "EFFECT.StatusAsleep";
+     *     name: "EFFECT.StatusAsleep";
      *     icon: "icons/svg/sleep.svg";
      *   },
      *   {
      *     id: "stun";
-     *     label: "EFFECT.StatusStunned";
+     *     name: "EFFECT.StatusStunned";
      *     icon: "icons/svg/daze.svg";
      *   },
      *   {
      *     id: "prone";
-     *     label: "EFFECT.StatusProne";
+     *     name: "EFFECT.StatusProne";
      *     icon: "icons/svg/falling.svg";
      *   },
      *   {
      *     id: "restrain";
-     *     label: "EFFECT.StatusRestrained";
+     *     name: "EFFECT.StatusRestrained";
      *     icon: "icons/svg/net.svg";
      *   },
      *   {
      *     id: "paralysis";
-     *     label: "EFFECT.StatusParalysis";
+     *     name: "EFFECT.StatusParalysis";
      *     icon: "icons/svg/paralysis.svg";
      *   },
      *   {
      *     id: "fly";
-     *     label: "EFFECT.StatusFlying";
+     *     name: "EFFECT.StatusFlying";
      *     icon: "icons/svg/wing.svg";
      *   },
      *   {
      *     id: "blind";
-     *     label: "EFFECT.StatusBlind";
+     *     name: "EFFECT.StatusBlind";
      *     icon: "icons/svg/blind.svg";
      *   },
      *   {
      *     id: "deaf";
-     *     label: "EFFECT.StatusDeaf";
+     *     name: "EFFECT.StatusDeaf";
      *     icon: "icons/svg/deaf.svg";
      *   },
      *   {
      *     id: "silence";
-     *     label: "EFFECT.StatusSilenced";
+     *     name: "EFFECT.StatusSilenced";
      *     icon: "icons/svg/silenced.svg";
      *   },
      *   {
      *     id: "fear";
-     *     label: "EFFECT.StatusFear";
+     *     name: "EFFECT.StatusFear";
      *     icon: "icons/svg/terror.svg";
      *   },
      *   {
      *     id: "burning";
-     *     label: "EFFECT.StatusBurning";
+     *     name: "EFFECT.StatusBurning";
      *     icon: "icons/svg/fire.svg";
      *   },
      *   {
      *     id: "frozen";
-     *     label: "EFFECT.StatusFrozen";
+     *     name: "EFFECT.StatusFrozen";
      *     icon: "icons/svg/frozen.svg";
      *   },
      *   {
      *     id: "shock";
-     *     label: "EFFECT.StatusShocked";
+     *     name: "EFFECT.StatusShocked";
      *     icon: "icons/svg/lightning.svg";
      *   },
      *   {
      *     id: "corrode";
-     *     label: "EFFECT.StatusCorrode";
+     *     name: "EFFECT.StatusCorrode";
      *     icon: "icons/svg/acid.svg";
      *   },
      *   {
      *     id: "bleeding";
-     *     label: "EFFECT.StatusBleeding";
+     *     name: "EFFECT.StatusBleeding";
      *     icon: "icons/svg/blood.svg";
      *   },
      *   {
      *     id: "disease";
-     *     label: "EFFECT.StatusDisease";
+     *     name: "EFFECT.StatusDisease";
      *     icon: "icons/svg/biohazard.svg";
      *   },
      *   {
      *     id: "poison";
-     *     label: "EFFECT.StatusPoison";
+     *     name: "EFFECT.StatusPoison";
      *     icon: "icons/svg/poison.svg";
      *   },
      *   {
      *     id: "curse";
-     *     label: "EFFECT.StatusCursed";
+     *     name: "EFFECT.StatusCursed";
      *     icon: "icons/svg/sun.svg";
      *   },
      *   {
      *     id: "regen";
-     *     label: "EFFECT.StatusRegen";
+     *     name: "EFFECT.StatusRegen";
      *     icon: "icons/svg/regen.svg";
      *   },
      *   {
      *     id: "degen";
-     *     label: "EFFECT.StatusDegen";
+     *     name: "EFFECT.StatusDegen";
      *     icon: "icons/svg/degen.svg";
      *   },
      *   {
      *     id: "upgrade";
-     *     label: "EFFECT.StatusUpgrade";
+     *     name: "EFFECT.StatusUpgrade";
      *     icon: "icons/svg/upgrade.svg";
      *   },
      *   {
      *     id: "downgrade";
-     *     label: "EFFECT.StatusDowngrade";
+     *     name: "EFFECT.StatusDowngrade";
      *     icon: "icons/svg/downgrade.svg";
      *   },
      *   {
      *     id: "invisible",
-     *     label: "EFFECT.StatusInvisible",
+     *     name: "EFFECT.StatusInvisible",
      *     icon: "icons/svg/invisible.svg"
      *   },
      *   {
      *     id: "target";
-     *     label: "EFFECT.StatusTarget";
+     *     name: "EFFECT.StatusTarget";
      *     icon: "icons/svg/target.svg";
      *   },
      *   {
      *     id: "eye";
-     *     label: "EFFECT.StatusMarked";
+     *     name: "EFFECT.StatusMarked";
      *     icon: "icons/svg/eye.svg";
      *   },
      *   {
      *     id: "bless";
-     *     label: "EFFECT.StatusBlessed";
+     *     name: "EFFECT.StatusBlessed";
      *     icon: "icons/svg/angel.svg";
      *   },
      *   {
      *     id: "fireShield";
-     *     label: "EFFECT.StatusFireShield";
+     *     name: "EFFECT.StatusFireShield";
      *     icon: "icons/svg/fire-shield.svg";
      *   },
      *   {
      *     id: "coldShield";
-     *     label: "EFFECT.StatusIceShield";
+     *     name: "EFFECT.StatusIceShield";
      *     icon: "icons/svg/ice-shield.svg";
      *   },
      *   {
      *     id: "magicShield";
-     *     label: "EFFECT.StatusMagicShield";
+     *     name: "EFFECT.StatusMagicShield";
      *     icon: "icons/svg/mage-shield.svg";
      *   },
      *   {
      *     id: "holyShield";
-     *     label: "EFFECT.StatusHolyShield";
+     *     name: "EFFECT.StatusHolyShield";
      *     icon: "icons/svg/holy-shield.svg";
      *   }
      * ]
@@ -1420,6 +1716,19 @@ declare global {
       en: string;
     } & Record<string, string>;
 
+    /**
+     * Localization constants.
+     */
+    i18n: {
+      /**
+       * In operations involving the document index, search prefixes must have at least this many characters to avoid too
+       * large a search space. Languages that have hundreds or thousands of characters will typically have very shallow
+       * search trees, so it should be safe to lower this number in those cases.
+       * @defaultValue `4`
+       */
+      searchMinimumCharacterLength: number;
+    };
+
     /**
      * Configuration for time tracking
      */
@@ -1437,6 +1746,24 @@ declare global {
     ActiveEffect: {
       /** @defaultValue `ActiveEffect` */
       documentClass: ConfiguredDocumentClassOrDefault<typeof ActiveEffect>;
+
+      /**
+       * If true, Active Effects on Items will be copied to the Actor when the Item is created on the Actor if the
+       * Active Effect's transfer property is true, and will be deleted when that Item is deleted from the Actor.
+       * If false, Active Effects are never copied to the Actor, but will still apply to the Actor from within the Item
+       * if the transfer property on the Active Effect is true.
+       * @deprecated since v11
+       */
+      legacyTransferral: boolean;
+    };
+
+    /**
+     * Configuration for the ActorDelta embedded document type.
+     */
+    ActorDelta: {
+      /** @defaultValue `ActorDelta` */
+      // @ts-expect-error Class isn't implemented yet
+      documentClass: ConfiguredDocumentClassOrDefault<typeof ActorDelta>;
     };
 
     /**
@@ -1447,7 +1774,7 @@ declare global {
       documentClass: ConfiguredDocumentClassOrDefault<typeof Card>;
 
       /** @defaultValue `{}` */
-      systemDataModels: Record<string, DataModel>;
+      dataModels: Record<string, DataModel>;
     };
 
     /**
@@ -1458,6 +1785,35 @@ declare global {
       documentClass: ConfiguredDocumentClassOrDefault<typeof TableResult>;
     };
 
+    JournalEntryPage: {
+      /** @defaultValue `JournalEntryPage` */
+      // @ts-expect-error Class isn't implemented yet
+      documentClass: ConfiguredDocumentClassOrDefault<typeof JournalEntryPage>;
+
+      dataModels: Record<string, DataModel>;
+
+      typeLabels: Record<string, string>;
+
+      typeIcons: {
+        [type: string]: string;
+
+        /** @defaultValue `"fas fa-file-image"` */
+        image: string;
+        /** @defaultValue `"fas fa-file-pdf"` */
+        pdf: string;
+        /** @defaultValue `"fas fa-file-lines"` */
+        text: string;
+        /** @defaultValue `"fas fa-file-video"` */
+        video: string;
+      };
+
+      /** @defaultValue `"text"` */
+      defaultType: string;
+
+      /** @defaultValue `"fas fa-book-open"` */
+      sidebarIcon: string;
+    };
+
     /**
      * Configuration for the ActiveEffect embedded document type
      */
@@ -1595,6 +1951,9 @@ declare global {
 
       /** @defaultValue `TokenConfig` */
       prototypeSheetClass: ConstructorOf<TokenConfig>;
+
+      /** @defaultValue `"TOKEN.Adjectives"` */
+      adjectivesPrefix: string;
     };
 
     /**
@@ -1609,6 +1968,237 @@ declare global {
 
       /** @defaultValue `WallsLayer` */
       layerClass: typeof WallsLayer;
+
+      /** @defaultValue `1` */
+      thresholdAttenuationMultiplier: number;
+
+      doorSounds: {
+        [sound: string]: CONFIG.WallDoorSound;
+
+        /**
+         * ```ts
+         * {
+         *   label: "WALLS.DoorSound.FuturisticFast",
+         *   close: "sounds/doors/futuristic/close-fast.ogg",
+         *   lock: "sounds/doors/futuristic/lock.ogg",
+         *   open: "sounds/doors/futuristic/open-fast.ogg",
+         *   test: "sounds/doors/futuristic/test.ogg",
+         *   unlock: "sounds/doors/futuristic/unlock.ogg"
+         * }
+         * ```
+         */
+        futuristicFast: CONFIG.WallDoorSound;
+
+        /**
+         * ```ts
+         * {
+         *   label: "WALLS.DoorSound.FuturisticHydraulic",
+         *   close: "sounds/doors/futuristic/close-hydraulic.ogg",
+         *   lock: "sounds/doors/futuristic/lock.ogg",
+         *   open: "sounds/doors/futuristic/open-hydraulic.ogg",
+         *   test: "sounds/doors/futuristic/test.ogg",
+         *   unlock: "sounds/doors/futuristic/unlock.ogg"
+         * }
+         * ```
+         */
+        futuristicHydraulic: CONFIG.WallDoorSound;
+
+        /**
+         * ```ts
+         * {
+         *   label: "WALLS.DoorSound.FuturisticForcefield",
+         *   close: "sounds/doors/futuristic/close-forcefield.ogg",
+         *   lock: "sounds/doors/futuristic/lock.ogg",
+         *   open: "sounds/doors/futuristic/open-forcefield.ogg",
+         *   test: "sounds/doors/futuristic/test-forcefield.ogg",
+         *   unlock: "sounds/doors/futuristic/unlock.ogg"
+         * }
+         * ```
+         */
+        futuristicForcefield: CONFIG.WallDoorSound;
+
+        /**
+         * ```ts
+         * {
+         *   label: "WALLS.DoorSound.Industrial",
+         *   close: "sounds/doors/industrial/close.ogg",
+         *   lock: "sounds/doors/industrial/lock.ogg",
+         *   open: "sounds/doors/industrial/open.ogg",
+         *   test: "sounds/doors/industrial/test.ogg",
+         *   unlock: "sounds/doors/industrial/unlock.ogg"
+         * }
+         * ```
+         */
+        industrial: CONFIG.WallDoorSound;
+
+        /**
+         * ```ts
+         * {
+         *   label: "WALLS.DoorSound.IndustrialCreaky",
+         *   close: "sounds/doors/industrial/close-creaky.ogg",
+         *   lock: "sounds/doors/industrial/lock.ogg",
+         *   open: "sounds/doors/industrial/open-creaky.ogg",
+         *   test: "sounds/doors/industrial/test.ogg",
+         *   unlock: "sounds/doors/industrial/unlock.ogg"
+         * }
+         * ```
+         */
+        industrialCreaky: CONFIG.WallDoorSound;
+
+        /**
+         * ```ts
+         * {
+         *   label: "WALLS.DoorSound.Jail",
+         *   close: "sounds/doors/jail/close.ogg",
+         *   lock: "sounds/doors/jail/lock.ogg",
+         *   open: "sounds/doors/jail/open.ogg",
+         *   test: "sounds/doors/jail/test.ogg",
+         *   unlock: "sounds/doors/jail/unlock.ogg"
+         * }
+         * ```
+         */
+        jail: CONFIG.WallDoorSound;
+
+        /**
+         * ```ts
+         * {
+         *   label: "WALLS.DoorSound.Metal",
+         *   close: "sounds/doors/metal/close.ogg",
+         *   lock: "sounds/doors/metal/lock.ogg",
+         *   open: "sounds/doors/metal/open.ogg",
+         *   test: "sounds/doors/metal/test.ogg",
+         *   unlock: "sounds/doors/metal/unlock.ogg"
+         * }
+         * ```
+         */
+        metal: CONFIG.WallDoorSound;
+
+        /**
+         * ```ts
+         * {
+         *   label: "WALLS.DoorSound.SlidingMetal",
+         *   close: "sounds/doors/shutter/close.ogg",
+         *   lock: "sounds/doors/shutter/lock.ogg",
+         *   open: "sounds/doors/shutter/open.ogg",
+         *   test: "sounds/doors/shutter/test.ogg",
+         *   unlock: "sounds/doors/shutter/unlock.ogg"
+         * }
+         * ```
+         */
+        slidingMetal: CONFIG.WallDoorSound;
+
+        /**
+         * ```ts
+         * {
+         *   label: "WALLS.DoorSound.SlidingModern",
+         *   close: "sounds/doors/sliding/close.ogg",
+         *   lock: "sounds/doors/sliding/lock.ogg",
+         *   open: "sounds/doors/sliding/open.ogg",
+         *   test: "sounds/doors/sliding/test.ogg",
+         *   unlock: "sounds/doors/sliding/unlock.ogg"
+         * }
+         * ```
+         */
+        slidingModern: CONFIG.WallDoorSound;
+
+        /**
+         * ```ts
+         * {
+         *   label: "WALLS.DoorSound.SlidingWood",
+         *   close: "sounds/doors/sliding/close-wood.ogg",
+         *   lock: "sounds/doors/sliding/lock.ogg",
+         *   open: "sounds/doors/sliding/open-wood.ogg",
+         *   test: "sounds/doors/sliding/test.ogg",
+         *   unlock: "sounds/doors/sliding/unlock.ogg"
+         * }
+         * ```
+         */
+        slidingWood: CONFIG.WallDoorSound;
+
+        /**
+         * ```ts
+         * {
+         *   label: "WALLS.DoorSound.StoneBasic",
+         *   close: "sounds/doors/stone/close.ogg",
+         *   lock: "sounds/doors/stone/lock.ogg",
+         *   open: "sounds/doors/stone/open.ogg",
+         *   test: "sounds/doors/stone/test.ogg",
+         *   unlock: "sounds/doors/stone/unlock.ogg"
+         * }
+         * ```
+         */
+        stoneBasic: CONFIG.WallDoorSound;
+
+        /**
+         * ```ts
+         * {
+         *   label: "WALLS.DoorSound.StoneRocky",
+         *   close: "sounds/doors/stone/close-rocky.ogg",
+         *   lock: "sounds/doors/stone/lock.ogg",
+         *   open: "sounds/doors/stone/open-rocky.ogg",
+         *   test: "sounds/doors/stone/test.ogg",
+         *   unlock: "sounds/doors/stone/unlock.ogg"
+         * }
+         * ```
+         */
+        stoneRocky: CONFIG.WallDoorSound;
+
+        /**
+         * ```ts
+         * {
+         *   label: "WALLS.DoorSound.StoneSandy",
+         *   close: "sounds/doors/stone/close-sandy.ogg",
+         *   lock: "sounds/doors/stone/lock.ogg",
+         *   open: "sounds/doors/stone/open-sandy.ogg",
+         *   test: "sounds/doors/stone/test.ogg",
+         *   unlock: "sounds/doors/stone/unlock.ogg"
+         * }
+         * ```
+         */
+        stoneSandy: CONFIG.WallDoorSound;
+
+        /**
+         * ```ts
+         * {
+         *   label: "WALLS.DoorSound.WoodBasic",
+         *   close: "sounds/doors/wood/close.ogg",
+         *   lock: "sounds/doors/wood/lock.ogg",
+         *   open: "sounds/doors/wood/open.ogg",
+         *   test: "sounds/doors/wood/test.ogg",
+         *   unlock: "sounds/doors/wood/unlock.ogg"
+         * }
+         * ```
+         */
+        woodBasic: CONFIG.WallDoorSound;
+
+        /**
+         * ```ts
+         * {
+         *   label: "WALLS.DoorSound.WoodCreaky",
+         *   close: "sounds/doors/wood/close-creaky.ogg",
+         *   lock: "sounds/doors/wood/lock.ogg",
+         *   open: "sounds/doors/wood/open-creaky.ogg",
+         *   test: "sounds/doors/wood/test.ogg",
+         *   unlock: "sounds/doors/wood/unlock.ogg"
+         * }
+         * ```
+         */
+        woodCreaky: CONFIG.WallDoorSound;
+
+        /**
+         * ```ts
+         * {
+         *   label: "WALLS.DoorSound.WoodHeavy",
+         *   close: "sounds/doors/wood/close-heavy.ogg",
+         *   lock: "sounds/doors/wood/lock.ogg",
+         *   open: "sounds/doors/wood/open-heavy.ogg",
+         *   test: "sounds/doors/wood/test.ogg",
+         *   unlock: "sounds/doors/wood/unlock.ogg"
+         * }
+         * ```
+         */
+        woodHeavy: CONFIG.WallDoorSound;
+      };
     };
 
     /**
@@ -1745,6 +2335,9 @@ declare global {
         /** @defaultValue `{ groupClass: InterfaceCanvasGroup, parent: "rendered" }` */
         interface: CONFIG.Canvas.GroupDefinition<typeof InterfaceCanvasGroup>;
 
+        /** @defaultValue `{ groupClass: OverlayCanvasGroup, parent: "stage" }` */
+        overlay: CONFIG.Canvas.GroupDefinition<typeof OverlayCanvasGroup>;
+
         [key: string]: CONFIG.Canvas.GroupDefinition;
       }
 
@@ -1813,6 +2406,23 @@ declare global {
       }
     }
 
+    interface WeatherAmbienceConfiguration {
+      id: string;
+      label: string;
+      filter: {
+        enabled: boolean;
+        blendMode: PIXI.BLEND_MODES;
+      };
+      effects: WeatherEffectConfiguration;
+    }
+
+    interface WeatherEffectConfiguration {
+      id: string;
+      effectClass: typeof ParticleEffect | typeof WeatherShaderEffect;
+      blendMode: PIXI.BLEND_MODES;
+      config: Record<string, unknown>;
+    }
+
     namespace Cards {
       interface Preset {
         type: string;
@@ -1839,6 +2449,26 @@ declare global {
       }
     }
 
+    interface WallDoorSound {
+      /** A localization string label */
+      label: string;
+
+      /** A sound path when the door is closed */
+      close: string;
+
+      /** A sound path when the door becomes locked */
+      lock: string;
+
+      /** A sound path when opening the door */
+      open: string;
+
+      /** A sound path when attempting to open a locked door */
+      test: string;
+
+      /** A sound path when the door becomes unlocked */
+      unlock: string;
+    }
+
     namespace TextEditor {
       /**
        * @param match   - The regular expression match result
diff --git a/src/foundry/client/game.d.mts b/src/foundry/client/game.d.mts
index 85930adc0..851faeb8e 100644
--- a/src/foundry/client/game.d.mts
+++ b/src/foundry/client/game.d.mts
@@ -8,6 +8,12 @@ import type {
 } from "../../types/helperTypes.d.mts";
 import type { StoredDocument, ValueOf } from "../../types/utils.d.mts";
 
+// TODO: DataModels
+type World = unknown;
+type System = unknown;
+// TODO: Apps
+type ClientIssues = unknown;
+
 declare global {
   /**
    * The core Game instance which encapsulates the data, settings, and states relevant for managing the game experience.
@@ -26,144 +32,157 @@ declare global {
      * The named view which is currently active.
      * Game views include: join, setup, players, license, game, stream
      */
-    view: Game.View;
+    readonly view: Game.View;
 
     /**
      * The object of world data passed from the server
      */
-    data: Game.Data;
+    readonly data: Game.Data;
 
-    /** The Release data for this version of Foundry */
-    release: foundry.config.ReleaseData;
+    /**
+     * The Release data for this version of Foundry
+     */
+    readonly release: foundry.config.ReleaseData;
 
     /**
      * The id of the active World user, if any
      */
-    userId: string | null;
+    readonly userId: string | null;
 
     /**
      * The game World which is currently active.
      */
-    world: this["data"]["world"];
+    readonly world: World;
 
     /**
      * The System which is used to power this game World.
      */
-    system: this["data"]["system"];
+    readonly system: System;
 
     /**
      * A Map of active Modules which are currently eligible to be enabled in this World.
      * The subset of Modules which are designated as active are currently enabled.
      */
-    modules: Game.ModuleMap;
+    readonly modules: Game.ModuleMap;
 
     /**
      * A mapping of WorldCollection instances, one per primary Document type.
+     * @remarks Initialized between the `"i18nInit"` and `"setup"` hook events
      */
-    collections: foundry.utils.Collection<WorldCollection<DocumentConstructor, string>>;
+    readonly collections: foundry.utils.Collection<WorldCollection<DocumentConstructor, string>>;
 
     /**
      * A mapping of CompendiumCollection instances, one per Compendium pack.
+     * @remarks Initialized between the `"i18nInit"` and `"setup"` hook events
      */
-    packs: foundry.utils.Collection<CompendiumCollection<CompendiumCollection.Metadata>>;
+    readonly packs: foundry.utils.Collection<CompendiumCollection<CompendiumCollection.Metadata>>;
 
     /**
      * A singleton web Worker manager.
      */
-    workers: WorkerManager;
+    readonly workers: WorkerManager;
 
     /**
      * Localization support
+     * @remarks Initialized between the `"init"` and `"i18nInit"` hook events.
      */
-    i18n: Localization;
+    readonly i18n: Localization;
 
     /**
      * The Keyboard Manager
      * @remarks Initialized between the `"setup"` and `"ready"` hook events.
-     * @defaultValue `null`
      */
-    keyboard: KeyboardManager | null;
+    readonly keyboard: KeyboardManager;
 
     /**
      * The Mouse Manager
      * @remarks Initialized between the `"setup"` and `"ready"` hook events.
-     * @defaultValue `null`
      */
-    mouse: MouseManager | null;
+    readonly mouse: MouseManager;
 
     /**
      * The Gamepad Manager
      * @remarks Initialized between the `"setup"` and `"ready"` hook events.
-     * @defaultValue `null`
      */
-    gamepad: GamepadManager | null;
+    readonly gamepad: GamepadManager;
 
     /**
      * The New User Experience manager.
      */
-    nue: NewUserExperience;
+    readonly nue: NewUserExperience;
 
     /**
      * The user role permissions setting
      * @remarks Initialized between the `"setup"` and `"ready"` hook events.
-     * @defaultValue `null`
      */
-    permissions: Game.Permissions | null;
+    readonly permissions: Game.Permissions;
 
     /**
      * The client session id which is currently active
      */
-    sessionId: string;
+    readonly sessionId: string;
 
     /**
      * Client settings which are used to configure application behavior
+     * @remarks Settings are registered between `"init"` and `"i18nInit"` hook events.
      */
-    settings: ClientSettings;
+    readonly settings: ClientSettings;
 
     /**
      * Client keybindings which are used to configure application behavior
+     * @remarks Initialized between the `"setup"` and `"ready"` hook events.
      */
-    keybindings: ClientKeybindings;
+    readonly keybindings: ClientKeybindings;
 
     /**
      * A reference to the open Socket.io connection
      */
-    socket: io.Socket | null;
+    readonly socket: io.Socket;
 
     /**
      * A singleton GameTime instance which manages the progression of time within the game world.
      */
-    time: GameTime;
+    readonly time: GameTime;
 
     /**
      * A singleton reference to the Canvas object which may be used.
+     * @remarks Initialized between the `"setup"` and `"ready"` hook events.
      */
-    canvas: Canvas;
+    readonly canvas: Canvas;
 
     /**
      * A singleton instance of the Audio Helper class
      */
-    audio: AudioHelper;
+    readonly audio: AudioHelper;
 
     /**
      * A singleton instance of the Video Helper class
+     * @remarks Initialized between the `"i18nInit"` and `"setup"` hook events.
      */
-    video: VideoHelper;
+    readonly video: VideoHelper;
 
     /**
      * A singleton instance of the TooltipManager class
+     * @remarks Initialized between the `"i18nInit"` and `"setup"` hook events.
      */
-    tooltip: TooltipManager;
+    readonly tooltip: TooltipManager;
 
     /**
      * A singleton instance of the Tour collection class
+     * @remarks Initialized between the `"i18nInit"` and `"setup"` hook events.
      */
-    tours: Tours;
+    readonly tours: Tours;
 
     /**
      * The global document index.
+     * @remarks Initialized between the `"i18nInit"` and `"setup"` hook events.
      */
-    documentIndex: DocumentIndex;
+    readonly documentIndex: DocumentIndex;
+
+    /**
+     * The singleton instance of the ClientIssues manager.
+     */
+    readonly issues: ClientIssues;
 
     /**
      * Whether the Game is running in debug mode
@@ -238,11 +257,6 @@ declare global {
      */
     initialize(): void;
 
-    /**
-     * Display certain usability error messages which are likely to result in the player having a bad experience.
-     */
-    protected _displayUsabilityErrors(): void;
-
     /**
      * Shut down the currently active Game. Requires GameMaster user permission.
      */
@@ -573,8 +587,10 @@ declare global {
       };
       model: {
         Actor: Record<string, Record<string, unknown>>;
+        Card: Record<string, Record<string, unknown>>;
         Cards: Record<string, Record<string, unknown>>;
         Item: Record<string, Record<string, unknown>>;
+        JournalEntryPage: Record<string, Record<string, unknown>>;
       };
       path: string;
       template: {
@@ -595,6 +611,7 @@ declare global {
       type: "world";
     }
 
+    // TODO: Rework after Module class is defined
     interface ModuleMap extends Map<string, Game["data"]["modules"][number]> {
       /**
        * Gets the module requested for by ID
@@ -615,13 +632,14 @@ declare global {
         remoteIsAccessible: boolean | null;
       };
       coreUpdate: {
-        channel: unknown | null;
+        channel: string | null;
         couldReachWebsite: boolean;
         hasUpdate: boolean;
         slowResponse: boolean;
-        version: unknown | null;
+        version: string | null;
         willDisableModules: boolean;
       };
+      demoMode: boolean;
       files: {
         s3?: {
           endpoint: {
@@ -637,44 +655,55 @@ declare global {
         } | null;
         storages: ("public" | "data" | "s3")[];
       };
+      // Todo: Update after data models
       modules: ModuleData<foundry.packages.ModuleData>[];
       options: {
-        demo: boolean;
         language: string;
         port: number;
         routePrefix: string | null;
         updateChannel: string;
       };
+      packageWarnings: Record<string, unknown>;
       packs: {
-        /** @deprecated since V9 */
-        entity: foundry.CONST.COMPENDIUM_DOCUMENT_TYPES;
-        index: {
-          _id: string;
-          name: string;
-          type: string;
-        }[];
+        flags: Record<string, unknown>;
+        id: string;
         label: string;
         name: string;
-        package: string;
+        ownership: Record<
+          ValueOf<typeof foundry.CONST.USER_ROLE_NAMES>,
+          keyof typeof foundry.CONST.DOCUMENT_PERMISSION_LEVELS
+        >;
+        packageName: string;
+        packageType: foundry.CONST.PACKAGE_TYPES;
         path: string;
-        private: boolean;
+        /** @deprecated since v11 */
+        private?: boolean;
         system?: string;
         type: foundry.CONST.COMPENDIUM_DOCUMENT_TYPES;
       }[];
       paused: boolean;
+      // TODO: Update after DataModels to use ReleaseData
       release: {
         build: number;
         channel: "Stable" | "Testing" | "Development" | "Prototype";
-        download: string;
-        generation: string;
-        notes: string;
+        download: string | undefined;
+        generation: number;
+        maxGeneration?: number;
+        maxStableGeneration?: number;
+        node_version?: number;
+        notes: string | undefined;
         time: number;
       };
+      // TODO: Update after data models
       system: SystemData<foundry.packages.SystemData>;
-      systemUpdate: string | null;
+      systemUpdate: {
+        hasUpdate: boolean;
+        version: string;
+      };
+      // TODO: I think this is only for configurable types
+      template: Record<foundry.CONST.DOCUMENT_TYPES, DocumentTemplate>;
       userId: string;
-      /** @deprecated since V9 */
-      version?: string;
+      // TODO: Update after data models
       world: WorldData<foundry.packages.WorldData>;
     } & {
       [DocumentType in
@@ -707,3 +736,8 @@ declare global {
 type ConfiguredCollectionClassForName<Name extends foundry.CONST.DOCUMENT_TYPES> = InstanceType<
   CONFIG[Name]["collection"]
 >;
+
+type DocumentTemplate = {
+  htmlFields: string[];
+  types: string[];
+};
diff --git a/src/foundry/common/constants.d.mts b/src/foundry/common/constants.d.mts
index d28687fc3..7abb71fb0 100644
--- a/src/foundry/common/constants.d.mts
+++ b/src/foundry/common/constants.d.mts
@@ -33,13 +33,53 @@ export const ASCII = `__________________________________________________________
 
 /**
  * Define the allowed ActiveEffect application modes
+ * @remarks (by Foundry) Other arbitrary mode numbers can be used by systems and modules to identify special behaviors and are ignored
  */
 export declare const ACTIVE_EFFECT_MODES: Readonly<{
+  /**
+   * Used to denote that the handling of the effect is programmatically provided by a system or module.
+   */
   CUSTOM: 0;
+
+  /**
+   * Multiplies a numeric base value by the numeric effect value
+   * @example
+   * 2 (base value) * 3 (effect value) = 6 (derived value)
+   */
   MULTIPLY: 1;
+
+  /**
+   * Adds a numeric base value to a numeric effect value, or concatenates strings
+   * @example
+   * 2 (base value) + 3 (effect value) = 5 (derived value)
+   * @example
+   * "Hello" (base value) + " World" (effect value) = "Hello World"
+   */
   ADD: 2;
+
+  /**
+   * Keeps the lower value of the base value and the effect value
+   * @example
+   * 2 (base value), 0 (effect value) = 0 (derived value)
+   * @example
+   * 2 (base value), 3 (effect value) = 2 (derived value)
+   */
   DOWNGRADE: 3;
+
+  /**
+   * Keeps the greater value of the base value and the effect value
+   * @example
+   * 2 (base value), 4 (effect value) = 4 (derived value)
+   * @example
+   * 2 (base value), 1 (effect value) = 2 (derived value)
+   */
   UPGRADE: 4;
+
+  /**
+   * Directly replaces the base value with the effect value
+   * @example
+   * 2 (base value), 4 (effect value) = 4 (derived value)
+   */
   OVERRIDE: 5;
 }>;
 export type ACTIVE_EFFECT_MODES = ValueOf<typeof ACTIVE_EFFECT_MODES>;
@@ -54,10 +94,33 @@ export declare const BASE_DOCUMENT_TYPE: "base";
  * TOP and FIRST are synonymous, as are BOTTOM and LAST.
  */
 export declare const CARD_DRAW_MODES: Readonly<{
+  /**
+   * Draw the first card from the stack
+   * Synonymous with @see CARD_DRAW_MODES.TOP
+   */
   FIRST: 0;
+
+  /**
+   * Draw the top card from the stack
+   * Synonymous with @see CARD_DRAW_MODES.FIRST
+   */
   TOP: 0;
+
+  /**
+   * Draw the last card from the stack
+   * Synonymous with @see CARD_DRAW_MODES.BOTTOM
+   */
   LAST: 1;
+
+  /**
+   * Draw the bottom card from the stack
+   * Synonymous with @see CARD_DRAW_MODES.LAST
+   */
   BOTTOM: 1;
+
+  /**
+   * Draw a random card from the stack
+   */
   RANDOM: 2;
 }>;
 export type CARD_DRAW_MODES = ValueOf<typeof CARD_DRAW_MODES>;
@@ -77,11 +140,38 @@ export type CANVAS_PERFORMANCE_MODES = ValueOf<typeof CANVAS_PERFORMANCE_MODES>;
  * Valid Chat Message types
  */
 export declare const CHAT_MESSAGE_TYPES: Readonly<{
+  /**
+   * An uncategorized chat message
+   */
   OTHER: 0;
+
+  /**
+   * The message is spoken out of character (OOC).
+   * OOC messages will be outlined by the player's color to make them more easily recognizable.
+   */
   OOC: 1;
+
+  /**
+   * The message is spoken by an associated character.
+   */
   IC: 2;
+
+  /**
+   * The message is an emote performed by the selected character.
+   * Entering "/emote waves his hand." while controlling a character named Simon will send the message, "Simon waves his hand."
+   */
   EMOTE: 3;
+
+  /**
+   * A message whispered to the target.
+   * If the user sending the message does not have the "Private Messages" permission, Gamemasters will be able to see the content of the message even if they were not a recipient.
+   * If the whisper's target is a character, the whisper will be sent to whoever controls the token.
+   */
   WHISPER: 4;
+
+  /**
+   * A message that is a dice roll.
+   */
   ROLL: 5;
 }>;
 export type CHAT_MESSAGE_TYPES = ValueOf<typeof CHAT_MESSAGE_TYPES>;
@@ -93,19 +183,40 @@ export declare const CORE_SUPPORTED_LANGUAGES: readonly ["en"];
 
 /**
  * Configure the severity of compatibility warnings.
- * If SILENT, nothing will be logged
- * If WARNING, a message will be logged at the "warn" level
- * If ERROR, a message will be logged at the "error" level
- * If FAILURE, an Error will be thrown
  */
 export declare const COMPATIBILITY_MODES: Readonly<{
+  /**
+   * Nothing will be logged
+   */
   SILENT: 0;
+
+  /**
+   * A message will be logged at the "warn" level
+   */
   WARNING: 1;
+
+  /**
+   * A message will be logged at the "error" level
+   */
   ERROR: 2;
+
+  /**
+   * An Error will be thrown
+   */
   FAILURE: 3;
 }>;
 export type COMPATIBILITY_MODES = ValueOf<typeof COMPATIBILITY_MODES>;
 
+/**
+ * The CSS themes which are currently supported for the V11 Setup menu.
+ */
+export declare const CSS_THEMES: Readonly<{
+  foundry: "THEME.foundry";
+  fantasy: "THEME.fantasy";
+  scifi: "THEME.scifi";
+}>;
+export type CSS_THEMES = ValueOf<typeof CSS_THEMES>;
+
 /**
  * The default artwork used for Token images if none is provided
  */
@@ -150,11 +261,32 @@ export type COMPENDIUM_DOCUMENT_TYPES = ValueOf<typeof COMPENDIUM_DOCUMENT_TYPES
  * Define the allowed ownership levels for a Document.
  * Each level is assigned a value in ascending order.
  * Higher levels grant more permissions.
+ * @see https://foundryvtt.com/article/users/
  */
 export declare const DOCUMENT_OWNERSHIP_LEVELS: Readonly<{
+  /**
+   * The User inherits permissions from the parent Folder.
+   */
+  INHERIT: -1;
+
+  /**
+   * Restricts the associated Document so that it may not be seen by this User.
+   */
   NONE: 0;
+
+  /**
+   * Allows the User to interact with the Document in basic ways, allowing them to see it in sidebars and see only limited aspects of its contents. The limits of this interaction are defined by the game system being used.
+   */
   LIMITED: 1;
+
+  /**
+   * Allows the User to view this Document as if they were owner, but prevents them from making any changes to it.
+   */
   OBSERVER: 2;
+
+  /**
+   * Allows the User to view and make changes to the Document as its owner. Owned documents cannot be deleted by anyone other than a gamemaster level User.
+   */
   OWNER: 3;
 }>;
 export type DOCUMENT_OWNERSHIP_LEVELS = ValueOf<typeof DOCUMENT_OWNERSHIP_LEVELS>;
@@ -169,7 +301,7 @@ export declare const DOCUMENT_META_OWNERSHIP_LEVELS: Readonly<{
 export type DOCUMENT_META_OWNERSHIP_LEVELS = ValueOf<typeof DOCUMENT_META_OWNERSHIP_LEVELS>;
 
 /**
- * @deprecated since v10
+ * @deprecated since v10, will be removed in v12
  * @see CONST.DOCUMENT_OWNERSHIP_LEVELS
  */
 export declare const DOCUMENT_PERMISSION_LEVELS: typeof DOCUMENT_OWNERSHIP_LEVELS;
@@ -192,24 +324,49 @@ export type DOCUMENT_LINK_TYPES = ValueOf<typeof DOCUMENT_LINK_TYPES>;
 
 /**
  * The supported dice roll visibility modes
+ * @see https://foundryvtt.com/article/dice/
  */
 export declare const DICE_ROLL_MODES: Readonly<{
+  /**
+   * This roll is visible to all players.
+   */
   PUBLIC: "publicroll";
+
+  /**
+   * Rolls of this type are only visible to the player that rolled and any Game Master users.
+   */
   PRIVATE: "gmroll";
+
+  /**
+   * A private dice roll only visible to Game Master users. The rolling player will not see the result of their own roll.
+   */
   BLIND: "blindroll";
+
+  /**
+   * A private dice roll which is only visible to the user who rolled it.
+   */
   SELF: "selfroll";
 }>;
 export type DICE_ROLL_MODES = ValueOf<typeof DICE_ROLL_MODES>;
 
 /**
  * The allowed fill types which a Drawing object may display
- * NONE: The drawing is not filled
- * SOLID: The drawing is filled with a solid color
- * PATTERN: The drawing is filled with a tiled image pattern
+ * @see https://foundryvtt.com/article/drawings/
  */
 export declare const DRAWING_FILL_TYPES: Readonly<{
+  /**
+   * The drawing is not filled
+   */
   NONE: 0;
+
+  /**
+   * The drawing is filled with a solid color
+   */
   SOLID: 1;
+
+  /**
+   * The drawing is filled with a tiled image pattern
+   */
   PATTERN: 2;
 }>;
 export type DRAWING_FILL_TYPES = ValueOf<typeof DRAWING_FILL_TYPES>;
@@ -219,6 +376,7 @@ export type DRAWING_FILL_TYPES = ValueOf<typeof DRAWING_FILL_TYPES>;
  */
 export declare const FOLDER_DOCUMENT_TYPES: readonly [
   "Actor",
+  "Adventure",
   "Item",
   "Scene",
   "JournalEntry",
@@ -226,13 +384,14 @@ export declare const FOLDER_DOCUMENT_TYPES: readonly [
   "RollTable",
   "Cards",
   "Macro",
+  "Compendium",
 ];
 export type FOLDER_DOCUMENT_TYPES = ValueOf<typeof FOLDER_DOCUMENT_TYPES>;
 
 /**
  * The maximum allowed level of depth for Folder nesting
  */
-export declare const FOLDER_MAX_DEPTH: 3;
+export declare const FOLDER_MAX_DEPTH: 4;
 
 /**
  * A list of allowed game URL names
@@ -246,13 +405,37 @@ export declare const GRID_MIN_SIZE: 50;
 
 /**
  * The allowed Grid types which are supported by the software
+ * @see https://foundryvtt.com/article/scenes/
  */
 export declare const GRID_TYPES: Readonly<{
+  /**
+   * No fixed grid is used on this Scene allowing free-form point-to-point measurement without grid lines.
+   */
   GRIDLESS: 0;
+
+  /**
+   * A square grid is used with width and height of each grid space equal to the chosen grid size.
+   */
   SQUARE: 1;
+
+  /**
+   * A column-wise hexagon grid (flat-topped) where odd-numbered rows are offset.
+   */
   HEXODDR: 2;
+
+  /**
+   * A column-wise hexagon grid (flat-topped) where even-numbered rows are offset.
+   */
   HEXEVENR: 3;
+
+  /**
+   * A row-wise hexagon grid (pointy-topped) where odd-numbered columns are offset.
+   */
   HEXODDQ: 4;
+
+  /**
+   * A row-wise hexagon grid (pointy-topped) where even-numbered columns are offset.
+   */
   HEXEVENQ: 5;
 }>;
 export type GRID_TYPES = ValueOf<typeof GRID_TYPES>;
@@ -260,7 +443,7 @@ export type GRID_TYPES = ValueOf<typeof GRID_TYPES>;
 /**
  * A list of supported setup URL names
  */
-export declare const SETUP_VIEWS: readonly ["license", "setup", "players", "join", "auth"];
+export declare const SETUP_VIEWS: readonly ["auth", "license", "setup", "players", "join", "update"];
 
 /**
  * An Array of valid MacroAction scope values
@@ -270,39 +453,76 @@ export type MACRO_SCOPES = ValueOf<typeof MACRO_SCOPES>;
 
 /**
  * An enumeration of valid Macro types
+ * @see https://foundryvtt.com/article/macros/
  */
 export declare const MACRO_TYPES: Readonly<{
+  /**
+   * Complex and powerful macros which leverage the FVTT API through plain JavaScript to perform functions as simple or as advanced as you can imagine.
+   */
   SCRIPT: "script";
+
+  /**
+   * Simple and easy to use, chat macros post pre-defined chat messages to the chat log when executed. All users can execute chat macros by default.
+   */
   CHAT: "chat";
 }>;
 export type MACRO_TYPES = ValueOf<typeof MACRO_TYPES>;
 
 /**
  * The allowed playback modes for an audio Playlist
- * DISABLED: The playlist does not play on its own, only individual Sound tracks played as a soundboard
- * SEQUENTIAL: The playlist plays sounds one at a time in sequence
- * SHUFFLE: The playlist plays sounds one at a time in randomized order
- * SIMULTANEOUS: The playlist plays all contained sounds at the same time
+ * @see https://foundryvtt.com/article/playlists/
  */
 export declare const PLAYLIST_MODES: Readonly<{
+  /**
+   * The playlist does not play on its own, only individual Sound tracks played as a soundboard.
+   */
   DISABLED: -1;
+
+  /**
+   * The playlist plays sounds one at a time in sequence.
+   */
   SEQUENTIAL: 0;
+
+  /**
+   * The playlist plays sounds one at a time in randomized order.
+   */
   SHUFFLE: 1;
+
+  /**
+   * The playlist plays all contained sounds at the same time.
+   */
   SIMULTANEOUS: 2;
 }>;
 export type PLAYLIST_MODES = ValueOf<typeof PLAYLIST_MODES>;
 
 /**
  * The available sort modes for an audio Playlist.
- * ALPHABETICAL (default): Sort sounds alphabetically.
- * MANUAL: Sort sounds by manual drag-and-drop.
+ * @defaultValue `"a"`
+ * @see https://foundryvtt.com/article/playlists/
  */
 export declare const PLAYLIST_SORT_MODES: Readonly<{
+  /**
+   * Sort sounds alphabetically.
+   * @defaultValue
+   */
   ALPHABETICAL: "a";
+
+  /**
+   * Sort sounds by manual drag-and-drop.
+   */
   MANUAL: "m";
 }>;
 export type PLAYLIST_SORT_MODES = ValueOf<typeof PLAYLIST_SORT_MODES>;
 
+/**
+ * The available modes for searching within a DirectoryCollection
+ */
+export declare const DIRECTORY_SEARCH_MODES: Readonly<{
+  FULL: "full";
+  NAME: "name";
+}>;
+export type DIRECTORY_SEARCH_MODES = ValueOf<typeof DIRECTORY_SEARCH_MODES>;
+
 /**
  * The allowed package types
  */
@@ -313,13 +533,60 @@ export type PACKAGE_TYPES = ValueOf<typeof PACKAGE_TYPES>;
  * Encode the reasons why a package may be available or unavailable for use
  */
 export declare const PACKAGE_AVAILABILITY_CODES: Readonly<{
-  UNKNOWN: -1;
-  REQUIRES_UPDATE: 0;
-  AVAILABLE: 1;
-  REQUIRES_SYSTEM: 2;
-  REQUIRES_DEPENDENCY: 3;
-  REQUIRES_CORE_UPGRADE: 4;
-  REQUIRES_CORE_DOWNGRADE: 5;
+  /**
+   * Package availability could not be determined
+   */
+  UNKNOWN: 0;
+
+  /**
+   * The Package is verified to be compatible with the current core software build
+   */
+  VERIFIED: 1;
+
+  /**
+   * Package is available for use, but not verified for the current core software build
+   */
+  UNVERIFIED_BUILD: 2;
+
+  /**
+   * One or more installed system is incompatible with the Package.
+   */
+  UNVERIFIED_SYSTEM: 3;
+
+  /**
+   * Package is available for use, but not verified for the current core software generation
+   */
+  UNVERIFIED_GENERATION: 4;
+
+  /**
+   * The System that the Package relies on is not available
+   */
+  MISSING_SYSTEM: 5;
+
+  /**
+   * A dependency of the Package is not available
+   */
+  MISSING_DEPENDENCY: 6;
+
+  /**
+   * The Package is compatible with an older version of Foundry than the currently installed version
+   */
+  REQUIRES_CORE_DOWNGRADE: 7;
+
+  /**
+   * The Package is compatible with a newer version of Foundry than the currently installed version, and that version is Stable
+   */
+  REQUIRES_CORE_UPGRADE_STABLE: 8;
+
+  /**
+   * The Package is compatible with a newer version of Foundry than the currently installed version, and that version is not yet Stable
+   */
+  REQUIRES_CORE_UPGRADE_UNSTABLE: 9;
+
+  /**
+   * A required dependency is not compatible with the current version of Foundry
+   */
+  REQUIRES_DEPENDENCY_UPDATE: 10;
 }>;
 export type PACKAGE_AVAILABILITY_CODES = ValueOf<typeof PACKAGE_AVAILABILITY_CODES>;
 
@@ -332,9 +599,24 @@ export declare const PASSWORD_SAFE_STRING: "••••••••••••
  * The allowed software update channels
  */
 export declare const SOFTWARE_UPDATE_CHANNELS: Readonly<{
+  /**
+   * The Stable release channel
+   */
   stable: "SETUP.UpdateStable";
+
+  /**
+   * The User Testing release channel
+   */
   testing: "SETUP.UpdateTesting";
+
+  /**
+   * The Development release channel
+   */
   development: "SETUP.UpdateDevelopment";
+
+  /**
+   * The Prototype release channel
+   */
   prototype: "SETUP.UpdatePrototype";
 }>;
 export type SOFTWARE_UPDATE_CHANNELS = ValueOf<typeof SOFTWARE_UPDATE_CHANNELS>;
@@ -346,30 +628,71 @@ export declare const SORT_INTEGER_DENSITY: 100000;
 
 /**
  * The allowed types of a TableResult document
+ * @see https://foundryvtt.com/article/roll-tables/
  */
 export declare const TABLE_RESULT_TYPES: Readonly<{
+  /**
+   *  Plain text or HTML scripted entries which will be output to Chat.
+   */
   TEXT: 0;
+
+  /**
+   * An in-World Document reference which will be linked to in the chat message.
+   */
   DOCUMENT: 1;
+
+  /**
+   * A Compendium Pack reference which will be linked to in the chat message.
+   */
   COMPENDIUM: 2;
 }>;
 export type TABLE_RESULT_TYPES = ValueOf<typeof TABLE_RESULT_TYPES>;
 
 /**
  * The allowed formats of a Journal Entry Page.
+ * @see https://foundryvtt.com/article/journal/
  */
 export declare const JOURNAL_ENTRY_PAGE_FORMATS: Readonly<{
+  /**
+   * The page is formatted as HTML.
+   */
   HTML: 1;
+
+  /**
+   * The page is formatted as Markdown.
+   */
   MARKDOWN: 2;
 }>;
+export type JOURNAL_ENTRY_PAGE_FORMATS = ValueOf<typeof JOURNAL_ENTRY_PAGE_FORMATS>;
 
 /**
  * Define the valid anchor locations for a Tooltip displayed on a Placeable Object
+ * @see TooltipManager
  */
 export declare const TEXT_ANCHOR_POINTS: Readonly<{
+  /**
+   * Anchor the tooltip to the center of the element.
+   */
   CENTER: 0;
+
+  /**
+   * Anchor the tooltip to the bottom of the element.
+   */
   BOTTOM: 1;
+
+  /**
+   * Anchor the tooltip to the top of the element.
+   */
   TOP: 2;
+
+  /**
+   * Anchor the tooltip to the left of the element.
+   */
   LEFT: 3;
+
+  /**
+   * Anchor the tooltip to the right of the element.
+   */
   RIGHT: 4;
 }>;
 export type TEXT_ANCHOR_POINTS = ValueOf<typeof TEXT_ANCHOR_POINTS>;
@@ -414,32 +737,64 @@ export type TILE_OCCLUSION_MODES = ValueOf<typeof TILE_OCCLUSION_MODES>;
 
 /**
  * Describe the various thresholds of token control upon which to show certain pieces of information
- * NONE - no information is displayed
- * CONTROL - displayed when the token is controlled
- * OWNER HOVER - displayed when hovered by a GM or a user who owns the actor
- * HOVER - displayed when hovered by any user
- * OWNER - always displayed for a GM or for a user who owns the actor
- * ALWAYS - always displayed for everyone
+ * @see https://foundryvtt.com/article/tokens/
  */
 export declare const TOKEN_DISPLAY_MODES: Readonly<{
+  /**
+   * No information is displayed.
+   */
   NONE: 0;
+
+  /**
+   * Displayed when the token is controlled.
+   */
   CONTROL: 10;
+
+  /**
+   * Displayed when hovered by a GM or a user who owns the actor.
+   */
   OWNER_HOVER: 20;
+
+  /**
+   * Displayed when hovered by any user.
+   */
   HOVER: 30;
+
+  /**
+   * Always displayed for a GM or for a user who owns the actor.
+   */
   OWNER: 40;
+
+  /**
+   * Always displayed for everyone.
+   */
   ALWAYS: 50;
 }>;
 export type TOKEN_DISPLAY_MODES = ValueOf<typeof TOKEN_DISPLAY_MODES>;
 
 /**
  * The allowed Token disposition types
- * HOSTILE - Displayed as an enemy with a red border
- * NEUTRAL - Displayed as neutral with a yellow border
- * FRIENDLY - Displayed as an ally with a cyan border
+ * @see https://foundryvtt.com/article/tokens/
  */
 export declare const TOKEN_DISPOSITIONS: Readonly<{
+  /**
+   * Displayed with a purple borders for owners and with no borders for others (and no pointer change).
+   */
+  SECRET: -2;
+
+  /**
+   * Displayed as an enemy with a red border.
+   */
   HOSTILE: -1;
+
+  /**
+   * Displayed as neutral with a yellow border.
+   */
   NEUTRAL: 0;
+
+  /**
+   * Displayed as an ally with a cyan border.
+   */
   FRIENDLY: 1;
 }>;
 export type TOKEN_DISPOSITIONS = ValueOf<typeof TOKEN_DISPOSITIONS>;
@@ -447,12 +802,35 @@ export type TOKEN_DISPOSITIONS = ValueOf<typeof TOKEN_DISPOSITIONS>;
 /**
  * Define the allowed User permission levels.
  * Each level is assigned a value in ascending order. Higher levels grant more permissions.
+ * @see https://foundryvtt.com/article/users/
  */
 export declare const USER_ROLES: Readonly<{
+  /**
+   * The User is blocked from taking actions in Foundry Virtual Tabletop.
+   * You can use this role to temporarily or permanently ban a user from joining the game.
+   */
   NONE: 0;
+
+  /**
+   * The User is able to join the game with permissions available to a standard player.
+   * They cannot take some more advanced actions which require Trusted permissions, but they have the basic functionalities needed to operate in the virtual tabletop.
+   */
   PLAYER: 1;
+
+  /**
+   * Similar to the Player role, except a Trusted User has the ability to perform some more advanced actions like create drawings, measured templates, or even to (optionally) upload media files to the server.
+   */
   TRUSTED: 2;
+
+  /**
+   * A special User who has many of the same in-game controls as a Game Master User, but does not have the ability to perform administrative actions like changing User roles or modifying World-level settings.
+   */
   ASSISTANT: 3;
+
+  /**
+   *  A special User who has administrative control over this specific World.
+   *  Game Masters behave quite differently than Players in that they have the ability to see all Documents and Objects within the world as well as the capability to configure World settings.
+   */
   GAMEMASTER: 4;
 }>;
 export type USER_ROLES = ValueOf<typeof USER_ROLES>;
@@ -465,11 +843,27 @@ export type USER_ROLE_NAMES = ValueOf<typeof USER_ROLE_NAMES>;
 
 /**
  * An enumeration of the allowed types for a MeasuredTemplate embedded document
+ * @see https://foundryvtt.com/article/measurement/
  */
 export declare const MEASURED_TEMPLATE_TYPES: Readonly<{
+  /**
+   * Circular templates create a radius around the starting point.
+   */
   CIRCLE: "circle";
+
+  /**
+   * Cones create an effect in the shape of a triangle or pizza slice from the starting point.
+   */
   CONE: "cone";
+
+  /**
+   * A rectangle uses the origin point as one of the corners, treating the origin as being inside of the rectangle's area.
+   */
   RECTANGLE: "rect";
+
+  /**
+   * A ray creates a single line that is one square in width and as long as you want it to be.
+   */
   RAY: "ray";
 }>;
 export type MEASURED_TEMPLATE_TYPES = ValueOf<typeof MEASURED_TEMPLATE_TYPES>;
@@ -524,6 +918,20 @@ export declare const USER_PERMISSIONS: Readonly<{
    */
   BROADCAST_VIDEO: UserPermission;
 
+  /**
+   * @defaultValue
+   * ```typescript
+   * {
+   *   label: "PERMISSION.CardsCreate",
+   *   hint: "PERMISSION.CardsCreateHint",
+   *   disableGM: false,
+   *   defaultRole: USER_ROLES.ASSISTANT
+   * }
+   * ```
+   */
+
+  CARDS_CREATE: UserPermission;
+
   /**
    * @defaultValue
    * ```typescript
@@ -628,6 +1036,19 @@ export declare const USER_PERMISSIONS: Readonly<{
    */
   NOTE_CREATE: UserPermission;
 
+  /**
+   * @defaultValue
+   * ```typescript
+   * {
+   *   label: "PERMISSION.NoteCreate",
+   *   hint: "PERMISSION.NoteCreateHint",
+   *   disableGM: false,
+   *   defaultRole: USER_ROLES.TRUSTED
+   * }
+   * ```
+   */
+  PING_CANVAS: UserPermission;
+
   /**
    * @defaultValue
    * ```typescript
@@ -693,6 +1114,19 @@ export declare const USER_PERMISSIONS: Readonly<{
    */
   TOKEN_CREATE: UserPermission;
 
+  /**
+   * @defaultValue
+   * ```typescript
+   * {
+   *    label: "PERMISSION.TokenDelete",
+   *    hint: "PERMISSION.TokenDeleteHint",
+   *    disableGM: false,
+   *    defaultRole: USER_ROLES.ASSISTANT
+   * }
+   * ```
+   */
+  TOKEN_DELETE: UserPermission;
+
   /**
    * @defaultValue
    * ```typescript
@@ -722,43 +1156,76 @@ export declare const USER_PERMISSIONS: Readonly<{
 
 /**
  * The allowed directions of effect that a Wall can have
- * BOTH: The wall collides from both directions
- * LEFT: The wall collides only when a ray strikes its left side
- * RIGHT: The wall collides only when a ray strikes its right side
+ * @see https://foundryvtt.com/article/walls/
  */
 export declare const WALL_DIRECTIONS: Readonly<{
+  /**
+   * The wall collides from both directions.
+   */
   BOTH: 0;
+
+  /**
+   * The wall collides only when a ray strikes its left side.
+   */
   LEFT: 1;
+
+  /**
+   * The wall collides only when a ray strikes its right side.
+   */
   RIGHT: 2;
 }>;
 export type WALL_DIRECTIONS = ValueOf<typeof WALL_DIRECTIONS>;
 
 /**
  * The allowed door types which a Wall may contain
- * NONE: The wall does not contain a door
- * DOOR: The wall contains a regular door
- * SECRET: The wall contains a secret door
+ * @see https://foundryvtt.com/article/walls/
  */
 export declare const WALL_DOOR_TYPES: Readonly<{
+  /**
+   * The wall does not contain a door.
+   */
   NONE: 0;
+
+  /**
+   *  The wall contains a regular door.
+   */
   DOOR: 1;
+
+  /**
+   * The wall contains a secret door.
+   */
   SECRET: 2;
 }>;
 export type WALL_DOOR_TYPES = ValueOf<typeof WALL_DOOR_TYPES>;
 
 /**
  * The allowed door states which may describe a Wall that contains a door
- * CLOSED: The door is closed
- * OPEN: The door is open
- * LOCKED: The door is closed and locked
+ * @see https://foundryvtt.com/article/walls/
  */
 export declare const WALL_DOOR_STATES: Readonly<{
+  /**
+   * The door is closed.
+   */
   CLOSED: 0;
+
+  /**
+   * The door is open.
+   */
   OPEN: 1;
+
+  /**
+   * The door is closed and locked.
+   */
   LOCKED: 2;
 }>;
 export type WALL_DOOR_STATES = ValueOf<typeof WALL_DOOR_STATES>;
 
+/**
+ * The possible ways to interact with a door
+ */
+export declare const WALL_DOOR_INTERACTIONS: ["open", "close", "lock", "unlock", "test"];
+export type WALL_DOOR_INTERACTIONS = ValueOf<typeof WALL_DOOR_INTERACTIONS>;
+
 /**
  * The wall properties which restrict the way interaction occurs with a specific wall
  */
@@ -767,37 +1234,71 @@ export type WALL_RESTRICTION_TYPES = ValueOf<typeof WALL_RESTRICTION_TYPES>;
 
 /**
  * The types of sensory collision which a Wall may impose
- * NONE: Senses do not collide with this wall
- * NORMAL: Senses collide with this wall
- * LIMITED: Senses collide with the second intersection, bypassing the first
+ * @see https://foundryvtt.com/article/walls/
  */
 export declare const WALL_SENSE_TYPES: Readonly<{
+  /**
+   * Senses do not collide with this wall.
+   */
   NONE: 0;
+
+  /**
+   * Senses collide with this wall.
+   */
   LIMITED: 10;
+
+  /**
+   * Senses collide with the second intersection, bypassing the first.
+   */
   NORMAL: 20;
+
+  /**
+   * Senses bypass the wall within a certain proximity threshold.
+   */
+  PROXIMITY: 30;
+
+  /**
+   * Senses bypass the wall outside a certain proximity threshold.
+   */
+  DISTANCE: 40;
 }>;
 export type WALL_SENSE_TYPES = ValueOf<typeof WALL_SENSE_TYPES>;
 
 /**
  * The types of movement collision which a Wall may impose
- * NONE: Movement does not collide with this wall
- * NORMAL: Movement collides with this wall
+ * @see https://foundryvtt.com/article/walls/
  */
 export declare const WALL_MOVEMENT_TYPES: Readonly<{
+  /**
+   * Movement does not collide with this wall.
+   */
   NONE: typeof WALL_SENSE_TYPES.NONE;
+
+  /**
+   * Movement collides with this wall.
+   */
   NORMAL: typeof WALL_SENSE_TYPES.NORMAL;
 }>;
 export type WALL_MOVEMENT_TYPES = ValueOf<typeof WALL_MOVEMENT_TYPES>;
 
 /**
  * The possible precedence values a Keybinding might run in
- * PRIORITY: Runs in the first group along with other PRIORITY keybindings
- * NORMAL: Runs after the PRIORITY group along with other NORMAL keybindings
- * DEFERRED: Runs in the last group along with other DEFERRED keybindings
+ * @see https://foundryvtt.com/article/keybinds/
  */
 export declare const KEYBINDING_PRECEDENCE: Readonly<{
+  /**
+   * Runs in the first group along with other PRIORITY keybindings.
+   */
   PRIORITY: 0;
+
+  /**
+   * Runs after the PRIORITY group along with other NORMAL keybindings.
+   */
   NORMAL: 1;
+
+  /**
+   * Runs in the last group along with other DEFERRED keybindings.
+   */
   DEFERRED: 2;
 }>;
 export type KEYBINDING_PRECEDENCE = ValueOf<typeof KEYBINDING_PRECEDENCE>;
@@ -806,6 +1307,7 @@ export type KEYBINDING_PRECEDENCE = ValueOf<typeof KEYBINDING_PRECEDENCE>;
  * The allowed set of HTML template extensions
  */
 export declare const HTML_FILE_EXTENSIONS: readonly ["html", "handlebars", "hbs"];
+export declare type HTML_FILE_EXTENSIONS = ValueOf<typeof HTML_FILE_EXTENSIONS>;
 
 interface _IMAGE_FILE_EXTENSIONS {
   apng: "image/apng";
@@ -909,25 +1411,27 @@ interface _UPLOADABLE_FILE_EXTENSIONS
     _GRAPHICS_FILE_EXTENSIONS {}
 
 export declare const UPLOADABLE_FILE_EXTENSIONS: _UPLOADABLE_FILE_EXTENSIONS;
+export type UPLOADABLE_FILE_EXTENSIONS = ValueOf<_UPLOADABLE_FILE_EXTENSIONS>;
 
 /**
  * A list of MIME types which are treated as uploaded "media", which are allowed to overwrite existing files.
  * Any non-media MIME type is not allowed to replace an existing file.
  */
 export declare const MEDIA_MIME_TYPES: ValueOf<_UPLOADABLE_FILE_EXTENSIONS>;
+export type MEDIA_MIME_TYPES = typeof MEDIA_MIME_TYPES;
 
 /**
  * An enumeration of file type categories which can be selected
  */
 export declare const FILE_CATEGORIES: {
-  HTML: typeof HTML_FILE_EXTENSIONS;
+  HTML: HTML_FILE_EXTENSIONS;
   IMAGE: _IMAGE_FILE_EXTENSIONS;
   VIDEO: _VIDEO_FILE_EXTENSIONS;
   AUDIO: _AUDIO_FILE_EXTENSIONS;
   TEXT: _TEXT_FILE_EXTENSIONS;
   FONT: _FONT_FILE_EXTENSIONS;
   GRAPHICS: _GRAPHICS_FILE_EXTENSIONS;
-  MEDIA: typeof MEDIA_MIME_TYPES;
+  MEDIA: MEDIA_MIME_TYPES;
 };
 
 /**
@@ -944,21 +1448,163 @@ export declare const FONT_WEIGHTS: {
   ExtraBold: 800;
   Black: 900;
 };
+export type FONT_WEIGHTS = ValueOf<typeof FONT_WEIGHTS>;
 
 /**
  * Stores shared commonly used timeouts, measured in MS
  */
 export declare const TIMEOUTS: Readonly<{
+  /**
+   * The default timeout for interacting with the foundryvtt.com API.
+   */
   FOUNDRY_WEBSITE: 10000;
+
+  /**
+   * The specific timeout for loading the list of packages from the foundryvtt.com API.
+   */
   PACKAGE_REPOSITORY: 5000;
+
+  /**
+   * The specific timeout for the IP address lookup service.
+   */
   IP_DISCOVERY: 5000;
 }>;
 export type TIMEOUTS = ValueOf<typeof TIMEOUTS>;
 
 /**
- * @deprecated since v10.
- * TODO: make a real link
- * @see data.ShapeData.TYPES
+ * A subset of Compendium types which require a specific system to be designated
+ */
+export declare const SYSTEM_SPECIFIC_COMPENDIUM_TYPES: readonly ["Actor", "Item"];
+export type SYSTEM_SPECIFIC_COMPENDIUM_TYPES = ValueOf<typeof SYSTEM_SPECIFIC_COMPENDIUM_TYPES>;
+
+/**
+ * The configured showdown bi-directional HTML \<-\> Markdown converter options.
+ */
+export declare const SHOWDOWN_OPTIONS: Readonly<{
+  disableForced4SpacesIndentedSublists: true;
+  noHeaderId: true;
+  parseImgDimensions: true;
+  strikethrough: true;
+  tables: true;
+  tablesHeaderId: true;
+}>;
+export type SHOWDOWN_OPTIONS = ValueOf<typeof SHOWDOWN_OPTIONS>;
+
+/**
+ * The list of allowed attributes in HTML elements.
+ */
+export const ALLOWED_HTML_ATTRIBUTES: Readonly<{
+  "*": ["class", "data-*", "id", "title", "style", "draggable", "aria-*", "tabindex", "dir"];
+  a: ["href", "name", "target", "rel"];
+  area: ["alt", "coords", "href", "rel", "shape", "target"];
+  audio: ["controls", "loop", "muted", "src", "autoplay"];
+  blockquote: ["cite"];
+  button: ["disabled", "name", "type", "value"];
+  col: ["span"];
+  colgroup: ["span"];
+  details: ["open"];
+  fieldset: ["disabled"];
+  form: ["name"];
+  iframe: ["src", "srcdoc", "name", "height", "width", "loading", "sandbox"];
+  img: ["height", "src", "width", "usemap", "sizes", "srcset", "alt"];
+  input: [
+    "checked",
+    "disabled",
+    "name",
+    "value",
+    "placeholder",
+    "type",
+    "alt",
+    "height",
+    "list",
+    "max",
+    "min",
+    "placeholder",
+    "readonly",
+    "size",
+    "src",
+    "step",
+    "width",
+  ];
+  label: ["for"];
+  li: ["value"];
+  map: ["name"];
+  meter: ["value", "min", "max", "low", "high", "optimum"];
+  ol: ["reversed", "start", "type"];
+  optgroup: ["disabled", "label"];
+  option: ["disabled", "selected", "label", "value"];
+  progress: ["max", "value"];
+  select: ["name", "disabled", "multiple", "size"];
+  source: ["media", "sizes", "src", "srcset", "type"];
+  table: ["border"];
+  td: ["colspan", "headers", "rowspan"];
+  textarea: ["rows", "cols", "disabled", "name", "readonly", "wrap"];
+  time: ["datetime"];
+  th: ["abbr", "colspan", "headers", "rowspan", "scope", "sorted"];
+  track: ["default", "kind", "label", "src", "srclang"];
+  video: ["controls", "height", "width", "loop", "muted", "poster", "src", "autoplay"];
+}>;
+export type ALLOWED_HTML_ATTRIBUTES = ValueOf<typeof ALLOWED_HTML_ATTRIBUTES>;
+
+/**
+ * The list of trusted iframe domains.
+ */
+export declare const TRUSTED_IFRAME_DOMAINS: ["google.com", "youtube.com"];
+export type TRUSTED_IFRAME_DOMAINS = ValueOf<typeof TRUSTED_IFRAME_DOMAINS>;
+
+/**
+ * Available themes for the world join page.
+ */
+export const WORLD_JOIN_THEMES: Readonly<{
+  default: "WORLD.JoinThemeDefault";
+  minimal: "WORLD.JoinThemeMinimal";
+}>;
+export type WORLD_JOIN_THEMES = ValueOf<typeof WORLD_JOIN_THEMES>;
+
+/**
+ * Setup page package progress protocol.
+ */
+export declare const SETUP_PACKAGE_PROGRESS: Readonly<{
+  ACTIONS: {
+    CREATE_BACKUP: "createBackup";
+    RESTORE_BACKUP: "restoreBackup";
+    DELETE_BACKUP: "deleteBackup";
+    CREATE_SNAPSHOT: "createSnapshot";
+    RESTORE_SNAPSHOT: "restoreSnapshot";
+    DELETE_SNAPSHOT: "deleteSnapshot";
+    INSTALL_PKG: "installPackage";
+    LAUNCH_WORLD: "launchWorld";
+    UPDATE_CORE: "updateCore";
+  };
+
+  STEPS: {
+    ARCHIVE: "archive";
+    CHECK_DISK_SPACE: "checkDiskSpace";
+    CONNECT_WORLD: "connectWorld";
+    CONNECT_PKG: "connectPackage";
+    MIGRATE_CORE: "migrateCore";
+    MIGRATE_SYSTEM: "migrateSystem";
+    DOWNLOAD: "download";
+    EXTRACT: "extract";
+    INSTALL: "install";
+    CLEANUP: "cleanup";
+    COMPLETE: "complete";
+    DELETE: "delete";
+    ERROR: "error";
+    VEND: "vend";
+    SNAPSHOT_MODULES: "snapshotModules";
+    SNAPSHOT_SYSTEMS: "snapshotSystems";
+    SNAPSHOT_WORLDS: "snapshotWorlds";
+  };
+}>;
+export namespace SETUP_PACKAGE_PROGRESS {
+  export type ACTIONS = ValueOf<typeof SETUP_PACKAGE_PROGRESS.ACTIONS>;
+  export type STEPS = ValueOf<typeof SETUP_PACKAGE_PROGRESS.STEPS>;
+}
+
+/**
+ * @deprecated since v10, will be removed in v12
+ * @see data.ShapeData.TYPES // TODO: make a real link
  */
 export declare const DRAWING_TYPES: Readonly<{
   RECTANGLE: "r";
@@ -968,6 +1614,12 @@ export declare const DRAWING_TYPES: Readonly<{
   FREEHAND: "f";
 }>;
 /**
- * @deprecated since v10.
+ * @deprecated since v10, will be removed in v12
  */
 export type DRAWING_TYPES = ValueOf<typeof DRAWING_TYPES>;
+
+/**
+ * The combat announcements.
+ */
+export declare const COMBAT_ANNOUNCEMENTS: readonly ["startEncounter", "nextUp", "yourTurn"];
+export type COMBAT_ANNOUNCEMENTS = ValueOf<typeof COMBAT_ANNOUNCEMENTS>;
diff --git a/src/foundry/common/data/data.mjs/folderData.d.mts b/src/foundry/common/data/data.mjs/folderData.d.mts
index 4e0ee1079..dba512841 100644
--- a/src/foundry/common/data/data.mjs/folderData.d.mts
+++ b/src/foundry/common/data/data.mjs/folderData.d.mts
@@ -42,7 +42,7 @@ export interface FolderDataProperties {
   /**
    * The document type which this Folder contains, from CONST.FOLDER_DOCUMENT_TYPES
    */
-  type: foundry.CONST.FOLDER_DOCUMENT_TYPES;
+  type: Exclude<foundry.CONST.FOLDER_DOCUMENT_TYPES, "Compendium">;
 
   /**
    * An HTML description of the contents of this folder
diff --git a/src/foundry/common/data/data.mjs/tokenData.d.mts b/src/foundry/common/data/data.mjs/tokenData.d.mts
index 7b0c1b851..5f206a06f 100644
--- a/src/foundry/common/data/data.mjs/tokenData.d.mts
+++ b/src/foundry/common/data/data.mjs/tokenData.d.mts
@@ -80,12 +80,14 @@ export interface TokenDataSchema extends DocumentSchema {
   bar1: DocumentField<TokenBarData> & {
     type: typeof TokenBarData;
     required: true;
-    default: () => { attribute: Game["system"]["data"]["primaryTokenAttribute"] | null };
+    // TODO: Fix after Data Model
+    // default: () => { attribute: Game["system"]["data"]["primaryTokenAttribute"] | null };
   };
   bar2: DocumentField<TokenBarData> & {
     type: typeof TokenBarData;
     required: true;
-    default: () => { attribute: Game["system"]["data"]["secondaryTokenAttribute"] | null };
+    // TODO: Fix after Data Model
+    // default: () => { attribute: Game["system"]["data"]["secondaryTokenAttribute"] | null };
   };
   flags: fields.ObjectField;
 }
diff --git a/src/foundry/common/documents.mjs/baseFolder.d.mts b/src/foundry/common/documents.mjs/baseFolder.d.mts
index a7541ba34..bef3431f8 100644
--- a/src/foundry/common/documents.mjs/baseFolder.d.mts
+++ b/src/foundry/common/documents.mjs/baseFolder.d.mts
@@ -27,5 +27,5 @@ export declare class BaseFolder extends Document<data.FolderData, BaseFolder, Fo
   /**
    * The type of Document contained within this Folder.
    */
-  get type(): CONST.FOLDER_DOCUMENT_TYPES;
+  get type(): Exclude<CONST.FOLDER_DOCUMENT_TYPES, "Compendium">;
 }


Test patch:
diff --git a/tests/foundry/client/config.test-d.ts b/tests/foundry/client/config.test-d.ts
new file mode 100644
index 000000000..b5afe90f4
--- /dev/null
+++ b/tests/foundry/client/config.test-d.ts
@@ -0,0 +1,7 @@
+class D20Roll extends Roll {}
+
+CONFIG.Dice.D20Roll = D20Roll;
+
+const d20roll = new CONFIG.Dice.D20Roll("1d20");
+
+d20roll.evaluate();
diff --git a/tests/foundry/common/constants.mjs.test-d.ts b/tests/foundry/common/constants.mjs.test-d.ts
new file mode 100644
index 000000000..8cfd768b6
--- /dev/null
+++ b/tests/foundry/common/constants.mjs.test-d.ts
@@ -0,0 +1,51 @@
+import { expectTypeOf } from "vitest";
+import type { ValueOf } from "../../../src/types/utils.d.mts";
+
+expectTypeOf<foundry.CONST.ACTIVE_EFFECT_MODES>().toMatchTypeOf<number>();
+expectTypeOf<foundry.CONST.CARD_DRAW_MODES>().toMatchTypeOf<number>();
+expectTypeOf<foundry.CONST.CANVAS_PERFORMANCE_MODES>().toMatchTypeOf<number>();
+expectTypeOf<foundry.CONST.COMPATIBILITY_MODES>().toMatchTypeOf<number>();
+expectTypeOf<foundry.CONST.CSS_THEMES>().toMatchTypeOf<string>();
+expectTypeOf<foundry.CONST.DOCUMENT_OWNERSHIP_LEVELS>().toMatchTypeOf<number>();
+expectTypeOf<foundry.CONST.DOCUMENT_META_OWNERSHIP_LEVELS>().toMatchTypeOf<number>();
+expectTypeOf<foundry.CONST.DICE_ROLL_MODES>().toMatchTypeOf<string>();
+expectTypeOf<foundry.CONST.DRAWING_FILL_TYPES>().toMatchTypeOf<number>();
+expectTypeOf<foundry.CONST.GRID_TYPES>().toMatchTypeOf<number>();
+expectTypeOf<foundry.CONST.MACRO_TYPES>().toMatchTypeOf<string>();
+expectTypeOf<foundry.CONST.PLAYLIST_MODES>().toMatchTypeOf<number>();
+expectTypeOf<foundry.CONST.PLAYLIST_SORT_MODES>().toMatchTypeOf<string>();
+expectTypeOf<foundry.CONST.DIRECTORY_SEARCH_MODES>().toMatchTypeOf<string>();
+expectTypeOf<foundry.CONST.PACKAGE_AVAILABILITY_CODES>().toMatchTypeOf<number>();
+expectTypeOf<foundry.CONST.SOFTWARE_UPDATE_CHANNELS>().toMatchTypeOf<string>();
+expectTypeOf<foundry.CONST.TABLE_RESULT_TYPES>().toMatchTypeOf<number>();
+expectTypeOf<foundry.CONST.JOURNAL_ENTRY_PAGE_FORMATS>().toMatchTypeOf<number>();
+expectTypeOf<foundry.CONST.TEXT_ANCHOR_POINTS>().toMatchTypeOf<number>();
+expectTypeOf<foundry.CONST.OCCLUSION_MODES>().toMatchTypeOf<number>();
+expectTypeOf<foundry.CONST.TILE_OCCLUSION_MODES>().toMatchTypeOf<foundry.CONST.OCCLUSION_MODES>();
+expectTypeOf<foundry.CONST.TOKEN_DISPLAY_MODES>().toMatchTypeOf<number>();
+expectTypeOf<foundry.CONST.TOKEN_DISPOSITIONS>().toMatchTypeOf<number>();
+expectTypeOf<foundry.CONST.USER_ROLES>().toMatchTypeOf<number>();
+expectTypeOf<foundry.CONST.USER_ROLE_NAMES>().toMatchTypeOf<string>();
+expectTypeOf<foundry.CONST.MEASURED_TEMPLATE_TYPES>().toMatchTypeOf<string>();
+expectTypeOf<ValueOf<typeof foundry.CONST.USER_PERMISSIONS>>().toEqualTypeOf<foundry.CONST.UserPermission>;
+expectTypeOf<foundry.CONST.WALL_DIRECTIONS>().toMatchTypeOf<number>();
+expectTypeOf<foundry.CONST.WALL_DOOR_TYPES>().toMatchTypeOf<number>();
+expectTypeOf<foundry.CONST.WALL_DOOR_STATES>().toMatchTypeOf<number>();
+expectTypeOf<foundry.CONST.WALL_SENSE_TYPES>().toMatchTypeOf<number>();
+expectTypeOf<foundry.CONST.WALL_MOVEMENT_TYPES>().toMatchTypeOf<number>();
+expectTypeOf<foundry.CONST.KEYBINDING_PRECEDENCE>().toMatchTypeOf<number>();
+expectTypeOf<foundry.CONST.IMAGE_FILE_EXTENSIONS>().toMatchTypeOf<string>();
+expectTypeOf<foundry.CONST.VIDEO_FILE_EXTENSIONS>().toMatchTypeOf<string>();
+expectTypeOf<foundry.CONST.AUDIO_FILE_EXTENSIONS>().toMatchTypeOf<string>();
+expectTypeOf<foundry.CONST.TEXT_FILE_EXTENSIONS>().toMatchTypeOf<string>();
+expectTypeOf<foundry.CONST.FONT_FILE_EXTENSIONS>().toMatchTypeOf<string>();
+expectTypeOf<foundry.CONST.GRAPHICS_FILE_EXTENSIONS>().toMatchTypeOf<string>();
+expectTypeOf<foundry.CONST.UPLOADABLE_FILE_EXTENSIONS>().toMatchTypeOf<string>();
+expectTypeOf<foundry.CONST.MEDIA_MIME_TYPES>().toMatchTypeOf<string>();
+expectTypeOf<foundry.CONST.GRAPHICS_FILE_EXTENSIONS>().toMatchTypeOf<string>();
+expectTypeOf<foundry.CONST.FONT_WEIGHTS>().toMatchTypeOf<number>();
+expectTypeOf<foundry.CONST.TIMEOUTS>().toMatchTypeOf<number>();
+expectTypeOf<foundry.CONST.ALLOWED_HTML_ATTRIBUTES>().toMatchTypeOf<string[]>();
+
+expectTypeOf<foundry.CONST.SETUP_PACKAGE_PROGRESS.ACTIONS>().toMatchTypeOf<string>();
+expectTypeOf<foundry.CONST.SETUP_PACKAGE_PROGRESS.STEPS>().toMatchTypeOf<string>();