@league-of-foundry-developers/foundry-vtt-types 13.340.0 → 13.340.1

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

@@ -1,8 +1,8 @@
-import type Document from "../../common/abstract/document.d.mts";
+export {};
 
 declare global {
   /**
-   * A singleton class {@link game#time} which keeps the official Server and World time stamps.
+   * A singleton class {@link game.time | `game#time`} which keeps the official Server and World time stamps.
    * Uses a basic implementation of https://www.geeksforgeeks.org/cristians-algorithm/ for synchronization.
    */
   class GameTime {
@@ -48,7 +48,10 @@ declare global {
      * @param options - Additional options passed to game.settings.set
      * @returns The new game time
      */
-    advance(seconds: number, options?: Document.OnUpsertOptions<"Setting">): Promise<number>;
+    advance(
+      seconds: number,
+      options?: Setting.Database.CreateOperation<false | undefined> | Setting.Database.UpdateOperation,
+    ): Promise<number>;
 
     /**
      * Synchronize the local client game time with the official time kept by the server

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

@@ -5,7 +5,7 @@ declare global {
    * A singleton Tooltip Manager class responsible for rendering and positioning a dynamic tooltip element which is
    * accessible as `game.tooltip`.
    *
-   * @see {@link Game.tooltip}
+   * @see {@link Game.tooltip | `Game.tooltip`}
    *
    * @example API Usage
    * ```typescript

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

@@ -3,65 +3,71 @@ import type { ValueOf } from "fvtt-types/utils";
 export { Tour };
 
 declare global {
-  /** A step in a Tour */
-  interface TourStep {
-    /** A machine-friendly id of the Tour Step */
-    id: string;
+  /** @deprecated {@link Tour.Step | `Tour.Step`} */
+  type TourStep = Tour.Step;
 
-    /** A DOM selector which denotes an element to highlight during this step */
-    selector?: string;
+  /** @deprecated {@link Tour.Config | `Tour.Config`} */
+  type TourConfig = Tour.Config;
 
-    /** The title of the step, displayed in the tooltip header */
-    title: string;
+  namespace Tour {
+    type STATUS = ValueOf<typeof Tour.STATUS>;
 
-    /** Raw HTML content displayed during the step */
-    content: string;
+    /** A step in a Tour */
+    interface Step {
+      /** A machine-friendly id of the Tour Step */
+      id: string;
 
-    /** How the tooltip for the step should be displayed relative to the target elemen */
-    tooltipDirection?: TooltipManager.TOOLTIP_DIRECTIONS;
+      /** A DOM selector which denotes an element to highlight during this step */
+      selector?: string;
 
-    /** Whether the Step is restricted to the GM only */
-    restricted?: boolean;
-  }
+      /** The title of the step, displayed in the tooltip header */
+      title: string;
 
-  /** Tour configuration data */
-  interface TourConfig {
-    /** The namespace this Tour belongs to. Typically, the name of the package which implements the tour should be used */
-    namespace?: string;
+      /** Raw HTML content displayed during the step */
+      content: string;
 
-    /** A machine-friendly id of the Tour, must be unique within the provided namespace */
-    id?: string;
+      /** How the tooltip for the step should be displayed relative to the target elemen */
+      tooltipDirection?: TooltipManager.TOOLTIP_DIRECTIONS;
 
-    /** A human-readable name for this Tour */
-    title: string;
+      /** Whether the Step is restricted to the GM only */
+      restricted?: boolean;
+    }
 
-    /** A human-readable description of this Tour */
-    description?: string;
+    /** 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;
 
-    /** The list of Tour Steps */
-    steps: TourStep[];
+      /** A machine-friendly id of the Tour, must be unique within the provided namespace */
+      id?: string;
 
-    /** A map of translations for the Tour that should be merged into the default translations */
-    localization?: Localization.Translations;
+      /** A human-readable name for this Tour */
+      title: string;
 
-    /** Whether the Tour is restricted to the GM only */
-    restricted?: boolean;
+      /** A human-readable description of this Tour */
+      description?: string;
 
-    /** Whether the Tour should be displayed in the Manage Tours UI */
-    display?: boolean;
+      /** The list of Tour Steps */
+      steps: Tour.Step[];
 
-    /** Whether the Tour can be resumed or if it always needs to start from the beginning */
-    canBeResumed?: boolean;
+      /** A map of translations for the Tour that should be merged into the default translations */
+      localization?: Localization.Translations;
 
-    /**
-     * 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[];
-  }
+      /** Whether the Tour is restricted to the GM only */
+      restricted?: boolean;
 
-  namespace Tour {
-    type STATUS = ValueOf<typeof Tour.STATUS>;
+      /** Whether the Tour should be displayed in the Manage Tours UI */
+      display?: boolean;
+
+      /** Whether the Tour can be resumed or if it always needs to start from the beginning */
+      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[];
+    }
   }
 
   /**
@@ -71,11 +77,14 @@ declare global {
     /**
      * @param config - The configuration of the Tour
      */
-    constructor(config: TourConfig, { id, namespace }?: { id?: TourConfig["id"]; namespace?: TourConfig["namespace"] });
+    constructor(
+      config: Tour.Config,
+      { id, namespace }?: { id?: Tour.Config["id"]; namespace?: Tour.Config["namespace"] },
+    );
     /**
      * The configuration of the tour. Cloned to avoid mutating the original configuration.
      */
-    config: TourConfig;
+    config: Tour.Config;
 
     static STATUS: Readonly<{
       UNSTARTED: "unstarted";
@@ -152,12 +161,12 @@ declare global {
     /**
      * The configuration of tour steps
      */
-    get steps(): TourStep[];
+    get steps(): Tour.Step[];
 
     /**
      * Return the current Step, or null if the tour has not yet started.
      */
-    get currentStep(): TourStep | null;
+    get currentStep(): Tour.Step | null;
 
     /**
      * The index of the current step; -1 if the tour has not yet started, or null if the tour is finished.
@@ -165,12 +174,12 @@ declare global {
     get stepIndex(): number | null;
 
     /**
-     * Returns True if there is a next TourStep
+     * Returns True if there is a next Tour.Step
      */
     get hasNext(): boolean;
 
     /**
-     * Returns True if there is a previous TourStep
+     * Returns True if there is a previous Tour.Step
      */
     get hasPrevious(): boolean;
 

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

@@ -3,7 +3,7 @@ export {};
 declare global {
   /**
    * A singleton Tour Collection class responsible for registering and activating Tours, accessible as game.tours
-   * @see {@link Game.tours}
+   * @see {@link Game.tours | `Game.tours`}
    */
   class Tours extends foundry.utils.Collection<Tour> {
     /** @throws `"You can only have one TourManager instance"` */

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

@@ -1,5 +1,5 @@
 import type { AnyObject, MustBeValidUuid } from "fvtt-types/utils";
-import type Document from "../../common/abstract/document.d.mts";
+import type Document from "#common/abstract/document.d.mts";
 
 declare const __Unset: unique symbol;
 
@@ -12,7 +12,7 @@ declare class InvalidUuid extends foundry.abstract.Document<any, any, any> {}
 type FromUuid<Uuid extends string> = Uuid extends `${string}.${string}.${infer Rest}`
   ? FromUuid<Rest>
   : Uuid extends `${infer DocumentType extends Document.Type}.${string}`
-    ? Document.ConfiguredInstanceForName<DocumentType>
+    ? Document.ImplementationFor<DocumentType>
     : InvalidUuid;
 
 // TODO(LukeAbby): The usage of `Document.Type` when it's unset will not be necessary once `Document.Any` is more type safe.
@@ -90,5 +90,5 @@ declare global {
    * @param documentName - The canonical Document name, for example "Actor"
    * @returns configured Document class implementation
    */
-  function getDocumentClass<Name extends Document.Type>(documentName: Name): Document.ConfiguredClassForName<Name>;
+  function getDocumentClass<Name extends Document.Type>(documentName: Name): Document.ImplementationClassFor<Name>;
 }

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

@@ -1,16 +1,11 @@
-import type { ValueOf } from "fvtt-types/utils";
+import type { AnyArray, ValueOf } from "fvtt-types/utils";
 
 // TODO: smarter types for named functions
 declare global {
-  interface WorkerTask {
-    [key: string]: unknown;
-
-    /** An incrementing task ID used to reference task progress */
-    taskId?: number;
-
-    /** The task action being performed, from WorkerManager.WORKER_TASK_ACTIONS */
-    action: ValueOf<typeof WorkerManager.WORKER_TASK_ACTIONS>;
-  }
+  /**
+   * @deprecated {@link AsyncWorker.WorkerTask | `AsyncWorker.WorkerTask`}
+   */
+  type WorkerTask = AsyncWorker.WorkerTask;
 
   /**
    * An asynchronous web Worker which can load user-defined functions and await execution using Promises.
@@ -18,7 +13,7 @@ declare global {
    * @param options - Worker initialization options (default: `{}`)
    */
   class AsyncWorker extends Worker {
-    constructor(name: string, options?: Partial<AsyncWorker.Options>);
+    constructor(name: string, options?: AsyncWorker.Options);
 
     name: string;
 
@@ -59,13 +54,25 @@ declare global {
      *                       (default: `[]`)
      * @returns A Promise which resolves with the returned result of the function once complete.
      */
-    executeFunction(functionName: string, args?: any[], transfer?: any[]): Promise<unknown>;
+    executeFunction(functionName: string, args?: AnyArray, transfer?: AnyArray): Promise<unknown>;
+  }
+
+  namespace AsyncWorker {
+    interface WorkerTask {
+      [key: string]: unknown;
+
+      /** An incrementing task ID used to reference task progress */
+      taskId?: number;
+
+      /** The task action being performed, from WorkerManager.WORKER_TASK_ACTIONS */
+      action: ValueOf<typeof WorkerManager.WORKER_TASK_ACTIONS>;
+    }
   }
 
   /**
    * A client-side class responsible for managing a set of web workers.
    * This interface is accessed as a singleton instance via game.workers.
-   * @see Game#workers
+   * @see {@link Game.workers | `Game#workers`}
    */
   class WorkerManager extends Map<string, AsyncWorker> {
     constructor();
@@ -89,7 +96,7 @@ declare global {
 
     /**
      * Retire a current Worker, terminating it immediately.
-     * @see {@link Worker#terminate}
+     * @see {@link Worker.terminate | `Worker#terminate`}
      * @param name - The named worker to terminate
      */
     retireWorker(name: string): void;
@@ -111,18 +118,18 @@ declare global {
        * Should the worker run in debug mode?
        * @defaultValue `false`
        */
-      debug: boolean;
+      debug?: boolean | undefined;
 
       /**
        * Should the worker automatically load the primitives library?
        * @defaultValue `false`
        */
-      loadPrimitives: boolean;
+      loadPrimitives?: boolean | undefined;
 
       /**
        * Should the worker operates in script modes? Optional scripts.
        */
-      scripts: string[];
+      scripts?: string[] | undefined;
     }
   }
 }

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

@@ -1,5 +1,5 @@
 import type { FixedInstanceType, Mixin } from "fvtt-types/utils";
-import type Document from "../../../common/abstract/document.d.mts";
+import type Document from "#common/abstract/document.d.mts";
 import type { InternalClientDocument } from "./client-document.d.mts";
 
 declare class CanvasDocument<
@@ -15,14 +15,14 @@ declare class CanvasDocument<
   /**
    * A lazily constructed PlaceableObject instance which can represent this Document on the game canvas.
    */
-  get object(): Document.ConfiguredObjectInstanceForName<PlaceableType> | null;
+  get object(): Document.ObjectFor<PlaceableType> | null;
 
   /**
    * A reference to the PlaceableObject instance which represents this Embedded Document.
    * @internal
    * @defaultValue `null`
    */
-  protected _object: Document.ConfiguredObjectInstanceForName<PlaceableType> | null;
+  protected _object: Document.ObjectFor<PlaceableType> | null;
 
   /**
    * Has this object been deliberately destroyed as part of the deletion workflow?
@@ -34,7 +34,7 @@ declare class CanvasDocument<
   /**
    * A reference to the CanvasLayer which contains Document objects of this type.
    */
-  get layer(): FixedInstanceType<PlaceablesLayer.ConfiguredClassForName<PlaceableType>>;
+  get layer(): PlaceablesLayer.ImplementationFor<PlaceableType>;
 
   /**
    * An indicator for whether this document is currently rendered on the game canvas.
@@ -48,33 +48,27 @@ declare class CanvasDocument<
 }
 
 declare namespace CanvasDocument {
-  type Any = CanvasDocument<any>;
+  interface Any extends CanvasDocument<any> {}
 }
 
 declare global {
   /**
    * A specialized sub-class of the ClientDocumentMixin which is used for document types that are intended to be represented upon the game Canvas.
    */
-  // TODO(LukeAbby): The constraint here should ideally be something like `Document<Document.PlaceableType, any, Scene.ConfiguredInstance | null>` but this causes circularities.
+  // TODO(LukeAbby): The constraint here should ideally be something like `Document<Document.PlaceableType, any, Scene.Implementation | null>` but this causes circularities.
   function CanvasDocumentMixin<BaseClass extends Document.Internal.Constructor>(
     Base: BaseClass,
-  ): typeof AnyDocument & Mixin<typeof CanvasDocument<FixedInstanceType<BaseClass>>, BaseClass>;
+  ): Mixin<typeof CanvasDocument<FixedInstanceType<BaseClass>>, BaseClass>;
 }
 
 // This is yet another `AnyDocument` type.
 // It exists specifically because the `Document.AnyConstructor` type is too safe to be merged in with a mixin.
-// The `arg0: never, ...args: never[]` trick trips up the base constructor check and so this one with an actual `...args: any[]` one is used instead.
+// The `...args: never` trick trips up the base constructor check and so this one with an actual `...args: any[]` one is used instead.
 //
 // `{}` is used to avoid merging `DataSchema` with the real schema.
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-declare class AnyDocument extends Document<any, {}, Document.Any | null> {
+declare class AnyDocument extends Document<Document.Type, {}, Document.Any | null> {
   constructor(...args: any[]);
 
-  // Note(LukeAbby): Specifically adding the `DocumentBrand` should be redundant but in practice it seems to help tsc more efficiently deduce that it's actually inheriting from `Document`.
-  // This is odd but probably is because it bails from looking up the parent class properties at times or something.
-  static [Document.Internal.DocumentBrand]: true;
-
-  flags?: unknown;
-
   getFlag(scope: never, key: never): any;
 }