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

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

@@ -1,9 +1,7 @@
-import type { ConformRecord } from "../../../types/helperTypes.d.mts";
-import type { AnyArray, AnyObject, DeepPartial, InexactPartial } from "../../../types/utils.d.mts";
+import type { AnyArray, AnyObject, InexactPartial, FixedInstanceType } from "#utils";
 import type ApplicationV2 from "../../client-esm/applications/api/application.d.mts";
 import type { CustomFormInput } from "../../client-esm/applications/forms/fields.d.mts";
 import type DataModel from "../../common/abstract/data.d.mts";
-import type Document from "../../common/abstract/document.d.mts";
 import type { DataField } from "../../common/data/fields.d.mts";
 
 declare global {
@@ -14,17 +12,17 @@ declare global {
    * When Foundry Virtual Tabletop is initialized, a singleton instance of this class is constructed within the global
    * Game object as as game.settings.
    *
-   * @see {@link Game#settings}
-   * @see {@link Settings}
-   * @see {@link SettingsConfig}
+   * @see {@link Game.settings | `Game#settings`}
+   * @see {@link Settings | `Settings`}
+   * @see {@link SettingsConfig | `SettingsConfig`}
    */
   class ClientSettings {
-    constructor(worldSettings?: Setting["_source"][]);
+    constructor(worldSettings?: Setting.Implementation["_source"][]);
 
     /**
      * A object of registered game settings for this scope
      */
-    settings: Map<keyof _SettingConfigRecord & string, ClientSettings.SettingConfig>;
+    settings: Map<keyof globalThis.SettingConfig & (string & {}), ClientSettings.SettingConfig>;
 
     /**
      * Registered settings menus which trigger secondary applications
@@ -87,11 +85,15 @@ declare global {
      * });
      * ```
      */
-    register<N extends ClientSettings.Namespace, K extends ClientSettings.Key, T extends ClientSettings.Type>(
+    register<
+      T extends ClientSettings.Type,
+      N extends ClientSettings.Namespace = ClientSettings.Namespace,
+      K extends ClientSettings.KeyFor<N> = ClientSettings.KeyFor<N>,
+    >(
       namespace: N,
       key: K,
       data: ClientSettings.Type extends T
-        ? ClientSettings.RegisterOptions<_SettingConfigRecord[`${N}.${K}`]>
+        ? ClientSettings.RegisterOptions<globalThis.SettingConfig[`${N}.${K}` & keyof SettingConfig]>
         : ClientSettings.RegisterOptions<NoInfer<T>>,
     ): void;
 
@@ -131,7 +133,7 @@ declare global {
      * game.settings.get("myModule", "myClientSetting");
      * ```
      */
-    get<N extends ClientSettings.Namespace, K extends ClientSettings.Key>(
+    get<N extends ClientSettings.Namespace, K extends ClientSettings.KeyFor<N>>(
       namespace: N,
       key: K,
     ): ClientSettings.SettingInitializedType<N, K>;
@@ -154,17 +156,17 @@ declare global {
      * game.settings.set("myModule", "myClientSetting", "b");
      * ```
      */
-    set<N extends ClientSettings.Namespace, K extends ClientSettings.Key>(
+    set<N extends ClientSettings.Namespace, K extends ClientSettings.KeyFor<N>>(
       namespace: N,
       key: K,
       value: ClientSettings.SettingAssignmentType<N, K>,
-      options?: Document.OnUpsertOptions<"Setting">,
+      options?: Setting.Database.CreateOperation<undefined | false> | Setting.Database.UpdateOperation,
     ): Promise<ClientSettings.SettingInitializedType<N, K>>;
   }
 
   namespace ClientSettings {
-    type Namespace = GetNamespaces<keyof _SettingConfigRecord>;
-    type Key = GetKeys<keyof _SettingConfigRecord>;
+    type Namespace = GetNamespaces<keyof globalThis.SettingConfig>;
+    type KeyFor<N extends Namespace> = GetKeys<N, keyof globalThis.SettingConfig>;
 
     /**
      * A compile type is a type for a setting that only exists at compile time.
@@ -187,14 +189,21 @@ declare global {
       | (T extends readonly (infer V)[] ? typeof Array<V> : never)
       | (T extends AnyObject ? typeof Object : never);
 
-    type SettingAssignmentType<N extends Namespace, K extends Key> = ToSettingAssignmentType<ConfiguredType<N, K>>;
+    type SettingAssignmentType<N extends Namespace, K extends KeyFor<N>> = ToSettingAssignmentType<
+      ConfiguredType<N, K>
+    >;
     type ToSettingAssignmentType<T extends Type> = ReplaceUndefinedWithNull<
       | SettingType<T>
       // TODO(LukeAbby): The `fromSource` function is called with `strict` which changes how fallback behaviour works. See `ClientSettings#set`
-      | (T extends DataModel.AnyConstructor ? DataModel.ConstructorDataFor<InstanceType<T>> : never)
+      // Note(LukeAbby): This doesn't use `InstanceType` because of this TypeScript issue: https://github.com/microsoft/TypeScript/issues/60839
+      | (T extends (abstract new (...args: infer _1) => infer Instance extends DataModel.Any)
+          ? DataModel.ConstructorDataFor<Instance>
+          : never)
     >;
 
-    type SettingInitializedType<N extends Namespace, K extends Key> = ToSettingInitializedType<ConfiguredType<N, K>>;
+    type SettingInitializedType<N extends Namespace, K extends KeyFor<N>> = ToSettingInitializedType<
+      ConfiguredType<N, K>
+    >;
     type ToSettingInitializedType<T extends Type> = ReplaceUndefinedWithNull<
       SettingType<T> | (T extends DataModel.Any ? T : never)
     >;
@@ -261,7 +270,7 @@ declare global {
     /**
      * A Client Setting
      * @remarks Copied from `resources/app/common/types.mjs`
-     * @remarks Not to be confused with {@link globalThis.SettingConfig} which is how you register setting types in this project
+     * @remarks Not to be confused with {@link globalThis.SettingConfig | `globalThis.SettingConfig`} which is how you register setting types in this project
      */
     interface SettingConfig<T extends Type = (value: unknown) => unknown>
       extends _SettingConfig<ToRuntimeType<T>, ToSettingAssignmentType<T>> {}
@@ -290,20 +299,36 @@ declare global {
       icon?: string | undefined;
 
       /** The FormApplication or ApplicationV2 to render */
-      type:
-        | (new () => FormApplication.Any)
-        | (new (options?: DeepPartial<ApplicationV2.Configuration>) => ApplicationV2.Any);
+      // In SettingsConfig#_onClickSubmenu this type is constructed and not given any options.
+      type: (new () => FormApplication.Any) | (new () => ApplicationV2.Any);
 
       /** If true, only a GM can edit this Setting */
       restricted?: boolean | undefined;
     }
 
-    type RegisterSubmenu = Omit<SettingSubmenuConfig, "key" | "namespace">;
+    interface RegisterSubmenu {
+      /** The human readable name */
+      name: string;
 
-    /**
-     * @deprecated - {@link globalThis.SettingConfig | `SettingConfig`}
-     */
-    interface Values extends globalThis.SettingConfig {}
+      /** The human readable label */
+      label: string;
+
+      /** An additional human readable hint */
+      hint: string;
+
+      /** The classname of an Icon to render */
+      icon: string;
+
+      /**
+       * The FormApplication class to render
+       *
+       * @privateRemarks The phrase "TODO better typing" in the original documentation was stripped.
+       */
+      type: (new () => FormApplication.Any) | (new () => ApplicationV2.Any);
+
+      /** If true, only a GM can edit this Setting */
+      restricted: boolean;
+    }
   }
 }
 
@@ -325,7 +350,7 @@ type PRIMITIVE_TYPES = readonly [
 // Foundry prioritizes the constructor over the function unless it's in `Setting#PRIMITIVE_TYPES`.
 type ConstructorToSettingType<T extends SettingConstructor> = T extends PRIMITIVE_TYPES[number]
   ? PrimitiveConstructorToSettingType<T>
-  : InstanceType<T>;
+  : FixedInstanceType<T>;
 
 // In theory this is just the `ReturnType<T>`.
 // However the function end of `Array` returns `any[]` while `Object` returns `any`.
@@ -336,15 +361,18 @@ type PrimitiveConstructorToSettingType<T extends PRIMITIVE_TYPES[number]> = T ex
     ? AnyObject
     : ReturnType<T>;
 
+// The `& keyof SettingConfig` is necessary because otherwise the fact that `K` depends on `N`
+// will confuse TypeScript and make it think that `${N}.${K}` can be invalid keys like
+// "core.moduleSetting" but in reality that would be disallowed by the dependent constraint of `K`.
 type ConfiguredType<
   N extends ClientSettings.Namespace,
-  K extends ClientSettings.Key,
-> = _SettingConfigRecord[`${N}.${K}`];
+  K extends ClientSettings.KeyFor<N>,
+> = globalThis.SettingConfig[`${N}.${K}` & keyof SettingConfig];
 
 type SettingType<T extends ClientSettings.Type> =
   // Note(LukeAbby): This isn't written as `T extends ClientSettings.TypeScriptType ? T : never` because then types like `DataField.Any` would be matched.
   | (T extends ClientSettings.RuntimeType ? never : T)
-  // TODO(LukeAbby): The `validate` function is called with `strict` which changes how fallback behaviour works. See `ClientSettings#set`
+  // TODO(LukeAbby): The `validate` function is called with `strict` which changes how fallback behavior works. See `ClientSettings#set`
   | (T extends DataField.Any ? DataField.AssignmentTypeFor<T> : never)
   | (T extends SettingConstructor ? ConstructorToSettingType<T> : T extends SettingFunction ? ReturnType<T> : never);
 
@@ -352,10 +380,6 @@ type SettingType<T extends ClientSettings.Type> =
 type ReplaceUndefinedWithNull<T> = T extends undefined ? null : T;
 
 type GetNamespaces<SettingPath extends PropertyKey> = SettingPath extends `${infer Scope}.${string}` ? Scope : never;
-type GetKeys<SettingPath extends PropertyKey> = SettingPath extends `${string}.${infer Name}` ? Name : never;
-
-type _SettingConfigRecord = ConformRecord<
-  // Refers to the deprecated interface so that merging works both ways.
-  ClientSettings.Values,
-  ClientSettings.Type
->;
+type GetKeys<N extends string, SettingPath extends PropertyKey> = SettingPath extends `${N}.${infer Name}`
+  ? Name
+  : never;

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

@@ -1,4 +1,4 @@
-import type { AnyObject } from "../../../types/utils.d.mts";
+import type { AnyObject } from "#utils";
 import type { DatabaseOperationMap, DocumentSocketRequest } from "../../common/abstract/_types.d.mts";
 
 declare global {
@@ -11,7 +11,7 @@ declare global {
      */
     static dispatch<DatabaseAction extends keyof DatabaseOperationMap>(
       eventName: string,
-      request: DocumentSocketRequest<DatabaseAction> | ManageCompendiumRequest,
+      request: DocumentSocketRequest<DatabaseAction> | CompendiumCollection.ManageCompendiumRequest,
     ): Promise<SocketInterface.SocketResponse>;
   }
 

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

@@ -1,4 +1,4 @@
-import type { InexactPartial } from "../../../types/utils.d.mts";
+export {};
 
 declare global {
   /**
@@ -25,7 +25,7 @@ declare global {
      */
     static performIntegerSort<T, SortKey extends string = "sort">(
       source: T,
-      options?: InexactPartial<SortingHelpers.SortOptions<T, SortKey>>,
+      options?: SortingHelpers.SortOptions<T, SortKey>,
     ): Array<{
       target: T;
       update: {
@@ -50,19 +50,19 @@ declare global {
        * The target object relative which to sort
        * @defaultValue `null`
        */
-      target: T | null;
+      target?: T | null | undefined;
 
       /**
        * The sorted Array of siblings which share the same sorted container
        * @defaultValue `[]`
        */
-      siblings: T[];
+      siblings?: T[] | undefined;
 
       /**
        * The name of the data property within the source object which defines the sort key
        * @defaultValue `"sort"`
        */
-      sortKey: SortKey;
+      sortKey?: SortKey | undefined;
 
       /**
        * Whether to explicitly sort before (true) or sort after (false). If nothing is passed
@@ -70,7 +70,7 @@ declare global {
        *
        * @defaultValue `true`
        */
-      sortBefore: boolean;
+      sortBefore?: boolean | undefined;
     }
   }
 }

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

@@ -1,11 +1,11 @@
-import type { ValueOf } from "../../../types/utils.d.mts";
+import type { ValueOf } from "#utils";
 
 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

@@ -1,67 +1,73 @@
-import type { ValueOf } from "../../../types/utils.d.mts";
+import type { ValueOf } from "#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,4 +1,29 @@
-import type { GetKey } from "../../../types/helperTypes.d.mts";
+import type { AnyObject, MustBeValidUuid } from "#utils";
+import type Document from "../../common/abstract/document.d.mts";
+
+declare const __Unset: unique symbol;
+
+type __UnsetDocument = Document.Any & {
+  [__Unset]: true;
+};
+
+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.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.
+type FromUuidValidate<
+  ConcreteDocument extends Document.Any,
+  Uuid extends string,
+> = __UnsetDocument extends ConcreteDocument
+  ? MustBeValidUuid<Uuid, Document.Type>
+  : string extends Uuid
+    ? string
+    : MustBeValidUuid<Uuid, ConcreteDocument["documentName"]>;
 
 declare global {
   /**
@@ -21,15 +46,15 @@ declare global {
    * @param uuid    - The uuid of the Entity or Embedded Entity to retrieve
    * @param options - Options to configure how a UUID is resolved.
    */
-  function fromUuid(
-    uuid: string,
+  function fromUuid<ConcreteDocument extends Document.Any = __UnsetDocument, const Uuid extends string = string>(
+    uuid: FromUuidValidate<ConcreteDocument, Uuid> | null | undefined,
     options?: {
       /** A Document to resolve relative UUIDs against. */
       relative?: ClientDocument;
       /** Allow retrieving an invalid Document. (default: `false`) */
       invalid?: boolean;
     },
-  ): Promise<foundry.abstract.Document.Any | null>;
+  ): Promise<(__UnsetDocument extends ConcreteDocument ? FromUuid<Uuid> : ConcreteDocument) | null>;
 
   /**
    * Retrieve a Document by its Universally Unique Identifier (uuid) synchronously. If the uuid resolves to a compendium
@@ -39,8 +64,8 @@ declare global {
    * @returns The Document or its index entry if it resides in a Compendium, otherwise null.
    * @throws If the uuid resolves to a Document that cannot be retrieved synchronously.
    */
-  function fromUuidSync(
-    uuid: string,
+  function fromUuidSync<ConcreteDocument extends Document.Any = __UnsetDocument, const Uuid extends string = string>(
+    uuid: FromUuidValidate<ConcreteDocument, Uuid> | null | undefined,
     options?: {
       /** A Document to resolve relative UUIDs against. */
       relative?: ClientDocument;
@@ -49,7 +74,7 @@ declare global {
       /** Throw an error if the UUID cannot be resolved synchronously. (default: `true`) */
       strict?: boolean;
     },
-  ): foundry.abstract.Document.Any | Record<string, unknown> | null;
+  ): (__UnsetDocument extends ConcreteDocument ? FromUuid<Uuid> : ConcreteDocument) | AnyObject | null;
 
   /**
    * Resolve a series of embedded document UUID parts against a parent Document.
@@ -65,7 +90,5 @@ declare global {
    * @param documentName - The canonical Document name, for example "Actor"
    * @returns configured Document class implementation
    */
-  function getDocumentClass<DocumentName extends string>(
-    documentName: DocumentName,
-  ): GetKey<GetKey<CONFIG, DocumentName, never>, "documentClass", undefined>;
+  function getDocumentClass<Name extends Document.Type>(documentName: Name): Document.ImplementationClassFor<Name>;
 }

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

@@ -1,4 +1,4 @@
-export {};
+import "youtube";
 
 declare global {
   /**

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

@@ -1,16 +1,11 @@
-import type { ValueOf } from "../../../types/utils.d.mts";
+import type { AnyArray, ValueOf } from "#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;
     }
   }
 }