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

package/src/foundry/client-esm/appv1/sheets/actor-sheet.d.mts

@@ -0,0 +1,5 @@
+// TODO: Migrate ActorSheet
+
+declare class ActorSheet {}
+
+export default ActorSheet;

package/src/foundry/client-esm/appv1/sheets/adventure-importer.d.mts

@@ -0,0 +1,5 @@
+// TODO: Migrate AdventureImporter
+
+declare class AdventureImporter {}
+
+export default AdventureImporter;

package/src/foundry/client-esm/appv1/sheets/item-sheet.d.mts

@@ -0,0 +1,5 @@
+// TODO: Migrate ItemSheet
+
+declare class ItemSheet {}
+
+export default ItemSheet;

package/src/foundry/client-esm/appv1/sheets/journal-page-sheet.d.mts

@@ -0,0 +1,7 @@
+// TODO: JournalPageSheet, JournalTextPageSheet, JournalTextTinyMCESheet
+
+declare class JournalPageSheet {}
+declare class JournalTextPageSheet extends JournalPageSheet {}
+declare class JournalTextTinyMCESheet extends JournalPageSheet {}
+
+export { JournalPageSheet, JournalTextPageSheet, JournalTextTinyMCESheet };

package/src/foundry/client-esm/appv1/sheets/journal-sheet.d.mts

@@ -0,0 +1,5 @@
+// TODO: Migrate JournalSheet
+
+declare class JournalSheet {}
+
+export default JournalSheet;

package/src/foundry/client-esm/audio/_module.d.mts

@@ -1,8 +1,7 @@
 // In Foundry itself this file contains re-exports of these other modules.
 // Therefore it has a runtime effect and uses `.mjs` instead of `.d.mts`.
-// While `.mts` could work, to avoid `import/no-unresolved` from erroring `.mjs` is used.
-/* eslint-disable import/extensions */
-/* eslint-disable import/no-unresolved */ // TODO: Remove when the files are instantiated
+// While `.mts` could work, to avoid `import-x/no-unresolved` from erroring `.mjs` is used.
+/* eslint-disable import-x/extensions */
 
 export * as types from "./_types.mjs";
 export { default as AudioBufferCache } from "./cache.mjs";

package/src/foundry/client-esm/audio/biquad.d.mts

@@ -1,4 +1,4 @@
-import type { InexactPartial } from "../../../types/utils.d.mts";
+import type { InexactPartial } from "fvtt-types/utils";
 
 /**
  * A sound effect which applies a biquad filter.

package/src/foundry/client-esm/audio/convolver.d.mts

@@ -1,4 +1,4 @@
-import type { InexactPartial } from "../../../types/utils.d.mts";
+import type { InexactPartial } from "fvtt-types/utils";
 
 declare namespace ConvolverEffect {}
 

package/src/foundry/client-esm/audio/helper.d.mts

@@ -1,6 +1,6 @@
 import type Sound from "./sound.d.mts";
 import type AudioBufferCache from "./cache.d.mts";
-import type { InexactPartial } from "../../../types/utils.d.mts";
+import type { InexactPartial } from "fvtt-types/utils";
 
 /**
  * A helper class to provide common functionality for working with the Web Audio API.

package/src/foundry/client-esm/audio/sound.d.mts

@@ -1,5 +1,5 @@
-import type { AnyObject, InexactPartial, ValueOf } from "../../../types/utils.d.mts";
-import type EventEmitterMixin from "../../common/utils/event-emitter.d.mts";
+import type { AnyObject, InexactPartial, ValueOf } from "fvtt-types/utils";
+import type EventEmitterMixin from "@common/utils/event-emitter.d.mts";
 
 declare namespace Sound {
   interface PlaybackOptions extends _PlaybackOptions {}

package/src/foundry/client-esm/av/_module.d.mts

@@ -0,0 +1,10 @@
+// In Foundry itself this file contains re-exports of these other modules.
+// Therefore it has a runtime effect and uses `.mjs` instead of `.d.mts`.
+// While `.mts` could work, to avoid `import-x/no-unresolved` from erroring `.mjs` is used.
+/* eslint-disable import-x/extensions */
+
+export * as clients from "./clients/_module.mjs";
+
+export { default as AVClient } from "./client.mjs";
+export { default as AVMaster } from "./master.mjs";
+export { default as AVSettings } from "./settings.mjs";

