@league-of-foundry-developers/foundry-vtt-types 13.346.0-beta.20250901211521 → 13.346.0-beta.20250902042249

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.20250901211521",
+  "version": "13.346.0-beta.20250902042249",
   "description": "TypeScript type definitions for Foundry VTT",
   "type": "module",
   "types": "./src/index.d.mts",

package/src/foundry/client/helpers/interaction/client-keybindings.d.mts

@@ -1,4 +1,4 @@
-import type { Brand, Identity, InexactPartial } from "#utils";
+import type { Identity, InexactPartial, ValueOf } from "#utils";
 import type KeyboardManager from "./keyboard-manager.d.mts";
 
 /**
@@ -407,22 +407,22 @@ declare namespace ClientKeybindings {
    */
   interface ActionComparison extends Pick<KeybindingAction, "precedence" | "order"> {}
 
-  type MOVEMENT_DIRECTIONS = Brand<string, "ClientKeybindings.MOVEMENT_DIRECTIONS">;
+  type MOVEMENT_DIRECTIONS = ValueOf<MovementDirections>;
 
   interface MovementDirections {
-    UP: "up" & MOVEMENT_DIRECTIONS;
-    LEFT: "left" & MOVEMENT_DIRECTIONS;
-    DOWN: "down" & MOVEMENT_DIRECTIONS;
-    RIGHT: "right" & MOVEMENT_DIRECTIONS;
-    DESCEND: "descend" & MOVEMENT_DIRECTIONS;
-    ASCEND: "ascend" & MOVEMENT_DIRECTIONS;
+    UP: "up";
+    LEFT: "left";
+    DOWN: "down";
+    RIGHT: "right";
+    DESCEND: "descend";
+    ASCEND: "ascend";
   }
 
-  type ZOOM_DIRECTIONS = Brand<string, "ClientKeybindings.ZOOM_DIRECTIONS">;
+  type ZOOM_DIRECTIONS = ValueOf<ZoomDirections>;
 
   interface ZoomDirections {
-    IN: "in" & ZOOM_DIRECTIONS;
-    OUT: "out" & ZOOM_DIRECTIONS;
+    IN: "in";
+    OUT: "out";
   }
 }
 

package/src/foundry/client/helpers/interaction/tooltip-manager.d.mts

@@ -1,4 +1,4 @@
-import type { Brand, Identity, InexactPartial, IntentionalPartial } from "#utils";
+import type { Identity, InexactPartial, IntentionalPartial, ValueOf } from "#utils";
 
 /**
  * A singleton Tooltip Manager class responsible for rendering and positioning a dynamic tooltip element which is
@@ -164,14 +164,14 @@ declare namespace TooltipManager {
   /**
    * The directions in which a tooltip can extend, relative to its tool-tipped element.
    */
-  type TOOLTIP_DIRECTIONS = Brand<string, "TooltipManager.TOOLTIP_DIRECTIONS">;
+  type TOOLTIP_DIRECTIONS = ValueOf<TooltipDirections>;
 
   interface TooltipDirections {
-    UP: "UP" & TOOLTIP_DIRECTIONS;
-    DOWN: "DOWN" & TOOLTIP_DIRECTIONS;
-    LEFT: "LEFT" & TOOLTIP_DIRECTIONS;
-    RIGHT: "RIGHT" & TOOLTIP_DIRECTIONS;
-    CENTER: "CENTER" & TOOLTIP_DIRECTIONS;
+    UP: "UP";
+    DOWN: "DOWN";
+    LEFT: "LEFT";
+    RIGHT: "RIGHT";
+    CENTER: "CENTER";
   }
 
   /** @internal */

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

@@ -3,7 +3,11 @@
 // While `.mts` could work, to avoid `import-x/no-unresolved` from erroring `.mjs` is used.
 /* eslint-disable import-x/extensions */
 
+/** @privateRemarks Foundry does an import then separate re-export for use in the body of {@linkcode registerTours}, not necessary on our side */
 export * as tours from "./tours/_module.mjs";
 export { default as Tour } from "./tour.mjs";
 export { default as NewUserExperienceManager } from "./nue-manager.mjs";
 export { default as ToursCollection } from "./tours-collection.mjs";
+
+/** Register core Tours. */
+export function registerTours(): Promise<void>;

package/src/foundry/client/nue/nue-manager.d.mts

