@league-of-foundry-developers/foundry-vtt-types 13.346.0-beta.20250823115730 → 13.346.0-beta.20250825015921

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@league-of-foundry-developers/foundry-vtt-types",
-  "version": "13.346.0-beta.20250823115730",
+  "version": "13.346.0-beta.20250825015921",
   "description": "TypeScript type definitions for Foundry VTT",
   "type": "module",
   "types": "./src/index.d.mts",

package/src/configuration/configuration.d.mts

@@ -266,9 +266,7 @@ export interface SettingConfig {
   "core.chatBubbles": fields.BooleanField<{ initial: true }>;
   "core.chatBubblesPan": fields.BooleanField<{ initial: true }>;
   "core.combatTrackerConfig": MaybeEmpty<{ resource: string; skipDefeated: boolean }>;
-  "core.compendiumConfiguration": Partial<
-    Record<string, foundry.documents.collections.CompendiumCollection.Configuration>
-  >;
+  "core.compendiumConfiguration": foundry.documents.collections.CompendiumCollection.SettingField;
   "core.gridTemplates": fields.BooleanField<{ initial: false }>;
   "core.coneTemplateType": "round" | "flat";
   "core.colorSchema": fields.StringField<{

package/src/configuration/globals.d.mts

@@ -12,7 +12,7 @@
 
 // eslint-disable-next-line import-x/no-named-default
 import { default as AlphaBlurFilter, AlphaBlurFilterPass } from "#client/canvas/rendering/filters/blur.mjs";
-import { ShaderField } from "#client/canvas/perception/vision-mode.mjs";
+import { ShaderField } from "#client/data/fields.mjs";
 import { DarknessLevelContainer } from "#client/canvas/layers/_module.mjs";
 
 export import AVSettings = globalThis.AVSettings;

package/src/foundry/client/_types.d.mts

@@ -81,9 +81,9 @@ type ManageCompendiumRequest = unknown;
 
 type ManageCompendiumResponse = unknown;
 
-type WorldCompendiumPackConfiguration = unknown;
+type WorldCompendiumPackConfiguration = foundry.documents.collections.CompendiumCollection.Configuration;
 
-type WorldCompendiumConfiguration = Record<string, WorldCompendiumPackConfiguration>;
+type WorldCompendiumConfiguration = foundry.documents.collections.CompendiumCollection.SettingData;
 
 type SettingConfig = foundry.helpers.ClientSettings.SettingConfig;
 

package/src/foundry/client/applications/ui/scene-controls.d.mts

@@ -115,14 +115,34 @@ declare namespace SceneControls {
   }
 
   /**
-   * The data structure for a set of controls in the {@link SceneControls#controls} record.
+   * The data structure for a set of controls in the {@linkcode SceneControls.controls | SceneControls#controls} record.
    */
   interface Control {
+    /**
+     * A unique identifier for the control
+     */
     name: string;
+
+    /**
+     * An integer indicating the control's order, with 0 being at the top
+     */
     order: number;
+
+    /**
+     * A title for the control: can be a localization path
+     */
     title: string;
+
+    /**
+     * One or more icon classes for the control, typically Font Awesome classes such as `"fa-solid fa-face-smile"`
+     */
     icon: string;
+
+    /**
+     * Whether the control should be visible to the current User
+     */
     visible?: boolean | undefined;
+
     tools: Record<string, Tool>;
 
     /**
@@ -138,17 +158,47 @@ declare namespace SceneControls {
   }
 
   /**
-   * The data structure for a single tool in the {@link Control#tools} record.
+   * The data structure for a single tool in the {@linkcode Control.tools | Control#tools} record.
    */
   interface Tool {
+    /**
+     * An identifier for the tool, unique among the tools of its SceneControl
+     */
     name: string;
+
+    /**
+     * An integer indicating the tool's order, with 0 being at the top
+     */
     order: number;
+
+    /**
+     * A title for the tool: can be a localization path
+     */
     title: string;
+
+    /**
+     * One or more icon classes for the tool, typically Font Awesome classes such as `"fa-solid fa-face-smile"`
+     */
     icon: string;
 
+    /**
+     * Whether the tool should be visible to the current User
+     */
     visible?: boolean | undefined;
+
+    /**
+     * Is the tool an on-or-off toggle?
+     */
     toggle?: boolean | undefined;
+
+    /**
+     * Is the tool the currently the active one? Not applicable to toggles or buttons.
+     */
     active?: boolean | undefined;
+
+    /**
+     * Is the tool a "button" in the sense of immediately resolving on click without becoming the active tool?
+     */
     button?: boolean | undefined;
 
     /** A callback invoked when the tool is activated or deactivated */

package/src/foundry/client/canvas/containers/elements/door-mesh.d.mts

@@ -173,8 +173,8 @@ declare namespace DoorMesh {
      * @remarks
      * - For `swing` and `swivel` it's a linear scale from 0 (no movement) to 2 (180 degrees)
      * - For `slide` it's door-lengths shifted
-     * - For `ascend` and `descend` it affects how much the texture grows/shrinks. For `ascend` there's also code in place that implies it should
-     * affect the texture `alpha` (down to a minimum of `0.6` at strength `2.0`), but it's non-functional as of 13.346: {@link https://github.com/foundryvtt/foundryvtt/issues/13157}
+     * - For `ascend` and `descend` it affects how much the texture grows/shrinks, and for `ascend`
+     * it also affects the texture `alpha` (down to a minimum of `0.5` at strength `2.0`)
      */
     strength: number;
 
@@ -218,6 +218,7 @@ declare namespace DoorMesh {
     scaleX: number;
     scaleY: number;
     tint: number;
+    alpha: number;
   }
 }
 

package/src/foundry/client/canvas/interaction/render-flags.d.mts

@@ -94,8 +94,14 @@ declare class RenderFlags<Flags extends RenderFlags.ValidateFlags<Flags>> extend
   /** @remarks `defineProperty`'d at construction with `enumerable: false, writable: false` and the value frozen. */
   readonly flags: Readonly<Flags>;
 
-  /** @remarks `defineProperty`'d at construction with `enumerable: false, writable: false` */
-  readonly object: RenderFlagObject;
+  /**
+   * @remarks `defineProperty`'d at construction with `enumerable: false, writable: false`
+   *
+   * `| undefined` because Foundry marks both the constructor's `config` parameter and its {@linkcode RenderFlags.Config.object | object}
+   * property as optional, but in core usage the only place this is called is in the {@linkcode RenderFlagsObject} constructor, where it's
+   * passed `object: this`
+   */
+  readonly object: RenderFlagObject | undefined;
 
   /**
    * The update priority when these render flags are applied.
@@ -134,13 +140,10 @@ declare namespace RenderFlags {
 
     /**
      * The ticker priority at which these render flags are handled
-     * @defaultValue {@linkcode PIXI.UPDATE_PRIORITY.OBJECTS}
-     * @remarks The default value does *not* match the type as of 13.346, this is a core bug: {@link https://github.com/foundryvtt/foundryvtt/issues/13171}.
-     * Due to this the property has been marked required here, it can go back to optional if the default is fixed.
-     *
-     * See {@linkcode RenderFlags.priority | RenderFlags#priority}
+     * @defaultValue "OBJECTS"
+     * @remarks See {@linkcode RenderFlags.priority | RenderFlags#priority}
      */
-    priority: Priority;
+    priority?: Priority | undefined;
   }
 
   /**

package/src/foundry/client/canvas/perception/vision-mode.d.mts

@@ -1,69 +1,8 @@
-import type { AnyObject, Brand, ConcreteKeys, Identity, InterfaceToObject, SimpleMerge } from "#utils";
+import type { AnyObject, Brand, ConcreteKeys, Identity, InterfaceToObject } from "#utils";
 import type { fields } from "#common/data/_module.d.mts";
-import type { AbstractBaseShader } from "#client/canvas/rendering/shaders/_module.d.mts";
 import type { DataModel } from "#common/abstract/_module.d.mts";
 import type { PointVisionSource } from "#client/canvas/sources/_module.d.mts";
-
-declare class ShaderField<
-  const Options extends ShaderField.Options = ShaderField.DefaultOptions,
-  const AssignmentType = ShaderField.AssignmentType<Options>,
-  const InitializedType = ShaderField.InitializedType<Options>,
-  const PersistedType extends typeof AbstractBaseShader | null | undefined = ShaderField.InitializedType<Options>,
-> extends fields.DataField<Options, AssignmentType, InitializedType, PersistedType> {
-  /**
-   * @defaultValue
-   * ```typescript
-   * const defaults = super._defaults;
-   * defaults.nullable = true;
-   * defaults.initial = undefined;
-   * return defaults;
-   * ```
-   */
-  static override get _defaults(): ShaderField.DefaultOptions;
-
-  /**
-   * @remarks
-   * @throws If the value provided is not an {@linkcode AbstractBaseShader} subclass.
-   */
-  override _cast(value: unknown): AssignmentType; // typeof AbstractBaseShader;
-}
-
-declare namespace ShaderField {
-  type Options = fields.DataField.Options<typeof AbstractBaseShader>;
-
-  type DefaultOptions = SimpleMerge<
-    fields.DataField.DefaultOptions,
-    {
-      nullable: true;
-      initial: undefined;
-    }
-  >;
-
-  /**
-   * A helper type for the given options type merged into the default options of the BooleanField class.
-   * @template Opts - the options that override the default options
-   */
-  type MergedOptions<Opts extends Options> = SimpleMerge<DefaultOptions, Opts>;
-
-  /**
-   * A shorthand for the assignment type of a BooleanField class.
-   * @template Opts - the options that override the default options
-   */
-  // eslint-disable-next-line @typescript-eslint/no-deprecated
-  type AssignmentType<Opts extends Options> = fields.DataField.DerivedAssignmentType<
-    typeof AbstractBaseShader,
-    MergedOptions<Opts>
-  >;
-
-  /**
-   * A shorthand for the initialized type of a BooleanField class.
-   * @template Opts - the options that override the default options
-   */
-  type InitializedType<Opts extends Options> = fields.DataField.DerivedInitializedType<
-    typeof AbstractBaseShader,
-    MergedOptions<Opts>
-  >;
-}
+import type { fields as clientFields } from "#client/data/_module.d.mts";
 
 /**
  * A Vision Mode which can be selected for use by a Token.
@@ -161,7 +100,7 @@ declare namespace VisionMode {
   }
 
   interface ShaderSchema extends fields.DataSchema {
-    shader: ShaderField;
+    shader: clientFields.ShaderField;
     uniforms: fields.ObjectField;
   }
 
@@ -204,7 +143,7 @@ declare namespace VisionMode {
     label: fields.StringField<{ blank: false }>;
     tokenConfig: fields.BooleanField<{ initial: true }>;
     canvas: fields.SchemaField<{
-      shader: ShaderField;
+      shader: clientFields.ShaderField;
       uniforms: fields.ObjectField;
     }>;
     lighting: fields.SchemaField<LightingSchema>;
@@ -253,6 +192,12 @@ declare namespace VisionMode {
   interface SourceData extends fields.SchemaField.SourceData<Schema> {}
 }
 
+/**
+ * @deprecated "Kept here for full compatibility" (since v13, until v14)
+ * @remarks Access via {@linkcode foundry.data.fields.ShaderField} instead
+ */
+declare const ShaderField: clientFields.ShaderField;
+
 export { VisionMode as default, ShaderField };
 
 declare class AnyVisionMode extends VisionMode {

package/src/foundry/client/canvas/primary/primary-graphics.d.mts

@@ -8,12 +8,8 @@ import type { PlaceableObject } from "#client/canvas/placeables/_module.d.mts";
 declare class PrimaryGraphics extends PrimaryCanvasObjectMixin(PIXI.smooth.SmoothGraphics) {
   /**
    * @param options - A config object
-   * @remarks Passing a {@linkcode PIXI.smooth.SmoothGraphicsGeometry} instead of an `options` should be supported here,
-   * but has been disabled due to a core bug: {@link https://github.com/foundryvtt/foundryvtt/issues/13170}
-   *
-   * If you need to pass a specific geometry instead of using a default `new SmoothGraphicsGeometry`, pass it as `options.geometry`.
    */
-  constructor(options?: PrimaryGraphics.ConstructorOptions);
+  constructor(options?: PrimaryGraphics.ConstructorOptions | PIXI.smooth.SmoothGraphicsGeometry);
 
   protected override _calculateCanvasBounds(): void;
 
@@ -34,9 +30,6 @@ declare namespace PrimaryGraphics {
      * A geometry passed to the graphics.
      * @defaultValue {@linkcode PIXI.smooth.SmoothGraphicsGeometry | new PIXI.smooth.SmoothGraphicsGeometry()}
      * @remarks Default applied in the {@linkcode PIXI.smooth.SmoothGraphics} constructor.
-     *
-     * @privateRemarks Foundry types this incorrectly because they didn't update it when they switched base classes:
-     * {@link https://github.com/foundryvtt/foundryvtt/issues/13170}
      */
     geometry: PIXI.smooth.SmoothGraphicsGeometry;
 

package/src/foundry/client/canvas/rendering/filters/_module.d.mts

@@ -21,3 +21,4 @@ export { default as VisibilityFilter } from "./visibility.mjs";
 export { default as VisionMaskFilter } from "./vision-mask-filter.mjs";
 export { default as VoidFilter } from "./void.mjs";
 export { default as WeatherOcclusionMaskFilter } from "./weather-occlusion-mask.mjs";
+export { default as AlphaBlurFilter, AlphaBlurFilterPass } from "./blur.mjs";

package/src/foundry/client/canvas/rendering/shaders/base-shader.d.mts

@@ -11,6 +11,13 @@ declare abstract class AbstractBaseShader extends BaseShaderMixin(PIXI.Shader) {
    */
   constructor(program: PIXI.Program, uniforms?: AbstractBaseShader.Uniforms);
 
+  /**
+   * Identify this class to be compatible with ShaderField
+   * @internal
+   * @remarks This is `defineProperty`'d on the class after its definition, with `writable: false, enumerable: false, configurable: false`
+   */
+  protected static readonly _isShaderFieldCompatible: true;
+
   /**
    * The raw vertex shader used by this class.
    * A subclass of AbstractBaseShader must implement the vertexShader static field.

package/src/foundry/client/client.d.mts

@@ -1124,6 +1124,12 @@ declare global {
    */
   export import CanvasVisionMask = foundry.canvas.layers.CanvasVisionMask;
 
+  /**
+   * @deprecated "You are accessing the global {@linkcode DarknessLevelContainer} which is now namespaced under {@linkcode foundry.canvas.layers.DarknessLevelContainer}"
+   * (since v13 will be removed in v15)
+   */
+  export import DarknessLevelContainer = foundry.canvas.layers.DarknessLevelContainer;
+
   /**
    * @deprecated "You are accessing the global {@linkcode DrawingsLayer} which is now namespaced under {@linkcode foundry.canvas.layers.DrawingsLayer}"
    * (since v13 will be removed in v15)
@@ -1256,6 +1262,12 @@ declare global {
    */
   export import UnboundTransform = foundry.canvas.geometry.UnboundTransform;
 
+  /**
+   * @deprecated "You are accessing the global {@linkcode ObservableTransform} which is now namespaced under {@linkcode foundry.canvas.geometry.ObservableTransform}"
+   * (since v13 will be removed in v15)
+   */
+  export import ObservableTransform = foundry.canvas.geometry.ObservableTransform;
+
   /**
    * @deprecated "You are accessing the global {@linkcode LimitedAnglePolygon} which is now namespaced under {@linkcode foundry.canvas.geometry.LimitedAnglePolygon}"
    * (since v13 will be removed in v15)
@@ -1592,6 +1604,18 @@ declare global {
    */
   export import VoidFilter = foundry.canvas.rendering.filters.VoidFilter;
 
+  /**
+   * @deprecated "You are accessing the global {@linkcode AlphaBlurFilter} which is now namespaced under {@linkcode foundry.canvas.rendering.filters.AlphaBlurFilter}"
+   * (since v13 will be removed in v15)
+   */
+  export import AlphaBlurFilter = foundry.canvas.rendering.filters.AlphaBlurFilter;
+
+  /**
+   * @deprecated "You are accessing the global {@linkcode AlphaBlurFilterPass} which is now namespaced under {@linkcode foundry.canvas.rendering.filters.AlphaBlurFilterPass}"
+   * (since v13 will be removed in v15)
+   */
+  export import AlphaBlurFilterPass = foundry.canvas.rendering.filters.AlphaBlurFilterPass;
+
   /**
    * @deprecated "You are accessing the global {@linkcode WeatherOcclusionMaskFilter} which is now namespaced under {@linkcode foundry.canvas.rendering.filters.WeatherOcclusionMaskFilter}"
    * (since v13 will be removed in v15)

package/src/foundry/client/data/_module.d.mts

@@ -3,11 +3,13 @@
 // While `.mts` could work, to avoid `import-x/no-unresolved` from erroring `.mjs` is used.
 /* eslint-disable import-x/extensions */
 
-// export * as types from "./_types.mjs";
+export * as types from "./_types.mjs";
 export * from "#common/data/_module.mjs";
 export * as regionBehaviors from "./region-behaviors/_module.mjs";
 export * as regionShapes from "./region-shapes/_module.mjs";
+export * as fields from "./fields.mjs";
 export * from "./terrain-data.mjs";
 export { default as CombatConfiguration } from "./combat-config.mjs";
 export { default as ClientDatabaseBackend } from "./client-backend.mjs";
-export { default as CalendarData, SIMPLIFIED_GREGORIAN_CALENDAR_CONFIG } from "./calendar.mjs";
+export { default as CalendarData } from "./calendar.mjs";
+export * from "./calendar.mjs";

package/src/foundry/client/data/_types.d.mts

@@ -8,3 +8,14 @@
 import type CombatConfiguration from "./combat-config.d.mts";
 
 type CombatConfigurationData = CombatConfiguration.Data;
+type CalendarConfig = unknown;
+type CalendarConfigYears = unknown;
+type CalendarConfigLeapYear = unknown;
+type CalendarConfigMonths = unknown;
+type CalendarConfigMonth = unknown;
+type CalendarConfigDays = unknown;
+type CalendarConfigDay = unknown;
+type CalendarConfigSeasons = unknown;
+type CalendarConfigSeason = unknown;
+type TimeComponents = unknown;
+type TimeFormatter = unknown;

package/src/foundry/client/data/fields.d.mts

@@ -0,0 +1,72 @@
+import type { SimpleMerge } from "#utils";
+import type { fields } from "#common/data/_module.d.mts";
+import type { AbstractBaseShader } from "#client/canvas/rendering/shaders/_module.d.mts";
+
+declare class ShaderField<
+  const Options extends ShaderField.Options = ShaderField.DefaultOptions,
+  const AssignmentType = ShaderField.AssignmentType<Options>,
+  const InitializedType = ShaderField.InitializedType<Options>,
+  const PersistedType extends typeof AbstractBaseShader | null | undefined = ShaderField.InitializedType<Options>,
+> extends fields.DataField<Options, AssignmentType, InitializedType, PersistedType> {
+  /**
+   * @defaultValue
+   * ```typescript
+   * const defaults = super._defaults;
+   * defaults.nullable = true;
+   * defaults.initial = undefined;
+   * return defaults;
+   * ```
+   */
+  static override get _defaults(): ShaderField.DefaultOptions;
+
+  /**
+   * @remarks
+   * @throws If the value provided is not an {@linkcode AbstractBaseShader} subclass.
+   */
+  override _cast(value: unknown): AssignmentType; // typeof AbstractBaseShader;
+}
+
+declare namespace ShaderField {
+  type Options = fields.DataField.Options<typeof AbstractBaseShader>;
+
+  type DefaultOptions = SimpleMerge<
+    fields.DataField.DefaultOptions,
+    {
+      nullable: true;
+      initial: undefined;
+    }
+  >;
+
+  /**
+   * A helper type for the given options type merged into the default options of the BooleanField class.
+   * @template Opts - the options that override the default options
+   */
+  type MergedOptions<Opts extends Options> = SimpleMerge<DefaultOptions, Opts>;
+
+  /**
+   * A shorthand for the assignment type of a BooleanField class.
+   * @template Opts - the options that override the default options
+   */
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
+  type AssignmentType<Opts extends Options> = fields.DataField.DerivedAssignmentType<
+    typeof AbstractBaseShader,
+    MergedOptions<Opts>
+  >;
+
+  /**
+   * A shorthand for the initialized type of a BooleanField class.
+   * @template Opts - the options that override the default options
+   */
+  type InitializedType<Opts extends Options> = fields.DataField.DerivedInitializedType<
+    typeof AbstractBaseShader,
+    MergedOptions<Opts>
+  >;
+}
+
+export { ShaderField };
+
+/**
+ * @remarks The `export * as fields` in `./_module.mjs` overwrites the re-export of `common/data/_module.mjs`'s `fields`,
+ * so the common fields are also re-exported here. This matches how Foundry's exports are handled.
+ */
+export * from "#common/data/fields.mjs";

package/src/foundry/client/documents/abstract/canvas-document.d.mts

@@ -53,7 +53,7 @@ declare function CanvasDocumentMixin<BaseClass extends CanvasDocumentMixin.BaseC
 ): CanvasDocumentMixin.Mix<BaseClass>;
 
 declare namespace CanvasDocumentMixin {
-  interface AnyMixedConstructor extends ReturnType<typeof foundry.documents.abstract.ClientDocumentMixin<BaseClass>> {}
+  interface AnyMixedConstructor extends ReturnType<typeof foundry.documents.abstract.CanvasDocumentMixin<BaseClass>> {}
   interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
 
   type Mix<BaseClass extends CanvasDocumentMixin.BaseClass> = Mixin<

package/src/foundry/client/documents/abstract/client-document.d.mts

@@ -15,7 +15,7 @@ import type ApplicationV2 from "#client/applications/api/application.d.mts";
 import type TextEditor from "#client/applications/ux/text-editor.mjs";
 
 declare class InternalClientDocument<DocumentName extends Document.Type> {
-  /** @privateRemarks All mixin classses should accept anything for its constructor. */
+  /** @privateRemarks All mixin classes should accept anything for its constructor. */
   constructor(...args: any[]);
 
   /**
@@ -117,15 +117,35 @@ declare class InternalClientDocument<DocumentName extends Document.Type> {
   protected _safePrepareData(): void;
 
   /**
-   * Prepare data for the Document. This method is called automatically by the DataModel#_initialize workflow.
-   * This method provides an opportunity for Document classes to define special data preparation logic.
-   * The work done by this method should be idempotent. There are situations in which prepareData may be called more
-   * than once.
+   * Prepare data for the Document. This method provides an opportunity for Document classes to define special data
+   * preparation logic to compute values that don't need to be stored in the database, such as a "bloodied" hp value
+   * or the total carrying weight of items. The work done by this method should be idempotent per initialization.
+   * There are situations in which prepareData may be called more than once.
+   *
+   * By default, foundry calls the following methods in order whenever the document is created or updated.
+   * 1. {@linkcode foundry.abstract.DataModel.reset | reset} (Inherited from DataModel)
+   * 2. {@linkcode _initialize} (Inherited from DataModel)
+   * 3. {@linkcode prepareData}
+   * 4. {@linkcode foundry.abstract.TypeDataModel.prepareBaseData | TypeDataModel#prepareBaseData}
+   * 5. {@linkcode prepareBaseData}
+   * 6. {@linkcode prepareEmbeddedDocuments}
+   * 7. {@linkcode foundry.abstract.TypeDataModel.prepareDerivedData | TypeDataModel#prepareBaseData}
+   * 8. {@linkcode prepareDerivedData}
+   *
+   * Do NOT invoke database operations like {@linkcode Document.update | update} or {@linkcode Document.setFlag | setFlag} within data prep, as that can cause an
+   * infinite loop by re-triggering the data initialization process.
+   *
+   * If possible you should extend {@linkcode prepareBaseData} and {@linkcode prepareDerivedData} instead of this function
+   * directly, but some systems with more complicated calculations may want to override this function to add extra
+   * steps, such as to calculate certain item values after actor data prep.
    */
   prepareData(): void;
 
   /**
    * Prepare data related to this Document itself, before any embedded Documents or derived data is computed.
+   *
+   * If possible when modifying the `system` object you should use {@linkcode foundry.abstract.TypeDataModel.prepareBaseData | TypeDataModel#prepareBaseData} on
+   * your data models instead of this method directly on the document.
    */
   prepareBaseData(): void;
 
@@ -497,11 +517,16 @@ declare const _ClientDocument: _ClientDocumentType;
 // FIXME(LukeAbby): Unlike most mixins, `ClientDocumentMixin` actually requires a specific constructor, the same as `Document`.
 // This means that `BaseClass extends Document.Internal.Constructor` is actually too permissive.
 // However this easily leads to circularities.
-declare function ClientDocumentMixin<BaseClass extends Document.Internal.Constructor>(
+declare function ClientDocumentMixin<BaseClass extends ClientDocumentMixin.BaseClass>(
   Base: BaseClass,
 ): ClientDocumentMixin.Mix<BaseClass>;
 
 declare namespace ClientDocumentMixin {
+  interface AnyMixedConstructor extends ReturnType<typeof foundry.documents.abstract.ClientDocumentMixin<BaseClass>> {}
+  interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
+
+  type BaseClass = Document.Internal.Constructor;
+
   type Mix<BaseClass extends Document.Internal.Constructor> = Mixin<
     typeof InternalClientDocument<Document.NameFor<BaseClass>>,
     BaseClass

package/src/foundry/client/documents/actor.d.mts

@@ -696,8 +696,9 @@ declare class Actor<out SubType extends Actor.SubType = Actor.SubType> extends f
   protected override _configure(options?: Document.ConfigureOptions): void;
 
   /**
-   * Maintain a list of Token Documents that represent this Actor, stored by Scene.
-   * @remarks Doesn't exist prior to being `defineProperty`'d in {@link Actor._configure | `Actor#_configure`}
+   * Maintain a list of Token Documents that represent this Actor, stored by Scene. This list may include unpersisted
+   * Token Documents (along with possibly unpersisted parent Scenes), including those with a null `_id`.
+   * @remarks `defineProperty`'d at construction with no options specified
    */
   protected _dependentTokens?: foundry.utils.IterableWeakMap<
     Scene.Implementation,