package/src/foundry/client-esm/av/client.d.mts

@@ -0,0 +1,18 @@
+import type AVMaster from "./master.d.mts";
+import type AVSettings from "./settings.d.mts";
+
+/**
+ * An interface for an Audio/Video client which is extended to provide broadcasting functionality.
+ * @remarks TODO: Stub
+ */
+declare class AVClient {
+  /**
+   * @param master   - The master orchestration instance
+   * @param settings - The audio/video settings being used
+   */
+  constructor(master: AVMaster, settings: AVSettings);
+}
+
+declare namespace AVClient {}
+
+export default AVClient;

package/src/foundry/client-esm/av/clients/_module.d.mts

@@ -0,0 +1,6 @@
+// In Foundry itself this file contains re-exports of these other modules.
+// Therefore it has a runtime effect and uses `.mjs` instead of `.d.mts`.
+// While `.mts` could work, to avoid `import-x/no-unresolved` from erroring `.mjs` is used.
+/* eslint-disable import-x/extensions */
+
+export { default as SimplePeerAVClient } from "./simplepeer.mjs";

package/src/foundry/client-esm/av/clients/simplepeer.d.mts

@@ -0,0 +1,11 @@
+import type AVClient from "../client.d.mts";
+
+/**
+ * An implementation of the AVClient which uses the simple-peer library and the Foundry socket server for signaling.
+ * Credit to bekit#4213 for identifying simple-peer as a viable technology and providing a POC implementation.
+ */
+declare class SimplePeerAVClient extends AVClient {}
+
+declare namespace SimplePeerAVClient {}
+
+export default SimplePeerAVClient;

package/src/foundry/client-esm/av/master.d.mts

@@ -0,0 +1,12 @@
+/**
+ * The master Audio/Video controller instance.
+ * This is available as the singleton game.webrtc
+ * @remarks TODO: Stub
+ */
+declare class AVMaster {
+  constructor();
+}
+
+declare namespace AVMaster {}
+
+export default AVMaster;

package/src/foundry/client-esm/av/settings.d.mts

@@ -0,0 +1,30 @@
+/**
+ * @remarks TODO: Stub
+ */
+declare class AVSettings {
+  constructor();
+}
+
+declare namespace AVSettings {
+  interface Data {
+    /**
+     * Whether this user has muted themselves.
+     * @remarks non-nullish due to use of `in`
+     */
+    muted?: boolean;
+
+    /**
+     * Whether this user has hidden their video.
+     * @remarks non-nullish due to use of `in`
+     */
+    hidden?: boolean;
+
+    /**
+     * Whether the user is broadcasting audio.
+     * @remarks non-nullish due to use of `in`
+     */
+    speaking?: boolean;
+  }
+}
+
+export default AVSettings;

package/src/foundry/client-esm/canvas/_module.d.mts

@@ -1,7 +1,7 @@
 // In Foundry itself this file contains re-exports of these other modules.
 // Therefore it has a runtime effect and uses `.mjs` instead of `.d.mts`.
-// While `.mts` could work, to avoid `import/no-unresolved` from erroring `.mjs` is used.
-/* eslint-disable import/extensions */
+// While `.mts` could work, to avoid `import-x/no-unresolved` from erroring `.mjs` is used.
+/* eslint-disable import-x/extensions */
 
 export { default as SceneManager } from "./scene-manager.mjs";
 export { default as SMAAFilter } from "./smaa/smaa.mjs";

package/src/foundry/client-esm/canvas/edges/_module.d.mts

@@ -1,7 +1,7 @@
 // In Foundry itself this file contains re-exports of these other modules.
 // Therefore it has a runtime effect and uses `.mjs` instead of `.d.mts`.
-// While `.mts` could work, to avoid `import/no-unresolved` from erroring `.mjs` is used.
-/* eslint-disable import/extensions */
+// While `.mts` could work, to avoid `import-x/no-unresolved` from erroring `.mjs` is used.
+/* eslint-disable import-x/extensions */
 
 export { default as CanvasEdges } from "./edges.mjs";
 export { default as CollisionResult } from "./collision.mjs";

package/src/foundry/client-esm/canvas/edges/collision.d.mts

