@league-of-foundry-developers/foundry-vtt-types 13.340.0 → 13.345.1-beta.20250704.94554

package/src/foundry/index.d.mts

@@ -1,4 +1,2 @@
 import "./client/index.d.mts";
-import "./client-esm/client.d.mts";
-import "./common/prosemirror/index.d.mts";
 import "./public/index.d.mts";

package/src/foundry/public/scripts/clipper/clipper.d.mts

@@ -1,4 +1,4 @@
-import type { Brand } from "fvtt-types/utils";
+import type { Brand } from "#utils";
 
 declare global {
   namespace ClipperLib {
@@ -213,12 +213,13 @@ declare global {
 
     class TEdge {
       Bot: IntPoint;
+
       /** current (updated for every new scanbeam) */
       Curr: IntPoint;
       Top: IntPoint;
       Delta: IntPoint;
 
-      /**  @defaultValue `0` */
+      /** @defaultValue `0` */
       Dx: number;
 
       /** @defaultValue `PolyType.ptSubject` */

package/src/foundry/public/scripts/index.d.mts

@@ -1,2 +1,3 @@
 import "./earcut-edges/index.d.mts";
 import "./clipper/index.d.mts";
+import "./ktx2/index.d.mts";

package/src/foundry/public/scripts/ktx2/basis_transcoder.d.mts

@@ -0,0 +1,5 @@
+import type { BASIS as _BASIS } from "pixi-basis-ktx2";
+
+declare global {
+  var BASIS: _BASIS;
+}

package/src/foundry/public/scripts/ktx2/index.d.mts

@@ -0,0 +1,2 @@
+import "./pixi-ktx2.min.d.mts";
+import "./basis_transcoder.d.mts";

package/src/foundry/public/scripts/ktx2/pixi-ktx2.min.d.mts

@@ -0,0 +1,5 @@
+import type * as _PixiBasisKTX2 from "pixi-basis-ktx2";
+
+declare global {
+  var PixiBasisKTX2: typeof _PixiBasisKTX2;
+}

package/src/foundry/public/scripts/workers/image-compressor.d.mts

@@ -3,17 +3,25 @@ import * as worker from "../../../../types/workers/image-compressor.mjs";
 
 declare global {
   export import FORMATS = worker.FORMATS;
-  export import Debug = worker.Debug;
 
   export import ProcessBufferToBase64Options = worker.ProcessBufferToBase64Options;
+  export import ProcessBufferRedToBufferRGBAOptions = worker.ProcessBufferRedToBufferRGBAOptions;
+  export import ProcessBufferRGBAToBufferRedOptions = worker.ProcessBufferRGBAToBufferRedOptions;
+  export import CopyBufferOptions = worker.CopyBufferOptions;
+  export import Debug = worker.Debug;
   export import ExpandOrReduceBufferOptions = worker.ExpandOrReduceBufferOptions;
-  export import ProcessBufferToBase64Return = worker.ProcessBufferToBase64Return;
-  export import ProcessBufferRedToBufferRGBAReturn = worker.ProcessBufferRedToBufferRGBAReturn;
-  export import ProcessBufferRGBAToBufferREDReturn = worker.ProcessBufferRGBAToBufferREDReturn;
+  export import ControlHashesReturnObject = worker.ControlHashesReturnObject;
+
+  export import ProcessBufferToBase64Result = worker.ProcessBufferToBase64Result;
+  export import ProcessBufferRedToBufferRGBAResult = worker.ProcessBufferRedToBufferRGBAResult;
+  export import ProcessBufferRGBAToBufferRedResult = worker.ProcessBufferRGBAToBufferRedResult;
+  export import CopyBufferResult = worker.CopyBufferResult;
+  export import BufferOperationReturn = worker.BufferOperationReturn;
 
   export import processBufferToBase64 = worker.processBufferToBase64;
   export import processBufferRedToBufferRGBA = worker.processBufferRedToBufferRGBA;
   export import processBufferRGBAToBufferRED = worker.processBufferRGBAToBufferRED;
+  export import copyBuffer = worker.copyBuffer;
   export import controlHashes = worker.controlHashes;
   export import pixelsToOffscreenCanvas = worker.pixelsToOffscreenCanvas;
   export import offscreenToBase64 = worker.offscreenToBase64;

package/src/types/augments/particles.d.mts

@@ -1,6 +1,6 @@
 /* eslint-disable import-x/export */
 
-import type { Brand } from "fvtt-types/utils";
+import type { Brand } from "#utils";
 
 export namespace behaviors {
   type BehaviorOrder = Brand<number, "PIXI.particles.behaviors.BehaviorOrder">;

package/src/types/augments/pixi.d.mts

@@ -1,4 +1,4 @@
-import type { Brand } from "fvtt-types/utils";
+import type { Brand, Identity } from "#utils";
 import * as _PIXI from "pixi.js";
 
 // Note(LukeAbby): The `smooth.d.mts` and `smooth.d.mts` files exist to make it DRY to selectively tweak PIXI sub-namespaces.
@@ -272,7 +272,7 @@ declare global {
     /**
      * Configure whether filter textures are cleared after binding.
      *
-     * Filter textures need not be cleared if the filter does not use pixel blending. {@link PIXI.CLEAR_MODES.BLIT} will detect
+     * Filter textures need not be cleared if the filter does not use pixel blending. {@linkcode PIXI.CLEAR_MODES.BLIT} will detect
      * this and skip clearing as an optimization.
      */
     const CLEAR_MODES: {
@@ -291,7 +291,7 @@ declare global {
       /** Always clear the filter texture. */
       CLEAR: 1 & CLEAR_MODES;
 
-      /** Clear only if {@link PIXI.FilterSystem.forceClear} is set or if the filter uses pixel blending. */
+      /** Clear only if {@linkcode PIXI.FilterSystem.forceClear} is set or if the filter uses pixel blending. */
       BLIT: 2 & CLEAR_MODES;
     };
 
@@ -440,7 +440,7 @@ declare global {
     /**
      * The gc modes that are supported by pixi.
      *
-     * The {@link PIXI.TextureGCSystem.defaultMode} Garbage Collection mode for PixiJS textures is AUTO
+     * The {@linkcode PIXI.TextureGCSystem.defaultMode} Garbage Collection mode for PixiJS textures is AUTO
      * If set to GC_MODE, the renderer will occasionally check textures usage. If they are not
      * used for a specified period of time they will be removed from the GPU. They will of course
      * be uploaded again when they are required. This is a silent behind the scenes process that
@@ -573,8 +573,8 @@ declare global {
 
     /**
      * Supported line joints in `PIXI.LineStyle` for graphics.
-     * @see PIXI.Graphics#lineStyle
-     * @see https://graphicdesign.stackexchange.com/questions/59018/what-is-a-bevel-join-of-two-lines-exactly-illustrator
+     * @see {@link PIXI.Graphics.lineStyle | `PIXI.Graphics#lineStyle`}
+     * @see {@link https://graphicdesign.stackexchange.com/questions/59018/what-is-a-bevel-join-of-two-lines-exactly-illustrator}
      */
     const LINE_JOIN: {
       /** 'miter': make a sharp corner where outer part of lines meet */
@@ -633,7 +633,7 @@ declare global {
     /**
      * Mipmap filtering modes that are supported by pixi.
      *
-     * The {@link PIXI.BaseTexture.defaultOptions.mipmap} affects default texture filtering.
+     * The {@linkcode PIXI.BaseTexture.defaultOptions.mipmap} affects default texture filtering.
      * Mipmaps are generated for a baseTexture if its `mipmap` field is `ON`,
      * or its `POW2` and texture dimensions are powers of 2.
      * Since WebGL 1 don't support mipmap for non-power-of-two textures,
@@ -736,7 +736,7 @@ declare global {
     /**
      * The scale modes that are supported by pixi.
      *
-     * The {@link PIXI.BaseTexture.defaultOptions.scaleMode} scale mode affects the default scaling mode of future operations.
+     * The {@linkcode PIXI.BaseTexture.defaultOptions.scaleMode} scale mode affects the default scaling mode of future operations.
      * It can be re-assigned to either LINEAR or NEAREST, depending upon suitability.
      */
     const SCALE_MODES: {
@@ -902,24 +902,24 @@ declare global {
 
     /**
      * Represents the update priorities used by internal PIXI classes when registered with
-     * the {@link PIXI.Ticker} object. Higher priority items are updated first and lower
+     * the {@linkcode PIXI.Ticker} object. Higher priority items are updated first and lower
      * priority items, such as render, should go later.
      * @remarks Includes Foundry's additions of `OBJECTS`, `PRIMARY`, and `PERCEPTION`
      */
     const UPDATE_PRIORITY: {
-      /** Highest priority used for interaction events in {@link PIXI.EventSystem} */
+      /** Highest priority used for interaction events in {@linkcode PIXI.EventSystem} */
       INTERACTION: 50 & UPDATE_PRIORITY;
 
-      /** High priority updating, used by {@link PIXI.AnimatedSprite} */
+      /** High priority updating, used by {@linkcode PIXI.AnimatedSprite} */
       HIGH: 25 & UPDATE_PRIORITY;
 
-      /** Default priority for ticker events, see {@link PIXI.Ticker#add}. */
+      /** Default priority for ticker events, see {@link PIXI.Ticker.add | `PIXI.Ticker#add`}. */
       NORMAL: 0 & UPDATE_PRIORITY;
 
-      /** Low priority used for {@link PIXI.Application} rendering. */
+      /** Low priority used for {@linkcode PIXI.Application} rendering. */
       LOW: 25 & UPDATE_PRIORITY;
 
-      /** Lowest priority used for {@link PIXI.BasePrepare} utility. */
+      /** Lowest priority used for {@linkcode PIXI.BasePrepare} utility. */
       UTILITY: 50 & UPDATE_PRIORITY;
 
       /** @remarks Foundry addition, defined as `HIGH - 2` */
@@ -973,42 +973,51 @@ declare global {
 
     namespace BatchGeometry {
       interface Any extends AnyPIXIBatchGeometry {}
-      type AnyConstructor = typeof AnyPIXIBatchGeometry;
+      interface AnyConstructor extends Identity<typeof AnyPIXIBatchGeometry> {}
     }
 
     export import BatchRenderer = _PIXI.BatchRenderer;
 
     namespace BatchRenderer {
       interface Any extends AnyPIXIBatchRenderer {}
-      type AnyConstructor = typeof AnyPIXIBatchRenderer;
+      interface AnyConstructor extends Identity<typeof AnyPIXIBatchRenderer> {}
     }
 
     export import Container = _PIXI.Container;
 
     namespace Container {
       interface Any extends AnyPIXIContainer {}
-      type AnyConstructor = typeof AnyPIXIContainer;
+      interface AnyConstructor extends Identity<typeof AnyPIXIContainer> {}
     }
 
     export import DisplayObject = _PIXI.DisplayObject;
 
     namespace DisplayObject {
       interface Any extends AnyPIXIDisplayObject {}
-      type AnyConstructor = typeof AnyPIXIDisplayObject;
+      interface AnyConstructor extends Identity<typeof AnyPIXIDisplayObject> {}
     }
 
     export import Filter = _PIXI.Filter;
 
     namespace Filter {
       interface Any extends AnyPIXIFilter {}
-      type AnyConstructor = typeof AnyPIXIFilter;
+      interface AnyConstructor extends Identity<typeof AnyPIXIFilter> {}
     }
 
     export import Shader = _PIXI.Shader;
 
     namespace Shader {
       interface Any extends AnyPIXIShader {}
-      type AnyConstructor = typeof AnyPIXIShader;
+      interface AnyConstructor extends Identity<typeof AnyPIXIShader> {}
+    }
+
+    class Texture<R extends PIXI.Resource = PIXI.Resource> extends _PIXI.Texture<R> {
+      // Note(LukeAbby): `Texture.from` does not correctly.
+      static from<R extends PIXI.Resource = PIXI.Resource, RO = any>(
+        source: PIXI.Resource | PIXI.TextureSource | PIXI.TextureSource[],
+        options?: PIXI.IBaseTextureOptions<RO>,
+        strict?: boolean,
+      ): PIXI.Texture<R>;
     }
   }
 }
@@ -1019,7 +1028,7 @@ declare module "@pixi/events" {
      * The angle in radians of a pointer or stylus measuring the vertical angle between
      * the device's surface to the pointer or stylus.
      * A stylus at 0 degrees would be directly parallel whereas at π/2 degrees it would be perpendicular.
-     * @see https://developer.mozilla.org/docs/Web/API/PointerEvent/altitudeAngle)
+     * @see {@link https://developer.mozilla.org/docs/Web/API/PointerEvent/altitudeAngle}
      */
     altitudeAngle: number;
 
@@ -1027,7 +1036,7 @@ declare module "@pixi/events" {
      * The angle in radians of a pointer or stylus measuring an arc from the X axis of the device to
      * the pointer or stylus projected onto the screen's plane.
      * A stylus at 0 degrees would be pointing to the "0 o'clock" whereas at π/2 degrees it would be pointing at "6 o'clock".
-     * @see https://developer.mozilla.org/docs/Web/API/PointerEvent/azimuthAngle)
+     * @see {@link https://developer.mozilla.org/docs/Web/API/PointerEvent/azimuthAngle}
      */
     azimuthAngle: number;
   }
@@ -1078,25 +1087,25 @@ declare module "pixi.js" {
 }
 
 declare abstract class AnyPIXIBatchGeometry extends PIXI.BatchGeometry {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }
 
 declare abstract class AnyPIXIBatchRenderer extends PIXI.BatchRenderer {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }
 
 declare abstract class AnyPIXIContainer extends PIXI.Container {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }
 
 declare abstract class AnyPIXIDisplayObject extends PIXI.DisplayObject {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }
 
 declare abstract class AnyPIXIFilter extends PIXI.Filter {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }
 
 declare abstract class AnyPIXIShader extends PIXI.Shader {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

package/src/types/augments/smooth.d.mts

@@ -1,4 +1,4 @@
-import type { Brand } from "fvtt-types/utils";
+import type { Brand } from "#utils";
 
 type JOINT_TYPE = Brand<number, "PIXI.smooth.JOINT_TYPE">;
 declare const JOINT_TYPE: {

package/src/types/augments/socket.io-client.d.mts

@@ -1,7 +1,6 @@
 import type * as _io from "socket.io-client";
 
 declare global {
-  // eslint-disable-next-line no-var
   var io: typeof _io & typeof _io.io & { connect: typeof _io.io };
   namespace io {
     type Socket = _io.Socket;

package/src/types/augments/tinyMCE.d.mts

@@ -1,6 +1,6 @@
 import _tinymce from "tinymce";
 import type * as _tinymceTypes from "tinymce";
-import type { AnyObject } from "fvtt-types/utils";
+import type { AnyObject } from "#utils";
 
 declare global {
   let tinyMCE: typeof _tinymce;

package/src/types/config.d.mts

@@ -1,25 +1,22 @@
 // This is an issue only on Windows. It's worked around in this weird way to avoid ESLint
 // whining about an unused disable.
-/* eslint import-x/no-unresolved: [2, { ignore: ["fvtt-types/configuration"] }] */
 
-import type { InterfaceToObject, MustConform } from "fvtt-types/utils";
-
-// eslint-disable-next-line import-x/extensions
-import * as configuration from "fvtt-types/configuration";
+import type { InterfaceToObject, MustConform } from "#utils";
+import * as configuration from "#configuration";
 
 declare global {
-  export import AssumeHookRan = configuration.AssumeHookRan;
-  export import DocumentClassConfig = configuration.DocumentClassConfig;
-  export import PlaceableObjectClassConfig = configuration.PlaceableObjectClassConfig;
-  export import DataConfig = configuration.DataConfig;
-  export import GetDataConfig = configuration.GetDataConfig;
-  export import DataModelConfig = configuration.DataModelConfig;
-  export import SourceConfig = configuration.SourceConfig;
-  export import FlagConfig = configuration.FlagConfig;
-  export import WebRTCConfig = configuration.WebRTCConfig;
-  export import ModuleConfig = configuration.ModuleConfig;
-  export import RequiredModules = configuration.RequiredModules;
-  export import SettingConfig = configuration.SettingConfig;
+  interface AssumeHookRan extends configuration.AssumeHookRan {}
+  interface DocumentClassConfig extends configuration.DocumentClassConfig {}
+  interface PlaceableObjectClassConfig extends configuration.PlaceableObjectClassConfig {}
+  interface DataConfig extends configuration.DataConfig {}
+  interface GetDataConfig extends configuration.GetDataConfig {}
+  interface DataModelConfig extends configuration.DataModelConfig {}
+  interface SourceConfig extends configuration.SourceConfig {}
+  interface FlagConfig extends configuration.FlagConfig {}
+  interface WebRTCConfig extends configuration.WebRTCConfig {}
+  interface ModuleConfig extends configuration.ModuleConfig {}
+  interface RequiredModules extends configuration.RequiredModules {}
+  interface SettingConfig extends configuration.SettingConfig {}
 }
 
 type ValidDataModel = {
@@ -34,7 +31,7 @@ type MustBeValid<T extends ValidDataModel> = T;
 type _TestValidDataModelConfig = MustConform<DataModelConfig, ValidDataModel>;
 
 interface ValidSettingConfig {
-  readonly [K: string]: ClientSettings.Type;
+  readonly [K: string]: foundry.helpers.ClientSettings.Type;
 }
 
 type _TestValidSettingConfig = MustConform<InterfaceToObject<SettingConfig>, ValidSettingConfig>;