@league-of-foundry-developers/foundry-vtt-types 12.331.3-beta → 12.331.4-beta

package/src/foundry/client-esm/canvas/sources/rendered-effect-source.d.mts

@@ -1,20 +1,20 @@
-import type { AnyFunction, InexactPartial } from "../../../../types/utils.d.mts";
+import type { AnyObject, Identity, InexactPartial, IntentionalPartial, NullishProps } from "fvtt-types/utils";
 import type BaseEffectSource from "./base-effect-source.d.mts";
-
-// TODO: Remove after shaders are done
-type AdaptiveDarknessShader = unknown;
+import type BaseLightSource from "./base-light-source.d.mts";
 
 /**
  * An abstract class which extends the base PointSource to provide common functionality for rendering.
  * This class is extended by both the LightSource and VisionSource subclasses.
  */
-declare class RenderedEffectSource<
-  SourceData extends RenderedEffectSource.RenderedEffectSourceData = RenderedEffectSource.RenderedEffectSourceData,
+declare abstract class RenderedEffectSource<
+  SourceData extends RenderedEffectSource.SourceData = RenderedEffectSource.SourceData,
   SourceShape extends PIXI.Polygon = PIXI.Polygon,
-  RenderingLayers extends Record<string, RenderedEffectSource.RenderedEffectSourceLayer> = RenderedEffectSource.Layers,
+  RenderingLayers extends Record<string, RenderedEffectSource.SourceLayer> = RenderedEffectSource.Layers,
 > extends BaseEffectSource<SourceData, SourceShape> {
   /**
    * Keys of the data object which require shaders to be re-initialized.
+   * @privateRemarks Presumably, allowing this to contain `"animation.type"` in `BaseLightSource` is why
+   * `#_configure` is passed flattened data
    */
   protected static _initializeShaderKeys: string[];
 
@@ -27,7 +27,7 @@ declare class RenderedEffectSource<
    * Layers handled by this rendered source.
    * @remarks Keys should match the keys of RenderingLayers
    */
-  protected static get _layers(): Record<string, RenderedEffectSource.RenderedEffectLayerConfig>;
+  protected static get _layers(): Record<string, RenderedEffectSource.LayerConfig>;
 
   /**
    * The offset in pixels applied to create soft edges.
@@ -39,21 +39,21 @@ declare class RenderedEffectSource<
    * @defaultValue
    * ```js
    * {
-   * ...super.defaultData,
-   * animation: {},
-   * seed: null,
-   * preview: false,
-   * color: null
+   *   ...super.defaultData,
+   *   animation: {},
+   *   seed: null,
+   *   preview: false,
+   *   color: null
    * }
    * ```
    */
-  static defaultData: RenderedEffectSource.RenderedEffectSourceData;
+  static defaultData: RenderedEffectSource.SourceData;
 
   /**
    * The animation configuration applied to this source
    * @defaultValue `{}`
    */
-  animation: RenderedEffectSource.RenderedEffectSourceAnimationConfig;
+  animation: RenderedEffectSource.StoredAnimationConfig;
 
   /**
    * Track the status of rendering layers
@@ -63,7 +63,7 @@ declare class RenderedEffectSource<
   /**
    * The color of the source as an RGB vector.
    */
-  colorRGB: [number, number, number] | null;
+  colorRGB: Color.RGBColorVector | null;
 
   /**
    * PIXI Geometry generated to draw meshes.
@@ -100,29 +100,27 @@ declare class RenderedEffectSource<
    */
   get illumination(): PointSourceMesh;
 
-  _initialize(data: Partial<SourceData>): void;
+  protected override _initialize(data: IntentionalPartial<SourceData>): void;
 
   /**
    * Decide whether to render soft edges with a blur.
    */
   protected _initializeSoftEdges(): void;
 
-  override _configure(changes: Partial<SourceData>): void;
+  // TODO: Flatten<IntentionalPartial<SourceData>>
+  protected override _configure(changes: AnyObject): void;
 
   /**
    * Configure which shaders are used for each rendered layer.
    * @privateRemarks Foundry marks this as private then overrides it in `PointVisionSource`
    */
-  protected _configureShaders(): {
-    background: AdaptiveLightingShader;
-    coloration: AdaptiveLightingShader;
-    illumination: AdaptiveLightingShader;
-  };
+  protected _configureShaders(): Record<keyof RenderingLayers, AdaptiveLightingShader.AnyConstructor>;
 
   /**
    * Specific configuration for a layer.
+   * @remarks Is a no-op in `RenderedEffectSource`
    */
-  protected _configureLayer(layer: Record<string, unknown>, layerId: string): void;
+  protected _configureLayer(layer: RenderedEffectSource.SourceLayer, layerId: string): void;
 
   /**
    * Create the geometry for the source shape that is used in shaders and compute its bounds for culling purpose.
@@ -133,18 +131,16 @@ declare class RenderedEffectSource<
 
   /**
    * Render the containers used to represent this light source within the LightingLayer
+   * @remarks Will error if called prior to initialization
    */
-  drawMeshes(): {
-    background: PIXI.Mesh;
-    coloration: PIXI.Mesh;
-    illumination: PIXI.Mesh;
-  };
+  drawMeshes(): Record<keyof RenderingLayers, PointSourceMesh | null>;
+
   /**
    * Create a Mesh for a certain rendered layer of this source.
    * @param layerId - The layer key in layers to draw
    * @returns The drawn mesh for this layer, or null if no mesh is required
    */
-  protected _drawMesh(layerId: string): PIXI.Mesh | null;
+  protected _drawMesh(layerId: string): PointSourceMesh | null;
 
   /**
    * Update shader uniforms used by every rendered layer.
@@ -166,24 +162,28 @@ declare class RenderedEffectSource<
    */
   protected _updateIlluminationUniforms(): void;
 
+  protected override _destroy(): void;
+
   /**
    * Animate the PointSource, if an animation is enabled and if it currently has rendered containers.
    * @param dt - Delta time.
+   * @privateRemarks In core this will return `void`, as the `this.animation.animation` function will  be a {@link foundry.canvas.sources.BaseLightSource.LightAnimationFunction | `BaseLightSource.LightAnimationFunction`}
+   * and in fact most of the time will be {@link foundry.canvas.sources.RenderedEffectSource.animateTime | `RenderedEffectSource#animateTime`}, but it could technically be set to any function
    */
-  animate(dt: number): this["animation"]["animation"] extends (...args: any) => infer Return ? Return : void;
+  animate(dt: number): this["animation"]["animation"] extends (...args: infer _1) => infer Return ? Return : void;
 
   /**
    * Generic time-based animation used for Rendered Point Sources.
    * @param dt      - Delta time.
    * @param options - Options which affect the time animation
    */
-  animateTime(dt: number, options?: InexactPartial<RenderedEffectSource.AnimationOptions>): void;
+  animateTime(dt: number, options?: RenderedEffectSource.AnimationFunctionOptions): void;
 
   /**
    * Get corrected level according to level and active vision mode data.
    * @returns The corrected level.
    */
-  static getCorrectedLevel(level: foundry.CONST.LIGHTING_LEVELS): number;
+  static getCorrectedLevel(level: foundry.CONST.LIGHTING_LEVELS): foundry.CONST.LIGHTING_LEVELS;
 
   /**
    * Get corrected color according to level, dim color, bright color and background color.
@@ -192,139 +192,250 @@ declare class RenderedEffectSource<
     level: foundry.CONST.LIGHTING_LEVELS,
     colorDim: Color,
     colorBright: Color,
-    colorBackground?: Color,
+    colorBackground?: Color | null,
   ): Color;
 
   /**
-   * @deprecated since v11
+   * @deprecated since v11, until v13
+   * @remarks "The RenderedEffectSource#preview is deprecated. Use RenderedEffectSource#isPreview instead."
    */
   set preview(preview: boolean);
 
   /**
-   * @deprecated since v11
+   * @deprecated since v11, until v13
+   * @remarks "The RenderedEffectSource#preview is deprecated. Set RenderedEffectSource#preview as part of RenderedEffectSource#initialize instead."
    */
   get preview(): boolean;
 }
 
 declare namespace RenderedEffectSource {
-  type Any = RenderedEffectSource<any, any, any>;
+  interface Any extends AnyRenderedEffectSource {}
+  interface AnyConstructor extends Identity<typeof AnyRenderedEffectSource> {}
 
-  interface RenderedEffectSourceData extends BaseEffectSource.BaseEffectSourceData {
+  interface SourceData extends BaseEffectSource.SourceData {
     /**
      * An animation configuration for the source
+     * @defaultValue `{}`
      */
-    animation: object;
+    animation: StoredAnimationConfig;
+
     /**
      * A color applied to the rendered effect
+     * @defaultValue `null`
+     * @remarks Foundry types as `number`, but it gets passed to `Color.from()`
+     *
+     * If `null`, Foundry will use the associated shader's `.defaultUniforms.color`
      */
-    color: number | null;
+    color: Color.Source | null;
+
     /**
      * An integer seed to synchronize (or de-synchronize) animations
+     * @defaultValue `null`
+     * @remarks This will remain null in `#data` if not specified, which will lead to `Math.floor(Math.random() * 100000)`
+     *
+     * If specified, takes precedence over `RenderedEffectSource#animation.seed`
      */
     seed: number | null;
+
     /**
      * Is this source a temporary preview?
+     * @defaultValue `false`
      */
     preview: boolean;
   }
 
-  interface AnimationOptions {
+  type AnimationFunction = (
+    this: RenderedEffectSource,
+    /** Delta time */
+    dt: number,
+    options?: AnimationFunctionOptions,
+  ) => void;
+
+  /** @internal */
+  type _AnimationFunctionOptions = InexactPartial<{
     /**
      * The animation speed, from 0 to 10
      * @defaultValue `5`
+     * @remarks Can't be `null` as it only has a parameter default
      */
-    speed?: number;
+    speed: number;
 
     /**
      * The animation intensity, from 1 to 10
      * @defaultValue `5`
+     * @remarks Can't be `null` as it only has a parameter default
      */
-    intensity?: number;
+    intensity: number;
 
     /**
      * Reverse the animation direction
      * @defaultValue `false`
      */
-    reverse?: boolean;
-  }
+    reverse: boolean | null;
+  }>;
+
+  /** Shared options for the {@link RenderedEffectSource.AnimationFunction | `AnimationFunction`}s provided by {@link foundry.canvas.sources.RenderedEffectSource | `RenderedEffectSource`} and subclasses */
+  interface AnimationFunctionOptions extends _AnimationFunctionOptions {}
 
-  interface RenderedEffectSourceAnimationConfig {
+  /**
+   * Properties *every* core-provided config has
+   * @internal
+   */
+  interface _AnimationConfigBase {
     /**
      * The human-readable (localized) label for the animation
+     * @remarks Despite the above, all of the core-provided configs provide a localization
+     * key here, not localized text.
      */
-    label?: string | undefined;
+    label: string;
+
     /**
      * The animation function that runs every frame
-     * @privateRemarks TODO: Figure out if there's a better way to define the function
+     * @privateRemarks Eventually called with `animation?.call()`, but at no point is a default provided,
+     * and not having one is nonsensical.
      */
-    animation?: AnyFunction | undefined;
+    animation: AnimationFunction | BaseLightSource.LightAnimationFunction;
+  }
+
+  /** @internal */
+  type _Seed = NullishProps<{
+    /**
+     * The animation seed
+     * @defaultValue `Math.floor(Math.random() * 100000)`
+     * @remarks No Foundry-provided config specifies this, but it would be respected if set
+     */
+    seed: number;
+  }>;
+
+  /**
+   * Each Foundry-provided entry in `CONFIG.Canvas.lightAnimations` provides at least a `colorationShader`,
+   * but any properties not provided will be backfilled by `|| this.layers[layer].defaultShader`
+   * @internal
+   */
+  type _AnimationConfigLightingShaders = NullishProps<{
     /**
      * A custom illumination shader used by this animation
+     * @defaultValue `AdaptiveIlluminationShader`
      */
-    illuminationShader?: AdaptiveIlluminationShader | undefined;
+    illuminationShader: AdaptiveIlluminationShader.AnyConstructor;
+
     /**
      * A custom coloration shader used by this animation
+     * @defaultValue `AdaptiveColorationShader`
      */
-    colorationShader?: AdaptiveColorationShader | undefined;
+    colorationShader: AdaptiveColorationShader.AnyConstructor;
+
     /**
      * A custom background shader used by this animation
+     * @defaultValue `AdaptiveBackgroundShader`
      */
-    backgroundShader?: AdaptiveBackgroundShader | undefined;
+    backgroundShader: AdaptiveBackgroundShader.AnyConstructor;
+  }> & { darknessShader?: never };
+
+  /**
+   * Foundry's typedef lists `darknessShader` as required, and every core-provided config
+   * has one specified, but it has a default just like the lighting shaders
+   * @internal
+   */
+  interface _AnimationConfigDarknessShaders {
     /**
      * A custom darkness shader used by this animation
+     * @defaultValue `AdaptiveDarknessShader`
      */
-    darknessShader?: AdaptiveDarknessShader | undefined;
-    /**
-     * The animation seed
-     */
-    seed?: number | undefined;
+    darknessShader: AdaptiveDarknessShader.AnyConstructor;
+
+    illuminationShader?: never;
+    colorationShader?: never;
+    backgroundShader?: never;
+  }
+
+  /**
+   * `this.animation.time` always gets set by `RenderedEffectSource#animateTime`,
+   * which all animation functions end up calling
+   * @internal
+   */
+  type _AnimationConfigComputed = InexactPartial<{
     /**
      * The animation time
+     * @remarks Always computed, never specified in `CONFIG`
      */
-    time?: number | undefined;
-  }
+    time: number;
+  }>;
+
+  interface LightAnimationConfig extends _AnimationConfigBase, _Seed, _AnimationConfigLightingShaders {}
+
+  interface StoredLightAnimationConfig extends IntentionalPartial<LightAnimationConfig>, _AnimationConfigComputed {}
 
-  interface RenderedEffectSourceLayer {
+  interface DarknessAnimationConfig extends _AnimationConfigBase, _Seed, _AnimationConfigDarknessShaders {}
+
+  interface StoredDarknessAnimationConfig
+    extends IntentionalPartial<DarknessAnimationConfig>,
+      _AnimationConfigComputed {}
+
+  type AnimationConfig = LightAnimationConfig | DarknessAnimationConfig;
+
+  type StoredAnimationConfig = StoredLightAnimationConfig | StoredDarknessAnimationConfig;
+  /**
+   * @remarks The properties `mesh` and `shader` from `LayerConfig` are not documented as being part of the typedef. They are given values
+   * during initialization *if* the Source has a valid `Placeable` as its `object`. `vmUniforms` is only provided a value for `PointVisionSource` layers.
+   */
+  interface SourceLayer extends LayerConfig {
     /**
      * Is this layer actively rendered?
      */
     active: boolean;
+
     /**
      * Do uniforms need to be reset?
      */
     reset: boolean;
+
     /**
      * Is this layer temporarily suppressed?
      */
     suppressed: boolean;
+
     /**
      * The rendered mesh for this layer
      */
-    mesh: PointSourceMesh;
+    mesh: PointSourceMesh | undefined;
+
     /**
      * The shader instance used for the layer
      */
-    shader: AdaptiveLightingShader;
+    shader: AdaptiveLightingShader | undefined;
+
+    /** @remarks Foundry does not include this in the typedef but is in the initialization of `RenderedEffectSource#layers` */
+    vmUniforms: AbstractBaseShader.Uniforms | undefined;
   }
 
-  interface RenderedEffectLayerConfig {
+  interface LayerConfig {
     /**
      * The default shader used by this layer
      */
-    defaultShader: AdaptiveLightingShader;
+    defaultShader: AdaptiveLightingShader.AnyConstructor;
+
     /**
      * The blend mode used by this layer
      */
-    blendMode: PIXI.BLEND_MODES;
+    blendMode: keyof typeof PIXI.BLEND_MODES;
   }
 
-  // Interface causes errors
+  // Interface would require `RenderingLayers extends ... = InterfaceToObject<Layers>` in every subclass signature
   // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
   type Layers = {
-    background: RenderedEffectSource.RenderedEffectSourceLayer;
-    coloration: RenderedEffectSource.RenderedEffectSourceLayer;
-    illumination: RenderedEffectSource.RenderedEffectSourceLayer;
+    background: RenderedEffectSource.SourceLayer;
+    coloration: RenderedEffectSource.SourceLayer;
+    illumination: RenderedEffectSource.SourceLayer;
   };
 }
 
+declare abstract class AnyRenderedEffectSource extends RenderedEffectSource<
+  RenderedEffectSource.SourceData,
+  PIXI.Polygon,
+  RenderedEffectSource.Layers
+> {
+  constructor(...args: never);
+}
+
 export default RenderedEffectSource;

package/src/foundry/client-esm/canvas/tokens/_module.d.mts

@@ -1,8 +1,7 @@
 // In Foundry itself this file contains re-exports of these other modules.
 // Therefore it has a runtime effect and uses `.mjs` instead of `.d.mts`.
-// While `.mts` could work, to avoid `import/no-unresolved` from erroring `.mjs` is used.
-/* eslint-disable import/extensions */
-/* eslint-disable import/no-unresolved */ // TODO: Remove when the files are instantiated
+// While `.mts` could work, to avoid `import-x/no-unresolved` from erroring `.mjs` is used.
+/* eslint-disable import-x/extensions */
 
 export { default as TokenRing } from "./ring.mjs";
 export { default as TokenRingConfig } from "./ring-config.mjs";

package/src/foundry/client-esm/canvas/tokens/ring-config.d.mts

@@ -1,3 +1,6 @@
+import type { InitializedOn } from "../../../../utils/index.d.mts";
+import type DynamicRingData from "./ring-data.d.mts";
+
 /**
  * Token Ring configuration Singleton Class.
  *
@@ -72,8 +75,178 @@
  * CONFIG.Token.ring.debugColorBands = true;
  * ```
  */
-declare class TokenRingConfig {}
+declare class TokenRingConfig {
+  constructor();
+
+  /**
+   * Core token rings used in Foundry VTT.
+   * Each key is a string identifier for a ring, and the value is an object containing the ring's data.
+   * This object is frozen to prevent any modifications.
+   * @remarks The outer object is frozen, but the individual rings' data isn't, and that object gets passed into a {@link DynamicRingData | `DynamicRingData`} constructor, leading to, for example,
+   * ```js
+   * CONFIG.Token.ring.getConfig("coreSteel")._source === TokenRingConfig.CORE_TOKEN_RINGS.coreSteel
+   * ```
+   * after {@link TokenRingConfig.initialize | `initialize`} has been called, which happens between the `setup` and `ready` hooks
+   */
+  static CORE_TOKEN_RINGS: TokenRingConfig.CoreTokenRings;
+
+  /**
+   * Core token rings fit modes used in Foundry VTT.
+   */
+  static CORE_TOKEN_RINGS_FIT_MODES: TokenRingConfig.CoreTokenRingsFitModes;
+
+  /**
+   * Register the token ring config and initialize it
+   * @remarks Calls the {@link Hooks.StaticCallbacks.initializeDynamicTokenRingConfig | `initializeDynamicTokenRingConfig`} hook via {@link Hooks.callAll | `Hooks.callAll`}
+   */
+  static initialize(): void;
+
+  /** Register game settings used by the Token Ring */
+  static registerSettings(): void;
+
+  /**
+   * A mapping of token subject paths where modules or systems have configured subject images.
+   * @defaultValue `{}`
+   * @remarks Not directly used anywhere in this class, essentially just a global cache. The system's `flags.tokenRingSubjectMappings`, if any, get assigned here in {@link Game.initializeConfig | `Game#initializeConfig`},
+   * and they're read in {@link TokenDocument._inferRingSubjectTexture | `TokenDocument#_inferRingSubjectTexture`}
+   */
+  subjectPaths: Record<string, string>;
+
+  /**
+   * All color bands visual debug flag.
+   * @defaultValue `false`
+   */
+  debugColorBands: boolean;
+
+  /**
+   * Get the current ring class.
+   * @remarks Since `##currentConfig` is a reference to a `##configs` entry, not a copy, setting this will persist in that config
+   */
+  get ringClass(): DynamicRingData["framework"]["ringClass"];
+  set ringClass(value);
+
+  /** Get the current effects. */
+  get effects(): DynamicRingData["effects"];
+
+  /** Get the current spritesheet. */
+  get spritesheet(): DynamicRingData["spritesheet"];
+
+  /**
+   * Get the current shader class.
+   * @remarks Since `##currentConfig` is a reference to a `##configs` entry, not a copy, setting this will persist in that config
+   */
+  get shaderClass(): DynamicRingData["framework"]["shaderClass"];
+  set shaderClass(value);
+
+  /** Get the current localized label */
+  get label(): DynamicRingData["label"];
+
+  /** Get the current id. */
+  get id(): DynamicRingData["id"];
+
+  /**
+   * Is a custom fit mode active?
+   * @remarks Anything other than `subject` is "custom", but the only other fit mode is `grid`
+   */
+  get isGridFitMode(): boolean;
+
+  /**
+   * Add a new ring configuration.
+   * @param id      - The id of the ring configuration.
+   * @param config  - The configuration object for the ring.
+   * @throws If called outside a callback for the {@link Hooks.StaticCallbacks.initializeDynamicTokenRingConfig | `initializeDynamicTokenRingConfig`} hook
+   * @remarks The actual error thrown incorrectly refers to a non-existent `registerDynamicTokenRing` hook
+   */
+  addConfig(id: string, config: DynamicRingData): void;
+
+  /**
+   * Get a ring configuration.
+   * @param id  - The id of the ring configuration.
+   * @returns   - The ring configuration object.
+   */
+  getConfig(id: string): DynamicRingData;
+
+  /**
+   * Use a ring configuration.
+   * @param id  - The id of the ring configuration to use.
+   * @returns   - True if the configuration was successfully set, false otherwise.
+   */
+  useConfig(id: string): boolean;
+
+  /** Get the IDs of all configurations. */
+  get configIDs(): string[];
+
+  /** Get the labels of all configurations. */
+  get configLabels(): Record<string, string>;
+
+  /**
+   * @deprecated since v12, until v14
+   * @remarks "TokenRingConfig#configNames is deprecated and replaced by TokenRingConfig#configIDs"
+   *
+   * Foundry comment claims deprecated since v11 - possibly a dnd5e-implementation-related deprecation?
+   */
+  get configNames(): string[];
+}
+
+declare namespace TokenRingConfig {
+  interface Any extends AnyTokenRingConfig {}
+  type AnyConstructor = typeof AnyTokenRingConfig;
+
+  /** Token ring fit modes for dynamic token ring visualization */
+  interface RingFitMode {
+    /** The fit mode identifier. */
+    id: string;
+
+    /** The fit mode label. */
+    label: string;
+  }
+
+  /**
+   * Core token rings fit modes used in Foundry VTT.
+   * @remarks Only the two provided core fit modes are checked against, by hardcoded IDs
+   */
+  interface CoreTokenRingsFitModes {
+    readonly subject: RingFitMode;
+    readonly grid: RingFitMode;
+  }
+
+  type CoreRingIDs = "coreSteel" | "coreBronze";
+
+  /**
+   * @remarks The type of any given {@link TokenRingConfig.CORE_TOKEN_RINGS | `TokenRingConfig.CORE_TOKEN_RINGS`} entry prior to
+   * {@link TokenRingConfig.initialize | `TokenRingConfig#initialize`} being called between the `setup` and `ready` hooks; Plain objects at this point
+   */
+  interface InitialCoreRingData extends Required<Pick<SourceCoreRingData, "id" | "label" | "spritesheet">> {}
+
+  interface InitialCoreRings extends Record<CoreRingIDs, InitialCoreRingData> {}
+
+  /**
+   * @remarks Due to the way the core configs are initialized, {@link TokenRingConfig.CORE_TOKEN_RINGS | `TokenRingConfig.CORE_TOKEN_RINGS`}
+   * ends up becoming the `_source` of the constructed DataModels in {@link CONFIG.Token.ring | `CONFIG.Token.ring`}, that is:
+   * ```js
+   * CONFIG.Token.ring.getConfig("coreSteel")._source === TokenRingConfig.CORE_TOKEN_RINGS.coreSteel
+   * ```
+   * after {@link TokenRingConfig.initialize | `TokenRingConfig#initialize`} has been called, which happens between the `setup` and `ready` hooks
+   */
+  interface SourceCoreRingData extends foundry.data.fields.SchemaField.SourceData<DynamicRingData.Schema> {}
+
+  interface SourceCoreRings extends Record<CoreRingIDs, SourceCoreRingData> {}
+
+  /**
+   * Core token rings used in Foundry VTT.
+   * Each key is a string identifier for a ring, and the value is an object containing the ring's data.
+   * This object is frozen to prevent any modifications.
+   * @remarks The outer object is frozen, but the individual rings' data isn't, and that object gets passed into a {@link DynamicRingData | `DynamicRingData`} constructor, leading to, for example,
+   * ```js
+   * CONFIG.Token.ring.getConfig("coreSteel")._source === TokenRingConfig.CORE_TOKEN_RINGS.coreSteel
+   * ```
+   * after {@link TokenRingConfig.initialize | `TokenRingConfig#initialize`} has been called, which happens between the `setup` and `ready` hooks
+   */
+  type CoreTokenRings = InitializedOn<SourceCoreRings, "ready", InitialCoreRings>;
+}
 
-declare namespace TokenRingConfig {}
+declare abstract class AnyTokenRingConfig extends TokenRingConfig {
+  constructor(...args: never);
+}
 
 export default TokenRingConfig;