@@ -1,57 +1,54 @@
+import type { NullishProps } from "../../../../utils/index.d.mts";
+import type Edge from "./edge.d.mts";
+import type PolygonVertex from "./vertex.d.mts";
+
 /**
  * A specialized object that contains the result of a collision in the context of the ClockwiseSweepPolygon.
  * This class is not designed or intended for use outside of that context.
- * @internal
  */
 declare class CollisionResult {
-  constructor(values?: {
-    target?: foundry.canvas.edges.PolygonVertex;
-    collisions?: foundry.canvas.edges.PolygonVertex[];
-    cwEdges?: EdgeSet;
-    ccwEdges?: EdgeSet;
-    isBehind?: boolean;
-    isLimited?: boolean;
-    wasLimited?: boolean;
-  });
+  constructor(values?: CollisionResult.ConstructorValues);
 
   /**
    * The vertex that was the target of this result
-   * @defaultValue `null`
    */
-  target: foundry.canvas.edges.PolygonVertex | null;
+  target: PolygonVertex;
 
   /**
    * The array of collision points which apply to this result
    * @defaultValue `[]`
    */
-  collisions: foundry.canvas.edges.PolygonVertex[];
+  collisions: PolygonVertex[];
 
   /**
    * The set of edges connected to the target vertex that continue clockwise
    * @defaultValue `new Set()`
    */
-  cwEdges: EdgeSet;
+  cwEdges: Set<Edge>;
 
   /**
    * The set of edges connected to the target vertex that continue counter-clockwise
    * @defaultValue `new Set()`
    */
-  ccwEdges: EdgeSet;
+  ccwEdges: Set<Edge>;
 
   /**
    * Is the target vertex for this result behind some closer active edge?
+   * @remarks Set directly from the constructor, so possibly was passed nullish
    */
-  isBehind: boolean | undefined;
+  isBehind: boolean | undefined | null;
 
   /**
    * Does the target vertex for this result impose a limited collision?
+   * @remarks Set directly from the constructor, so possibly was passed nullish
    */
-  isLimited: boolean | undefined;
+  isLimited: boolean | undefined | null;
 
   /**
    * Has the set of collisions for this result encountered a limited edge?
+   * @remarks Set directly from the constructor, so possibly was passed nullish
    */
-  wasLimited: boolean | undefined;
+  wasLimited: boolean | undefined | null;
 
   /**
    * Is this result limited in the clockwise direction?
@@ -90,4 +87,50 @@ declare class CollisionResult {
   blockedCCWPrev: boolean;
 }
 
+declare namespace CollisionResult {
+  interface Any extends AnyCollisionResult {}
+  type AnyConstructor = typeof AnyCollisionResult;
+
+  type _ConstructorValues = NullishProps<{
+    /**
+     * The set of edges connected to the target vertex that continue clockwise
+     * @defaultValue `new Set()`
+     */
+    cwEdges: Set<Edge>;
+
+    /**
+     * The set of edges connected to the target vertex that continue counter-clockwise
+     * @defaultValue `new Set()`
+     */
+    ccwEdges: Set<Edge>;
+
+    /** Is the target vertex for this result behind some closer active edge? */
+    isBehind: boolean;
+
+    /** Does the target vertex for this result impose a limited collision? */
+    isLimited: boolean;
+
+    /** Has the set of collisions for this result encountered a limited edge? */
+    wasLimited: boolean;
+  }>;
+
+  interface ConstructorValues extends _ConstructorValues {
+    /**
+     * The vertex that was the target of this result
+     */
+    target: PolygonVertex;
+
+    /**
+     * The array of collision points which apply to this result
+     * @defaultValue `[]`
+     * @remarks Can't be `null` as it only has a parameter default
+     */
+    collisions?: PolygonVertex[] | undefined;
+  }
+}
+
+declare abstract class AnyCollisionResult extends CollisionResult {
+  constructor(arg0: never, ...args: never[]);
+}
+
 export default CollisionResult;

package/src/foundry/client-esm/canvas/edges/edge.d.mts

@@ -1,5 +1,7 @@
-import type { InexactPartial } from "../../../../types/utils.d.mts";
-import type { WallThresholdData } from "../../../common/documents/_types.d.mts";
+import type PolygonVertex from "./vertex.d.mts";
+import type { LineIntersection } from "@common/utils/geometry.d.mts";
+import type { NullishProps } from "fvtt-types/utils";
+import type { WallThresholdData } from "@common/documents/_types.d.mts";
 
 /**
  * A data structure used to represent potential edges used by the ClockwiseSweepPolygon.
@@ -12,33 +14,7 @@ declare class Edge {
    * @param b - The second endpoint of the edge
    * @param options - Additional options which describe the edge
    */