@@ -10,7 +10,30 @@ declare class NewUserExperienceManager {
    */
   initialize(): void;
 
-  #private: true;
+  /** @deprecated Made hard private in v13. This warning will be removed in v14. */
+  protected _createInitialChatMessages(): never;
+
+  /**
+   * Create a default scene for the new world.
+   * @param sceneData - Additional data to merge with the default scene
+   * @returns The created default scene
+   * @remarks Creates the default scene with `{keepId: true}`, will be `"NUEDEFAULTSCENE0"` unless overwritten in `sceneData`
+   */
+  createDefaultScene(sceneData?: Scene.UpdateData): Promise<Scene.Implementation>;
+
+  /** @deprecated Made hard private in v13. This warning will be removed in v14. */
+  protected _showNewWorldTour(): never;
+
+  /** @deprecated Made hard private in v13. This warning will be removed in v14. */
+  protected _activateListeners(): never;
+
+  /** @deprecated Made hard private in v13. This warning will be removed in v14. */
+  protected _onActionLink(): never;
+
+  /** @deprecated Made hard private in v13. This warning will be removed in v14. */
+  protected _onTabLink(): never;
+
+  #NewUserExperienceManager: true;
 }
 
 declare namespace NewUserExperienceManager {}

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

@@ -1,4 +1,6 @@
-import type { ValueOf } from "#utils";
+import type { Identity, InexactPartial, ValueOf } from "#utils";
+import type { ClientKeybindings, TooltipManager } from "#client/helpers/interaction/_module.d.mts";
+import type { Localization } from "#client/helpers/_module.d.mts";
 
 /**
  * A Tour that shows a series of guided steps.
@@ -11,7 +13,8 @@ declare class Tour {
    */
   constructor(config: Tour.Config, options?: Tour.ConstructorOptions);
 
-  static STATUS: Tour.STATUS;
+  /** @remarks Frozen */
+  static STATUS: Tour.Status;
 
   /**
    * Indicates if a Tour is currently in progress.
@@ -21,13 +24,14 @@ declare class Tour {
   /**
    * Returns the active Tour, if any
    */
-  static get activeTour(): Tour | null;
+  static get activeTour(): Tour.Any | null;
 
   /**
    * Handle a movement action to either progress or regress the Tour
    * @param movementDirections - The Directions being moved in
+   * @remarks This method's one call in core is by full path name inside `ClientKeybindings##onPan`, so extending in subclasses has no effect
    */
-  static onMovementAction(movementDirections: string[]): true | void;
+  static onMovementAction(movementDirections: ClientKeybindings.MOVEMENT_DIRECTIONS[]): true | void;
 
   /**
    * Configuration of the tour. This object is cloned to avoid mutating the original configuration.
@@ -36,6 +40,7 @@ declare class Tour {
 
   /**
    * The HTMLElement which is the focus of the current tour step.
+   * @remarks Only `undefined` prior to Tour {@linkcode start}
    */
   targetElement: HTMLElement | undefined | null;
 
