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

package/src/foundry/client/pixi/webgl/shaders/samplers/base-sampler.d.mts

@@ -1,4 +1,4 @@
-import type { InexactPartial, Mixin } from "fvtt-types/utils";
+import type { Identity, InexactPartial, Mixin } from "fvtt-types/utils";
 
 declare class BatchPlugin<BaseSamplerShaderClass extends BaseSamplerShader.AnyConstructor> {
   /** @privateRemarks All mixin classses should accept anything for its constructor. */
@@ -56,7 +56,7 @@ declare global {
     /**
      * Pause or Unpause this sampler. If set to true, the shader is disabled. Otherwise, it is enabled.
      * Contrary to enabled, a shader might decide to refuse a pause, to continue to render animations per example.
-     * @see enabled
+     * @see {@link enabled | `enabled`}
      */
     get paused(): boolean;
 
@@ -184,7 +184,7 @@ declare global {
 
   namespace BaseSamplerShader {
     interface Any extends AnyBaseSamplerShader {}
-    type AnyConstructor = typeof AnyBaseSamplerShader;
+    interface AnyConstructor extends Identity<typeof AnyBaseSamplerShader> {}
 
     interface BatchGeometryData {
       id: string;
@@ -201,5 +201,5 @@ declare global {
 }
 
 declare abstract class AnyBaseSamplerShader extends BaseSamplerShader {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/webgl/shaders/samplers/baseline-illumination.d.mts

@@ -1,4 +1,4 @@
-export {};
+import type { Identity } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -30,10 +30,10 @@ declare global {
 
   namespace BaselineIlluminationSamplerShader {
     interface Any extends AnyBaselineIlluminationSamplerShader {}
-    type AnyConstructor = typeof AnyBaselineIlluminationSamplerShader;
+    interface AnyConstructor extends Identity<typeof AnyBaselineIlluminationSamplerShader> {}
   }
 }
 
 declare abstract class AnyBaselineIlluminationSamplerShader extends BaselineIlluminationSamplerShader {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/webgl/shaders/samplers/color-adjustment.d.mts

@@ -1,4 +1,4 @@
-export {};
+import type { Identity } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -55,7 +55,7 @@ declare global {
 
   namespace ColorAdjustmentsSamplerShader {
     interface Any extends AnyColorAdjustmentsSamplerShader {}
-    type AnyConstructor = typeof AnyColorAdjustmentsSamplerShader;
+    interface AnyConstructor extends Identity<typeof AnyColorAdjustmentsSamplerShader> {}
   }
 
   /**
@@ -105,14 +105,14 @@ declare global {
 
   namespace AmplificationSamplerShader {
     interface Any extends AnyAmplificationSamplerShader {}
-    type AnyConstructor = typeof AnyAmplificationSamplerShader;
+    interface AnyConstructor extends Identity<typeof AnyAmplificationSamplerShader> {}
   }
 }
 
 declare abstract class AnyColorAdjustmentsSamplerShader extends ColorAdjustmentsSamplerShader {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }
 
 declare abstract class AnyAmplificationSamplerShader extends AmplificationSamplerShader {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/webgl/shaders/samplers/depth.d.mts

@@ -1,4 +1,4 @@
-export {};
+import type { Identity } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -87,7 +87,7 @@ declare global {
 
   namespace DepthSamplerShader {
     interface Any extends AnyDepthSamplerShader {}
-    type AnyConstructor = typeof AnyDepthSamplerShader;
+    interface AnyConstructor extends Identity<typeof AnyDepthSamplerShader> {}
 
     /** @internal */
     type PartialPIXIBatchable = Pick<PIXI.IBatchableElement, "_texture" | "vertexData" | "indices" | "uvs">;
@@ -103,5 +103,5 @@ declare global {
 }
 
 declare abstract class AnyDepthSamplerShader extends DepthSamplerShader {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/webgl/shaders/samplers/fog-of-war.d.mts

@@ -1,4 +1,4 @@
-export {};
+import type { Identity } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -16,10 +16,10 @@ declare global {
 
   namespace FogSamplerShader {
     interface Any extends AnyFogSamplerShader {}
-    type AnyConstructor = typeof AnyFogSamplerShader;
+    interface AnyConstructor extends Identity<typeof AnyFogSamplerShader> {}
   }
 }
 
 declare abstract class AnyFogSamplerShader extends FogSamplerShader {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/webgl/shaders/samplers/occlusion.d.mts

@@ -1,4 +1,4 @@
-export {};
+import type { Identity } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -87,7 +87,7 @@ declare global {
 
   namespace OccludableSamplerShader {
     interface Any extends AnyOccludableSamplerShader {}
-    type AnyConstructor = typeof AnyOccludableSamplerShader;
+    interface AnyConstructor extends Identity<typeof AnyOccludableSamplerShader> {}
 
     /** @privateRemarks Unlike `DepthSamplerShader`, this class uses every `IBatchableElement` key */
     interface OccludableBatchData extends PIXI.IBatchableElement {
@@ -102,5 +102,5 @@ declare global {
 }
 
 declare abstract class AnyOccludableSamplerShader extends OccludableSamplerShader {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/webgl/shaders/samplers/primary.d.mts

@@ -1,8 +1,8 @@
-export {};
+import type { Identity } from "fvtt-types/utils";
 
 declare global {
   /**
-   * The base shader class of {@link PrimarySpriteMesh}.
+   * The base shader class of {@link PrimarySpriteMesh | `PrimarySpriteMesh`}.
    */
   class PrimaryBaseSamplerShader extends OccludableSamplerShader {
     /**
@@ -26,10 +26,10 @@ declare global {
 
   namespace PrimaryBaseSamplerShader {
     interface Any extends AnyPrimaryBaseSamplerShader {}
-    type AnyConstructor = typeof AnyPrimaryBaseSamplerShader;
+    interface AnyConstructor extends Identity<typeof AnyPrimaryBaseSamplerShader> {}
   }
 }
 
 declare abstract class AnyPrimaryBaseSamplerShader extends PrimaryBaseSamplerShader {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/webgl/shaders/samplers/token-ring.d.mts

@@ -1,7 +1,5 @@
-import type { NullishProps } from "../../../../../../utils/index.d.mts";
-import type TokenRing from "../../../../../client-esm/canvas/tokens/ring.d.mts";
-
-export {};
+import type { Identity, NullishProps } from "fvtt-types/utils";
+import type TokenRing from "#client-esm/canvas/tokens/ring.d.mts";
 
 declare global {
   /**
@@ -51,7 +49,7 @@ declare global {
 
   namespace TokenRingSamplerShader {
     interface Any extends AnyTokenRingSamplerShader {}
-    type AnyConstructor = typeof AnyTokenRingSamplerShader;
+    interface AnyConstructor extends Identity<typeof AnyTokenRingSamplerShader> {}
 
     /** @internal */
     type RingContainerObject = NullishProps<{
@@ -71,5 +69,5 @@ declare global {
 }
 
 declare abstract class AnyTokenRingSamplerShader extends TokenRingSamplerShader {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/webgl/shaders/vision/background-vision.d.mts

@@ -1,4 +1,4 @@
-export {};
+import type { Identity } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -34,10 +34,10 @@ declare global {
 
   namespace BackgroundVisionShader {
     interface Any extends AnyBackgroundVisionShader {}
-    type AnyConstructor = typeof AnyBackgroundVisionShader;
+    interface AnyConstructor extends Identity<typeof AnyBackgroundVisionShader> {}
   }
 }
 
 declare abstract class AnyBackgroundVisionShader extends BackgroundVisionShader {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/webgl/shaders/vision/base-vision.d.mts

@@ -1,4 +1,4 @@
-export {};
+import type { Identity } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -24,10 +24,10 @@ declare global {
 
   namespace AdaptiveVisionShader {
     interface Any extends AnyAdaptiveVisionShader {}
-    type AnyConstructor = typeof AnyAdaptiveVisionShader;
+    interface AnyConstructor extends Identity<typeof AnyAdaptiveVisionShader> {}
   }
 }
 
 declare abstract class AnyAdaptiveVisionShader extends AdaptiveVisionShader {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/webgl/shaders/vision/coloration-vision.d.mts

@@ -1,4 +1,4 @@
-export {};
+import type { Identity } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -33,10 +33,10 @@ declare global {
 
   namespace ColorationVisionShader {
     interface Any extends AnyColorationVisionShader {}
-    type AnyConstructor = typeof AnyColorationVisionShader;
+    interface AnyConstructor extends Identity<typeof AnyColorationVisionShader> {}
   }
 }
 
 declare abstract class AnyColorationVisionShader extends ColorationVisionShader {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/webgl/shaders/vision/effects/amplification.d.mts

@@ -1,4 +1,4 @@
-export {};
+import type { Identity } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -24,10 +24,10 @@ declare global {
 
   namespace AmplificationBackgroundVisionShader {
     interface Any extends AnyAmplificationBackgroundVisionShader {}
-    type AnyConstructor = typeof AnyAmplificationBackgroundVisionShader;
+    interface AnyConstructor extends Identity<typeof AnyAmplificationBackgroundVisionShader> {}
   }
 }
 
 declare abstract class AnyAmplificationBackgroundVisionShader extends AmplificationBackgroundVisionShader {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/webgl/shaders/vision/effects/wave.d.mts

@@ -1,4 +1,4 @@
-export {};
+import type { Identity } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -23,7 +23,7 @@ declare global {
 
   namespace WaveBackgroundVisionShader {
     interface Any extends AnyWaveBackgroundVisionShader {}
-    type AnyConstructor = typeof AnyWaveBackgroundVisionShader;
+    interface AnyConstructor extends Identity<typeof AnyWaveBackgroundVisionShader> {}
   }
 
   /**
@@ -48,14 +48,14 @@ declare global {
 
   namespace WaveColorationVisionShader {
     interface Any extends AnyWaveColorationVisionShader {}
-    type AnyConstructor = typeof AnyWaveColorationVisionShader;
+    interface AnyConstructor extends Identity<typeof AnyWaveColorationVisionShader> {}
   }
 }
 
 declare abstract class AnyWaveBackgroundVisionShader extends WaveBackgroundVisionShader {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }
 
 declare abstract class AnyWaveColorationVisionShader extends WaveColorationVisionShader {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/webgl/shaders/vision/illumination-vision.d.mts

@@ -1,4 +1,4 @@
-export {};
+import type { Identity } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -28,10 +28,10 @@ declare global {
 
   namespace IlluminationVisionShader {
     interface Any extends AnyIlluminationVisionShader {}
-    type AnyConstructor = typeof AnyIlluminationVisionShader;
+    interface AnyConstructor extends Identity<typeof AnyIlluminationVisionShader> {}
   }
 }
 
 declare abstract class AnyIlluminationVisionShader extends IlluminationVisionShader {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/webgl/shaders/weather/base-weather.d.mts

@@ -1,9 +1,4 @@
-import type {
-  InterfaceToObject,
-  AnyObject,
-  RemoveIndexSignatures,
-  FixedInstanceType,
-} from "../../../../../../utils/index.d.mts";
+import type { RemoveIndexSignatures, FixedInstanceType, Identity } from "fvtt-types/utils";
 
 type AbstractBaseShaderClass = typeof AbstractBaseShader;
 
@@ -17,16 +12,18 @@ declare const InternalAbstractWeatherShader_Const: InternalAbstractWeatherShader
 
 // @ts-expect-error - This pattern inherently requires a ts-expect-error as the base class is dynamic.
 class InternalAbstractWeatherShader<
-  DefaultUniforms extends AnyObject,
-  _ComputedUniforms extends object = RemoveIndexSignatures<Extract<DefaultUniforms, AnyObject>>,
+  DefaultUniforms extends AbstractBaseShader.Uniforms,
+  _ComputedUniforms extends object = RemoveIndexSignatures<DefaultUniforms>,
 > extends InternalAbstractWeatherShader_Const<_ComputedUniforms> {}
 
 declare global {
   /**
    * The base shader class for weather shaders.
+   * @typeParam DefaultUniforms - An interface representing an `AbstractWeatherShader` subclass's `static defaultUniforms`
+   * @remarks For each key in `static defaultOptions`, dynamically defines a getter/setter pair for `this.uniforms[key]` on the instance
    */
   class AbstractWeatherShader<
-    DefaultUniforms extends AnyObject = InterfaceToObject<AbstractWeatherShader.DefaultUniforms>,
+    DefaultUniforms extends AbstractBaseShader.Uniforms = AbstractWeatherShader.DefaultUniforms,
   > extends InternalAbstractWeatherShader<DefaultUniforms> {
     constructor(...args: ConstructorParameters<typeof AbstractBaseShader>);
 
@@ -49,7 +46,7 @@ declare global {
 
     static override create<ThisType extends AbstractBaseShader.AnyConstructor>(
       this: ThisType,
-      initialUniforms?: AbstractBaseShader.Uniforms,
+      initialUniforms?: AbstractBaseShader.Uniforms | null,
     ): FixedInstanceType<ThisType>;
 
     /**
@@ -65,6 +62,9 @@ declare global {
      */
     set scale(scale: number | { x: number; y?: number });
 
+    /** @remarks No getter is actually provided */
+    get scale(): undefined;
+
     set scaleX(x: number);
 
     set scaleY(y: number);
@@ -81,7 +81,7 @@ declare global {
 
   namespace AbstractWeatherShader {
     interface Any extends AnyAbstractWeatherShader {}
-    type AnyConstructor = typeof AnyAbstractWeatherShader;
+    interface AnyConstructor extends Identity<typeof AnyAbstractWeatherShader> {}
 
     interface CommonUniforms extends AbstractBaseShader.Uniforms {
       terrainUvMatrix: PIXI.Matrix;
@@ -101,11 +101,10 @@ declare global {
       time: number;
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-    interface DefaultUniforms {}
+    interface DefaultUniforms extends AbstractBaseShader.Uniforms {}
   }
 }
 
-declare abstract class AnyAbstractWeatherShader extends AbstractWeatherShader {
-  constructor(arg0: never, ...args: never[]);
+declare abstract class AnyAbstractWeatherShader extends AbstractWeatherShader<AbstractWeatherShader.DefaultUniforms> {
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/webgl/shaders/weather/effect.d.mts

@@ -1,37 +1,30 @@
-import type { InexactPartial, FixedInstanceType } from "fvtt-types/utils";
-
-type QuadMeshClass = typeof QuadMesh;
-
-interface InternalWeatherShaderEffect_Interface extends QuadMeshClass {
-  new <ShaderClassInstance extends object>(
-    ...args: ConstructorParameters<typeof QuadMesh>
-  ): QuadMesh & ShaderClassInstance;
-}
-
-declare const InternalWeatherShaderEffect_Const: InternalWeatherShaderEffect_Interface;
-
-// @ts-expect-error - This pattern inherently requires a ts-expect-error as the base class is dynamic.
-class InternalWeatherShaderEffect<
-  ShaderClass extends AbstractWeatherShader.AnyConstructor,
-  _ShaderClassInstance extends object = FixedInstanceType<ShaderClass>,
-> extends InternalWeatherShaderEffect_Const<_ShaderClassInstance> {}
+import type { Identity, IntentionalPartial } from "fvtt-types/utils";
 
 declare global {
   /**
    * An interface for defining shader-based weather effects
    */
-  class WeatherShaderEffect<
-    ShaderClass extends AbstractWeatherShader.AnyConstructor = AbstractWeatherShader.AnyConstructor,
-  > extends InternalWeatherShaderEffect<ShaderClass> {
+  class WeatherShaderEffect extends QuadMesh {
     /**
      * @param config - The config object to create the shader effect
      */
-    constructor(config: WeatherShaderEffect.WeatherShaderEffectConfig | undefined, shaderClass: ShaderClass);
+    constructor(
+      config: WeatherShaderEffect.Configuration | undefined,
+      shaderClass: AbstractWeatherShader.AnyConstructor,
+    );
+
+    /** @privateRemarks Override not in Foundry code, but reflects reality at runtime */
+    override get shader(): AbstractWeatherShader;
+
+    /** @privateRemarks Override not in Foundry code, but reflects reality at runtime */
+    override setShaderClass(shaderClass: AbstractWeatherShader.AnyConstructor): void;
 
     /**
      * Set shader parameters.
      */
-    configure(config?: WeatherShaderEffect.WeatherShaderEffectConfig): void;
+    configure(
+      config?: WeatherShaderEffect.Configuration, // not:null (gets `Object.entries()`ed)
+    ): void;
 
     /**
      * Begin animation
@@ -47,17 +40,17 @@ declare global {
      * Initialize the weather effect.
      * @param config - Config object.
      */
-    protected _initialize(config: WeatherShaderEffect.WeatherShaderEffectConfig): void;
+    protected _initialize(config: WeatherShaderEffect.Configuration): void;
   }
 
   namespace WeatherShaderEffect {
     interface Any extends AnyWeatherShaderEffect {}
-    type AnyConstructor = typeof AnyWeatherShaderEffect;
+    interface AnyConstructor extends Identity<typeof AnyWeatherShaderEffect> {}
 
-    type WeatherShaderEffectConfig = InexactPartial<AbstractBaseShader.Uniforms & WeatherShaderEffect["shader"]>;
+    type Configuration = IntentionalPartial<AbstractBaseShader.Uniforms & AbstractWeatherShader>;
   }
 }
 
-declare abstract class AnyWeatherShaderEffect extends WeatherShaderEffect<AbstractWeatherShader.AnyConstructor> {
-  constructor(arg0: never, ...args: never[]);
+declare abstract class AnyWeatherShaderEffect extends WeatherShaderEffect {
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/webgl/shaders/weather/fog.d.mts

@@ -1,4 +1,4 @@
-import type { InterfaceToObject } from "fvtt-types/utils";
+import type { Identity } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -6,7 +6,7 @@ declare global {
    */
   class FogShader<
     DefaultUniforms extends FogShader.DefaultUniforms = FogShader.DefaultUniforms,
-  > extends AbstractWeatherShader<InterfaceToObject<DefaultUniforms>> {
+  > extends AbstractWeatherShader<DefaultUniforms> {
     /**
      * @defaultValue
      * ```js
@@ -36,9 +36,9 @@ declare global {
 
   namespace FogShader {
     interface Any extends AnyFogShader {}
-    type AnyConstructor = typeof AnyFogShader;
+    interface AnyConstructor extends Identity<typeof AnyFogShader> {}
 
-    interface DefaultUniforms extends AbstractBaseShader.Uniforms, AbstractWeatherShader.DefaultUniforms {
+    interface DefaultUniforms extends AbstractWeatherShader.DefaultUniforms {
       intensity: number;
       rotation: number;
       slope: number;
@@ -47,5 +47,5 @@ declare global {
 }
 
 declare abstract class AnyFogShader extends FogShader {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/webgl/shaders/weather/rain.d.mts

@@ -1,4 +1,4 @@
-import type { InterfaceToObject } from "fvtt-types/utils";
+import type { Identity } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -6,7 +6,7 @@ declare global {
    */
   class RainShader<
     DefaultUniforms extends RainShader.DefaultUniforms = RainShader.DefaultUniforms,
-  > extends AbstractWeatherShader<InterfaceToObject<DefaultUniforms>> {
+  > extends AbstractWeatherShader<DefaultUniforms> {
     /**
      * @defaultValue
      * ```js
@@ -26,9 +26,9 @@ declare global {
 
   namespace RainShader {
     interface Any extends AnyRainShader {}
-    type AnyConstructor = typeof AnyRainShader;
+    interface AnyConstructor extends Identity<typeof AnyRainShader> {}
 
-    interface DefaultUniforms extends AbstractBaseShader.Uniforms {
+    interface DefaultUniforms extends AbstractWeatherShader.DefaultUniforms {
       opacity: number;
       intensity: number;
       strength: number;
@@ -39,5 +39,5 @@ declare global {
 }
 
 declare abstract class AnyRainShader extends RainShader {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/webgl/shaders/weather/snow.d.mts

@@ -1,4 +1,4 @@
-import type { InterfaceToObject } from "fvtt-types/utils";
+import type { Identity } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -6,7 +6,7 @@ declare global {
    */
   class SnowShader<
     DefaultUniforms extends SnowShader.DefaultUniforms = SnowShader.DefaultUniforms,
-  > extends AbstractWeatherShader<InterfaceToObject<DefaultUniforms>> {
+  > extends AbstractWeatherShader<DefaultUniforms> {
     /**
      * @defaultValue
      * ```
@@ -22,14 +22,14 @@ declare global {
 
   namespace SnowShader {
     interface Any extends AnySnowShader {}
-    type AnyConstructor = typeof AnySnowShader;
+    interface AnyConstructor extends Identity<typeof AnySnowShader> {}
 
-    interface DefaultUniforms extends AbstractBaseShader.Uniforms {
+    interface DefaultUniforms extends AbstractWeatherShader.DefaultUniforms {
       direction: number;
     }
   }
 }
 
 declare abstract class AnySnowShader extends SnowShader {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/workers/texture-worker.d.mts

@@ -1,4 +1,4 @@
-import type { NullishProps } from "../../../../utils/index.d.mts";
+import type { Identity, NullishProps } from "fvtt-types/utils";
 import type {
   _ProcessBufferToBase64Options,
   Debug,
@@ -61,8 +61,8 @@ declare global {
   }
 
   namespace TextureCompressor {
-    type Any = AnyTextureCompressor;
-    type AnyConstructor = typeof AnyTextureCompressor;
+    interface Any extends AnyTextureCompressor {}
+    interface AnyConstructor extends Identity<typeof AnyTextureCompressor> {}
 
     /** @internal */
     type _ConstructorOptions = NullishProps<{
@@ -91,7 +91,7 @@ declare global {
       controlHash?: boolean;
     }>;
 
-    /** Options for the {@link TextureCompressor} constructor */
+    /** Options for the {@link TextureCompressor | `TextureCompressor`} constructor */
     interface ConstructorOptions extends _ConstructorOptions {}
 
     interface CompressBase64Options extends _ProcessBufferToBase64Options, Debug {}
@@ -101,5 +101,5 @@ declare global {
 }
 
 declare abstract class AnyTextureCompressor extends TextureCompressor {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

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

@@ -3,24 +3,29 @@ import type { Tour } from "../core/tour.d.mts";
 declare global {
   class SetupTour extends Tour {
     constructor(
-      config: SetupTourConfig,
-      { id, namespace }?: { id?: SetupTourConfig["id"]; namespace?: SetupTourConfig["namespace"] },
+      config: SetupTour.Config,
+      { id, namespace }?: { id?: SetupTour.Config["id"]; namespace?: SetupTour.Config["namespace"] },
     );
-    config: SetupTourConfig;
+    config: SetupTour.Config;
 
     focusedApp: Application.Any;
     override get canStart(): boolean;
-    override get steps(): TourStep[];
+    override get steps(): Tour.Step[];
     protected override _preStep(): Promise<void>;
     private _installingASystem(): Promise<void>;
     private _creatingAWorld(): Promise<void>;
   }
 
-  interface SetupTourConfig extends TourConfig {
-    /**
-     * Whether to close all open windows before beginning the tour.
-     * @defaultValue `true`
-     */
-    closeWindows: boolean;
+  namespace SetupTour {
+    interface Config extends Tour.Config {
+      /**
+       * Whether to close all open windows before beginning the tour.
+       * @defaultValue `true`
+       */
+      closeWindows: boolean;
+    }
   }
+
+  /** @deprecated {@link SetupTour.Config | `SetupTour.Config`} */
+  type SetupTourConfig = SetupTour.Config;
 }