-  constructor(
-    a: Canvas.Point,
-    b: Canvas.Point,
-    options?: InexactPartial<{
-      /** A string used to uniquely identify this edge */
-      id?: string;
-      /** A PlaceableObject that is responsible for this edge, if any */
-      object?: PlaceableObject;
-      /** The type of edge */
-      type?: Edge.EdgeTypes;
-      /** How this edge restricts light */
-      light?: foundry.CONST.WALL_SENSE_TYPES;
-      /** How this edge restricts movement */
-      move?: foundry.CONST.WALL_SENSE_TYPES;
-      /** How this edge restricts sight */
-      sight?: foundry.CONST.WALL_SENSE_TYPES;
-      /** How this edge restricts sound */
-      sound?: foundry.CONST.WALL_SENSE_TYPES;
-      /**
-       * A direction of effect for the edge
-       * @defaultValue `0`
-       */
-      direction?: foundry.CONST.WALL_DIRECTIONS;
-      /** Configuration of threshold data for this edge */
-      threshold?: WallThresholdData;
-    }>,
-  );
+  constructor(a: Canvas.Point, b: Canvas.Point, options?: Edge.ConstructorOptions);
 
   /**
    * The first endpoint of the edge.
@@ -52,11 +28,20 @@ declare class Edge {
 
   /**
    * A string used to uniquely identify this edge.
+   * @defaultValue `object?.id ?? undefined`
    */
-  id: string;
+  id: string | undefined;
 
-  object: PlaceableObject;
+  /**
+   * A PlaceableObject that is responsible for this edge, if any
+   * @remarks This property is never read by Foundry, so it being nullish won't break anything as of 12.331
+   */
+  object: PlaceableObject.Any | undefined | null;
 
+  /**
+   * The type of edge
+   * @defaultValue `"wall"`
+   */
   type: Edge.EdgeTypes;
 
   /**
@@ -66,28 +51,33 @@ declare class Edge {
 
   /**
    * How this edge restricts light.
+   * @defaultValue `CONST.WALL_SENSE_TYPES.NONE`
    */
   light: foundry.CONST.WALL_SENSE_TYPES;
 
   /**
    * How this edge restricts movement.
+   * @defaultValue `CONST.WALL_SENSE_TYPES.NONE`
    */
   move: foundry.CONST.WALL_SENSE_TYPES;
 
   /**
    * How this edge restricts sight.
+   * @defaultValue `CONST.WALL_SENSE_TYPES.NONE`
    */
   sight: foundry.CONST.WALL_SENSE_TYPES;
 
   /**
    * How this edge restricts sound.
+   * @defaultValue `CONST.WALL_SENSE_TYPES.NONE`
    */
   sound: foundry.CONST.WALL_SENSE_TYPES;
 
   /**
    * Specialized threshold data for this edge.
+   * @remarks Foundry only accesses this in nullish-safe ways as of 12.331
    */
-  threshold: WallThresholdData;
+  threshold: WallThresholdData | undefined | null;
 
   /**
    * The endpoint of the edge which is oriented towards the top-left.
@@ -107,37 +97,38 @@ declare class Edge {
   /**
    * Record other edges which this one intersects with.
    */
-  intersections: {
-    edge: Edge;
-    intersection: foundry.utils.LineIntersection;
-  }[];
+  intersections: Edge.IntersectionEntry[];
 
   /**
    * A PolygonVertex instance.
    * Used as part of ClockwiseSweepPolygon computation.
+   * @defaultValue `undefined`
+   * @remarks Only set in {@link ClockwiseSweepPolygon#_identifyVertices} (part of CSP initialization)
    */
-  vertexA: foundry.canvas.edges.PolygonVertex;
+  vertexA: PolygonVertex | undefined;
 
   /**
    * A PolygonVertex instance.
    * Used as part of ClockwiseSweepPolygon computation.
+   * @defaultValue `undefined`
+   * @remarks Only set in {@link ClockwiseSweepPolygon#_identifyVertices} (part of CSP initialization)
    */