@@ -111,7 +116,7 @@ declare class Tour {
 
   /**
    * Return whether this Tour is currently eligible to be started?
-   * This is useful for tours which can only be used in certain circumnstances, like if the canvas is active.
+   * This is useful for tours which can only be used in certain circumstances, like if the canvas is active.
    */
   get canStart(): boolean;
 
@@ -153,6 +158,8 @@ declare class Tour {
   /**
    * Progresses to a given Step
    * @param stepIndex - The step to progress to
+   * @remarks
+   * @throws If `stepIndex` is outside the range `[0, this.steps.length]`
    */
   progress(stepIndex: number): Promise<void>;
 
@@ -168,17 +175,22 @@ declare class Tour {
    * @param filepath - The path to the JSON file
    * @remarks Returns `new this()` so needs an override per subclass.
    */
-  static fromJSON(filepath: string): Promise<Tour>;
+  static fromJSON(filepath: string): Promise<Tour.Any>;
 
   /**
    * Set-up operations performed before a step is shown.
    * @abstract
+   * @remarks Despite being marked `@abstract`, the base implementation is a no-op and doesn't throw.
+   * Implementation is therefor *not* required by subclasses, but most probably will do so anyway
    */
   protected _preStep(): Promise<void>;
 
   /**
    * Clean-up operations performed after a step is completed.
    * @abstract
+   * @remarks Despite being marked `@abstract`, the base implementation is a method with a real body
+   * and doesn't throw. Implementation is therefor *not* required by subclasses; none of core's  do,
+   * and any that do must call `super._postStep()` in them
    */
   protected _postStep(): Promise<void>;
 
@@ -187,90 +199,120 @@ declare class Tour {
    */
   protected _renderStep(): Promise<void>;
 
+  /** @deprecated Made hard private in v13. This warning will be removed in v14. */
+  protected _onButtonClick(event: never, buttons: never): never;
+
+  /** @deprecated Made hard private in v13. This warning will be removed in v14. */
+  protected _saveProgress(): never;
+
+  /** @deprecated Made hard private in v13. This warning will be removed in v14. */
+  protected _loadProgress(): never;
+
   /**
    * Reloads the Tour's current step from the saved progress
    * @internal
    */
   _reloadProgress(): void;
 
-  #tour: true;
+  #Tour: true;
 }
 
 declare namespace Tour {
-  /** Tour configuration data */
-  interface Config {
-    /** The namespace this Tour belongs to. Typically, the name of the package which implements the tour should be used */
-    namespace: string;
-
-    /** A machine-friendly id of the Tour, must be unique within the provided namespace */
-    id: string;
-
-    /** A human-readable name for this Tour. Localized. */
-    title: string;
-
-    /** The list of Tour Steps */
-    steps: Tour.Step[];
+  interface Any extends AnyTour {}
+  interface AnyConstructor extends Identity<typeof AnyTour> {}
 
+  /** @internal */
+  type _Config = InexactPartial<{
     /** A human-readable description of this Tour. Localized. */
-    description?: string | undefined;
+    description: string;
 
     /** A map of localizations for the Tour that should be merged into the default localizations */
-    localization?: foundry.helpers.Localization.Translations | undefined;
+    localization: Localization.Translations;
 
     /** Whether the Tour is restricted to the GM only. Defaults to false. */
-    restricted?: boolean | undefined;
+    restricted: boolean;
 
     /** Whether the Tour should be displayed in the Manage Tours UI. Defaults to false. */
-    display?: boolean | undefined;
+    display: boolean;
 
     /** Whether the Tour can be resumed or if it always needs to start from the beginning. Defaults to false. */
-    canBeResumed?: boolean | undefined;
+    canBeResumed: boolean;
 
-    /** A list of namespaced Tours that might be suggested to the user when this Tour is completed. The first non-completed Tour in the array will be recommended. */
-    suggestedNextTours?: string[] | undefined;
-  }
+    /**
+     * A list of namespaced Tours that might be suggested to the user when this Tour is completed. The first non-completed Tour in the array will be recommended.
+     * @remarks e.g. `["core.welcome"]`
+     */
+    suggestedNextTours: string[];
+  }>;
 
-  /** A step in a Tour */
-  interface Step {
-    /** A machine-friendly id of the Tour Step */
+  /** Tour configuration data */
+  interface Config extends _Config {
+    /**
+     * The namespace this Tour belongs to. Typically, the name of the package which implements the tour should be used
+     * @remarks Technically not required as long as the Tour is only constructed to be immediately passed
+     * {@linkcode foundry.nue.ToursCollection.register | ToursCollection#register}, which will use its argument instead.
+     * Core relies on this for all their tour definitions in `public/tours/*.json`, but it's safer and simpler from the
+     * types perspective to leave it required, as per their typedef
+     */
+    namespace: string;
+
+    /**
+     * A machine-friendly id of the Tour, must be unique within the provided namespace
+     * @remarks Technically not required as long as the Tour is only constructed to be immediately passed
+     * {@linkcode foundry.nue.ToursCollection.register | ToursCollection#register}, which will use its argument instead.
+     * Core relies on this for all their tour definitions in `public/tours/*.json`, but it's safer and simpler from the
+     * types perspective to leave it required, as per their typedef
+     */
     id: string;
 
-    /** The title of the step, displayed in the tooltip header */
+    /**
+     * A human-readable name for this Tour. Localized.
+     * @remarks As in, "this gets localized", not "must be passed pre-localized"
+     */
     title: string;
 
-    /** Raw HTML content displayed during the step */
-    content: string;
+    /** The list of Tour Steps */
+    steps: Tour.Step[];
+  }
 
+  /** @internal */
+  type _Step = InexactPartial<{
     /** A DOM selector which denotes an element to highlight during this step. If omitted, the step is displayed in the center of the screen. */
-    selector?: string | undefined;
+    selector: string;
 
     /** How the tooltip for the step should be displayed relative to the target element. If omitted, the best direction will be attempted to be auto-selected. */
-    tooltipDirection?: foundry.helpers.interaction.TooltipManager.TOOLTIP_DIRECTIONS | undefined;
+    tooltipDirection: TooltipManager.TOOLTIP_DIRECTIONS;
 
     /** Whether the Step is restricted to the GM only. Defaults to false. */
-    restricted?: boolean | undefined;
+    restricted: boolean;
+  }>;
 
-    /** Activates a particular sidebar tab. Usable in `SidebarTour` instances. */
-    sidebarTab?: string | undefined;
+  /** A step in a Tour */
+  interface Step extends _Step {
+    /** A machine-friendly id of the Tour Step */
+    id: string;
 
-    /** Activates a particular canvas layer and its respective control group. Usable in `CanvasTour` instances */
-    layer?: string | undefined;
+    /** The title of the step, displayed in the tooltip header */
+    title: string;
 
-    /** Activates a particular tool. Usable in `CanvasTour` instances. */
-    tool?: string | undefined;
+    /** Raw HTML content displayed during the step */
+    content: string;
   }
 
-  type Status = ValueOf<STATUS>;
+  type STATUS = ValueOf<Status>;
 
-  interface ConstructorOptions {
-    /** A tour ID that supercedes `TourConfig#id` */
+  /** @internal */
+  type _ConstructorOptions = InexactPartial<{
+    /** A tour ID that supersedes `TourConfig#id` */
     id: string;
 
-    /** A tour namespace that supercedes `TourConfig#namespace` */
+    /** A tour namespace that supersedes `TourConfig#namespace` */
     namespace: string;
-  }
+  }>;
+
+  interface ConstructorOptions extends _ConstructorOptions {}
 
-  interface STATUS {
+  interface Status {
     readonly UNSTARTED: "unstarted";
     readonly IN_PROGRESS: "in-progress";
     readonly COMPLETED: "completed";
@@ -278,3 +320,7 @@ declare namespace Tour {
 }
 
 export default Tour;
+
+declare abstract class AnyTour extends Tour {
+  constructor(...args: never);
+}

package/src/foundry/client/nue/tours/canvas-tour.d.mts

@@ -1,15 +1,55 @@
-import type Tour from "../tour.mjs";
+import type { Identity, InexactPartial } from "#utils";
+import type { Tour } from "#client/nue/_module.d.mts";
+import type { SceneControls } from "#client/applications/ui/_module.d.mts";
 
 /**
  * A tour for demonstrating an aspect of Canvas functionality.
  * Automatically activates a certain canvas layer or tool depending on the needs of the step.
  */
 declare class CanvasTour extends Tour {
+  /** @privateRemarks Fake type override */
+  constructor(config: CanvasTour.Config, options?: Tour.ConstructorOptions);
+
+  /** @privateRemarks Fake type override */
+  override config: CanvasTour.Config;
+
   override start(): Promise<void>;
+
   override get canStart(): boolean;
+
+  /** @privateRemarks Fake type override */
+  static override fromJSON(filepath: string): Promise<CanvasTour.Any>;
+
   protected override _preStep(): Promise<void>;
+
+  #CanvasTour: true;
 }
 
-declare namespace CanvasTour {}
+declare namespace CanvasTour {
+  interface Any extends AnyCanvasTour {}
+  interface AnyConstructor extends Identity<typeof AnyCanvasTour> {}
+
+  interface Config extends Tour.Config {
+    steps: CanvasTour.Step[];
+  }
+
+  /** @internal */
+  type _Step = InexactPartial<{
+    /**
+     * Activates a particular canvas layer and its respective control group. Usable in `CanvasTour` instances
+     * @privateRemarks This is just `string` for now, but we may narrow the controls type to only configured values in future
+     */
+    layer: keyof SceneControls["controls"];
+
+    /** Activates a particular tool. Usable in `CanvasTour` instances. */
+    tool: string;
+  }>;
+
+  interface Step extends Tour.Step, _Step {}
+}
 
 export default CanvasTour;
+
+declare abstract class AnyCanvasTour extends CanvasTour {
+  constructor(...args: never);
+}

package/src/foundry/client/nue/tours/setup-tour.d.mts

@@ -1,31 +1,54 @@
-import type Tour from "../tour.mjs";
+import type { Identity, InexactPartial } from "#utils";
+import type { Tour } from "#client/nue/_module.d.mts";
+import type { Application } from "#client/appv1/api/_module.d.mts";
+import type { ApplicationV2 } from "#client/applications/api/_module.d.mts";
 
 /**
  * A Tour subclass that handles controlling the UI state of the Setup screen
  */
 declare class SetupTour extends Tour {
+  /** @privateRemarks Fake type override */
   constructor(config: SetupTour.Config, options?: Tour.ConstructorOptions);
 
+  /** @privateRemarks Fake type override */
+  config: SetupTour.Config;
+
   /**
    * Stores a currently open Application for future steps
    */
-  focusedApp: foundry.appv1.api.Application.Any | foundry.applications.api.ApplicationV2.Any;
+  focusedApp: Application.Any | ApplicationV2.Any;
 
   override get canStart(): boolean;
+
+  /** @remarks Removes the GM check, as 'A user is always "GM" for Setup Tours' */
   override get steps(): Tour.Step[];
+
+  /** @privateRemarks Fake type override */
+  static override fromJSON(filepath: string): Promise<SetupTour.Any>;
+
   protected override _preStep(): Promise<void>;
 
-  #setupTour: true;
+  #SetupTour: true;
 }
 
 declare namespace SetupTour {
-  interface Config extends Tour.Config {
+  interface Any extends AnySetupTour {}
+  interface AnyConstructor extends Identity<typeof AnySetupTour> {}
+
+  /** @internal */
+  type _Config = InexactPartial<{
     /**
      * Whether to close all open windows before beginning the tour.
-     * @defaultValue `true`
+     * @remarks Checked for `!== false`, so effectively defaults `true`
      */
     closeWindows: boolean;
-  }
+  }>;
+
+  interface Config extends Tour.Config, _Config {}
 }
 
 export default SetupTour;
+
+declare abstract class AnySetupTour extends SetupTour {
+  constructor(...args: never);
+}

package/src/foundry/client/nue/tours/sidebar-tour.d.mts

@@ -1,13 +1,46 @@
+import type { Identity, InexactPartial } from "#utils";
 import type Tour from "../tour.mjs";
 
 /**
  * A Tour subclass for the Sidebar Tour
  */
 declare class SidebarTour extends Tour {
+  /** @privateRemarks Fake type override */
+  constructor(config: SidebarTour.Config, options?: Tour.ConstructorOptions);
+
+  /** @privateRemarks Fake type override */
+  override config: SidebarTour.Config;
+
   override start(): Promise<void>;
+
+  /** @privateRemarks Fake type override */
+  static override fromJSON(filepath: string): Promise<SidebarTour.Any>;
+
   protected override _preStep(): Promise<void>;
 }
 
-declare namespace SidebarTour {}
+declare namespace SidebarTour {
+  interface Any extends AnySidebarTour {}
+  interface AnyConstructor extends Identity<typeof AnySidebarTour> {}
+
+  /** @internal */
+  type _Step = InexactPartial<{
+    /**
+     * Activates a particular sidebar tab. Usable in {@linkcode SidebarTour} instances.
+     * @remarks {@linkcode SidebarTour._preStep | SidebarTour#_preStep} does `await ui[this.currentStep.sidebarTab]?.activate();`
+     */
+    sidebarTab: keyof typeof ui;
+  }>;
+
+  interface Step extends Tour.Step, _Step {}
+
+  interface Config extends Tour.Config {
+    steps: SidebarTour.Step[];
+  }
+}
 
 export default SidebarTour;
+
+declare abstract class AnySidebarTour extends SidebarTour {
+  constructor(...args: never);
+}

package/src/foundry/client/nue/tours-collection.d.mts

@@ -2,8 +2,10 @@ import type Tour from "./tour.d.mts";
 
 /**
  * A singleton Tour Collection class responsible for registering and activating Tours, accessible as game.tours.
+ * @remarks
+ * @throws If {@linkcode game.tours} is already constructed
  */
-declare class ToursCollection extends Collection<Tour> {
+declare class ToursCollection extends Collection<Tour.Any> {
   constructor();
 
   /**
@@ -11,13 +13,17 @@ declare class ToursCollection extends Collection<Tour> {
    * @param namespace - The namespace of the Tour
    * @param id        - The machine-readable id of the Tour
    * @param tour      - The constructed Tour
+   * @remarks
+   * @throws If a Tour with this `namespace`/`id` combination has already been registered
    */
-  register(namespace: string, id: string, tour: Tour): void;
+  register(namespace: string, id: string, tour: Tour.Any): void;
 
   /**
    * Set a Tour to the collection.
+   * @remarks Only checks to throw or not then calls super
+   * @throws If `key` doesn't match the Tour's `namespace` and `id`
    */
-  set(key: string, tour: Tour): this;
+  set(key: string, tour: Tour.Any): this;
 }
 
 declare namespace ToursCollection {}