-  vertexB: foundry.canvas.edges.PolygonVertex;
+  vertexB: PolygonVertex | undefined;
 
   /**
    * Is this edge limited for a particular type?
    */
-  isLimited(type: "direction" | "light" | "move" | "sight" | "sound"): boolean;
+  isLimited(type: foundry.CONST.WALL_RESTRICTION_TYPES): boolean;
 
   /**
    * Create a copy of the Edge which can be safely mutated.
    */
-  clone(): Edge;
+  clone(): this;
 
   /**
    * Get an intersection point between this Edge and another.
    */
-  getIntersection(other: Edge): foundry.utils.LineIntersection | void;
+  getIntersection(other: Edge): LineIntersection | void;
 
   /**
    * Test whether to apply a proximity threshold to this edge.
@@ -149,7 +140,7 @@ declare class Edge {
    * @returns True if the edge has a threshold greater than 0 for the source type,
    *          and the source type is within that distance.
    */
-  applyThreshold(sourceType: string, sourceOrigin: Canvas.Point, externalRadius?: number): boolean;
+  applyThreshold(sourceType: Edge.AttenuationTypes, sourceOrigin: Canvas.Point, externalRadius?: number): boolean;
 
   /**
    * Determine the orientation of this Edge with respect to a reference point.
@@ -178,7 +169,80 @@ declare class Edge {
 }
 
 declare namespace Edge {
+  interface Any extends AnyEdge {}
+  type AnyConstructor = typeof AnyEdge;
+
+  /** @internal */
+  type _ConstructorOptions = NullishProps<{
+    /**
+     * A string used to uniquely identify this edge
+     *
+     */
+    id: string | null;
+
+    /**
+     * A PlaceableObject that is responsible for this edge, if any
+     * @remarks `Edge#object` is never read by Foundry, so this being nullish won't break anything as of 12.331
+     */
+    object: PlaceableObject.Any;
+
+    /**
+     * The type of edge
+     * @defaultValue `"wall"`
+     */
+    type: Edge.EdgeTypes;
+
+    /**
+     * How this edge restricts light
+     * @defaultValue `CONST.WALL_SENSE_TYPES.NONE`
+     */
+    light: foundry.CONST.WALL_SENSE_TYPES;
+
+    /**
+     * How this edge restricts movement
+     * @defaultValue `CONST.WALL_SENSE_TYPES.NONE`
+     */
+    move: foundry.CONST.WALL_SENSE_TYPES;
+
+    /**
+     * How this edge restricts sight
+     * @defaultValue `CONST.WALL_SENSE_TYPES.NONE`
+     */
+    sight: foundry.CONST.WALL_SENSE_TYPES;
+
+    /**
+     * How this edge restricts sound
+     * @defaultValue `CONST.WALL_SENSE_TYPES.NONE`
+     */
+    sound: foundry.CONST.WALL_SENSE_TYPES;
+
+    /**
+     * A direction of effect for the edge
+     * @defaultValue `CONST.WALL_DIRECTIONS.BOTH`
+     */
+    direction: foundry.CONST.WALL_DIRECTIONS;
+
+    /**
+     * Configuration of threshold data for this edge
+     * @remarks Foundry only accesses this in nullish-safe ways as of 12.331
+     */
+    threshold: WallThresholdData;
+  }>;
+
+  interface ConstructorOptions extends _ConstructorOptions {}
+
   type EdgeTypes = "wall" | "darkness" | "innerBounds" | "outerBounds";
+
+  type AttenuationTypes = Exclude<foundry.CONST.WALL_RESTRICTION_TYPES, "move">;
+
+  interface IntersectionEntry {
+    edge: Edge;
+    intersection: LineIntersection;
+  }
+}
+
+declare abstract class AnyEdge extends Edge {
+  constructor(arg0: never, ...args: never[]);
 }
 
 export default Edge;

package/src/foundry/client-esm/canvas/edges/edges.d.mts

@@ -20,4 +20,13 @@ declare class CanvasEdges extends Map<string, Edge> {
   refresh(): void;
 }
 
+declare namespace CanvasEdges {
+  interface Any extends AnyCanvasEdges {}
+  type AnyConstructor = typeof AnyCanvasEdges;
+}
+
+declare abstract class AnyCanvasEdges extends CanvasEdges {
+  constructor(arg0: never, ...args: never[]);
+}
+
 export default CanvasEdges;