@league-of-foundry-developers/foundry-vtt-types 0.8.9-6 → 9.238.0

package/src/foundry/foundry.js/applications/formApplications/documentSheets/actorSheet.d.ts

@@ -91,8 +91,11 @@ declare global {
     /** @override */
     protected _onDragStart(event: DragEvent): void;
 
-    /** @override */
-    protected _onDrop(event: DragEvent): Promise<boolean | undefined> | unknown;
+    /**
+     * @override
+     * @internal
+     */
+    protected _onDrop(event: DragEvent): void;
 
     /**
      * Handle the dropping of ActiveEffect data onto an Actor Sheet
@@ -191,7 +194,7 @@ declare global {
 
       interface Folder {
         type: 'Folder';
-        documentName: foundry.CONST.FolderEntityTypes;
+        documentName: foundry.CONST.FOLDER_DOCUMENT_TYPES;
         id: string;
       }
     }

package/src/foundry/foundry.js/applications/formApplications/documentSheets/ambientLightConfig.d.ts

@@ -0,0 +1,104 @@
+import type { ConfiguredDocumentClassForName } from '../../../../../types/helperTypes';
+import type { AmbientLightDataConstructorData } from '../../../../common/data/data.mjs/ambientLightData';
+import type { AnimationDataConstructorData } from '../../../../common/data/data.mjs/animationData';
+import type { DarknessActivationConstructorData } from '../../../../common/data/data.mjs/darknessActivation.js';
+import type { LightDataConstructorData } from '../../../../common/data/data.mjs/lightData.js';
+
+declare global {
+  /**
+   * The Application responsible for configuring a single AmbientLight document within a parent Scene.
+   * @typeParam Options - the type of the options object
+   * @typeParam Data    - The data structure used to render the handlebars template.
+   */
+  class AmbientLightConfig<
+    Options extends DocumentSheet.Options = DocumentSheet.Options,
+    Data extends object = AmbientLightConfig.Data<Options>
+  > extends DocumentSheet<Options, Data, InstanceType<ConfiguredDocumentClassForName<'AmbientLight'>>> {
+    /**
+     * @override
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   id: "ambient-light-config",
+     *   classes: ["sheet", "ambient-light-config"],
+     *   title: "LIGHT.ConfigTitle",
+     *   template: "templates/scene/ambient-light-config.html",
+     *   width: 480,
+     *   height: "auto",
+     *   tabs: [{navSelector: ".tabs", contentSelector: "form", initial: "basic"}]
+     * });
+     * ```
+     */
+    static get defaultOptions(): DocumentSheet.Options;
+
+    /**
+     * @param options - (unused)
+     * @override
+     */
+    getData(options?: Partial<Options>): Data | Promise<Data>;
+
+    /** @override */
+    close(options?: Application.CloseOptions): Promise<void>;
+
+    /** @override */
+    activateListeners(html: JQuery): void;
+
+    /**
+     * Preview the change caused by a change on the form by refreshing the display of the light source
+     */
+    protected _onChangeInput(event: JQuery.ChangeEvent): Promise<void>;
+
+    /** @override */
+    protected _onResetForm(event: PointerEvent): void;
+
+    /** @override */
+    protected _onChangeTab(event: MouseEvent | null, tabs: Tabs, active: string): void;
+
+    /**
+     * @param event - (unused)
+     * @override
+     */
+    protected _updateObject(
+      event: Event,
+      formData: AmbientLightConfig.FormData
+    ): Promise<InstanceType<ConfiguredDocumentClassForName<'AmbientLight'>> | undefined>;
+
+    /**
+     * Refresh the display of the AmbientLight object
+     * @internal
+     */
+    protected _refresh(): void;
+  }
+
+  namespace AmbientLightConfig {
+    interface Data<Options extends DocumentSheet.Options>
+      extends DocumentSheet.Data<InstanceType<ConfiguredDocumentClassForName<'AmbientLight'>>, Options> {
+      isAdvanced: boolean;
+      colorationTechniques: unknown; // FIXME: typeof AdaptiveLightingShader.COLORATION_TECHNIQUES
+      lightAnimations: Record<string, string> & {
+        '': 'None';
+      };
+      submitText: string;
+    }
+
+    interface FormData extends Pick<AmbientLightDataConstructorData, 'x' | 'y' | 'rotation' | 'walls' | 'vision'> {
+      'config.dim': LightDataConstructorData['dim'];
+      'config.bright': LightDataConstructorData['bright'];
+      'config.angle': LightDataConstructorData['angle'];
+      'config.color': LightDataConstructorData['color'];
+      'config.alpha': LightDataConstructorData['alpha'];
+      'config.darkness.min': DarknessActivationConstructorData['min'];
+      'config.darkness.max': DarknessActivationConstructorData['max'];
+      'config.animation.type': AnimationDataConstructorData['type'];
+      'config.animation.speed': AnimationDataConstructorData['speed'];
+      'config.animation.reverse': AnimationDataConstructorData['reverse'];
+      'config.animation.intensity': AnimationDataConstructorData['intensity'];
+      'config.coloration': LightDataConstructorData['coloration'];
+      'config.luminosity': LightDataConstructorData['luminosity'];
+      'config.gradual': LightDataConstructorData['gradual'];
+      'config.saturation': LightDataConstructorData['saturation'];
+      'config.contrast': LightDataConstructorData['contrast'];
+      'config.shadows': LightDataConstructorData['shadows'];
+    }
+  }
+}

package/src/foundry/foundry.js/applications/formApplications/documentSheets/ambientSoundConfig.d.ts

@@ -49,7 +49,7 @@ declare global {
       submitText: string;
     }
 
-    type FormData = Pick<foundry.data.AmbientSoundData, 'easing' | 'path' | 'type' | 'volume'> &
+    type FormData = Pick<foundry.data.AmbientSoundData, 'easing' | 'path' | 'volume'> &
       Pick<AmbientSoundDataConstructorData, 'radius' | 'x' | 'y'>;
 
     type Options = DocumentSheet.Options;

package/src/foundry/foundry.js/applications/formApplications/{folderConfig.d.ts → documentSheets/folderConfig.d.ts}

@@ -1,5 +1,5 @@
-import type { ConfiguredDocumentClass } from '../../../../types/helperTypes';
-import type { SortingModes } from '../../../common/data/data.mjs/folderData';
+import type { ConfiguredDocumentClass } from '../../../../../types/helperTypes';
+import type { SortingModes } from '../../../../common/data/data.mjs/folderData';
 
 declare global {
   /**
@@ -64,7 +64,7 @@ declare global {
       name: string;
       parent: string;
       sorting: SortingModes;
-      type: foundry.CONST.FolderEntityTypes;
+      type: foundry.CONST.FOLDER_DOCUMENT_TYPES;
     }
   }
 }

package/src/foundry/foundry.js/applications/formApplications/documentSheets/index.d.ts

@@ -1,11 +1,15 @@
 import './activeEffectConfig';
 import './actorSheet';
+import './ambientLightConfig';
 import './ambientSoundConfig';
 import './combatantConfig';
+import './folderConfig';
 import './itemSheet';
 import './journalSheet';
 import './lightConfig';
 import './macroConfig';
+import './measuredTemplateConfig';
+import './noteConfig';
 import './permissionControl';
 import './playlistConfig';
 import './playlistSoundConfig';

package/src/foundry/foundry.js/applications/formApplications/documentSheets/lightConfig.d.ts

@@ -1,84 +1,10 @@
-import type { ConfiguredDocumentClassForName } from '../../../../../types/helperTypes';
-import type { AmbientLightDataConstructorData } from '../../../../common/data/data.mjs/ambientLightData';
-import type { AnimationDataConstructorData } from '../../../../common/data/data.mjs/animationData';
-
 declare global {
   /**
-   * The Application responsible for configuring a single AmbientLight document within a parent Scene.
-   * @typeParam Options - the type of the options object
-   * @typeParam Data    - The data structure used to render the handlebars template.
+   * @deprecated since v9
    */
-  class LightConfig<
-    Options extends DocumentSheet.Options = DocumentSheet.Options,
-    Data extends object = LightConfig.Data<Options>
-  > extends DocumentSheet<Options, Data, InstanceType<ConfiguredDocumentClassForName<'AmbientLight'>>> {
-    /**
-     * @override
-     * @defaultValue
-     * ```typescript
-     * foundry.utils.mergeObject(super.defaultOptions, {
-     *   title: "LIGHT.ConfigTitle",
-     *   template: "templates/scene/light-config.html",
-     *   width: 480
-     * });
-     * ```
-     */
-    static get defaultOptions(): DocumentSheet.Options;
-
-    /**
-     * @param options - (unused)
-     * @override
-     */
-    getData(options?: Partial<Options>): Data | Promise<Data>;
-
-    /** @override */
-    close(options?: Application.CloseOptions): Promise<void>;
-
-    /**
-     * Preview the change caused by a change on the form by refreshing the display of the light source
-     */
-    protected _onChangeInput(event: JQuery.ChangeEvent): Promise<void>;
-
-    /** @override */
-    protected _getSubmitData(
-      updateData?: LightConfig.FormData
-    ): ReturnType<DocumentSheet['_getSubmitData']> & { tintAlpha: number };
-
-    /**
-     * @param event - (unused)
-     * @override
-     */
-    protected _updateObject(
-      event: Event,
-      formData: LightConfig.FormData
-    ): Promise<InstanceType<ConfiguredDocumentClassForName<'AmbientLight'>> | undefined>;
-
-    /**
-     * Refresh the display of the AmbientLight object
-     * @internal
-     */
-    protected _refresh(): void;
-  }
-
-  namespace LightConfig {
-    interface Data<Options extends DocumentSheet.Options>
-      extends DocumentSheet.Data<InstanceType<ConfiguredDocumentClassForName<'AmbientLight'>>, Options> {
-      submitText: string;
-      lightTypes: Record<foundry.CONST.SourceType, string>;
-      lightAnimations: Record<string, string> & {
-        '': 'None';
-      };
-      colorIntensity: number;
-    }
-
-    interface FormData
-      extends Pick<
-        AmbientLightDataConstructorData,
-        'angle' | 'bright' | 'darknessThreshold' | 'dim' | 'rotation' | 't' | 'tintAlpha' | 'tintColor' | 'x' | 'y'
-      > {
-      'lightAnimation.intensity': AnimationDataConstructorData['intensity'];
-      'lightAnimation.speed': AnimationDataConstructorData['speed'];
-      'lightAnimation.type': AnimationDataConstructorData['type'];
-    }
+  class LightConfig extends AmbientLightConfig {
+    constructor(...args: ConstructorParameters<typeof AmbientLightConfig>);
   }
 }
+
+export {};

package/src/foundry/foundry.js/applications/formApplications/documentSheets/measuredTemplateConfig.d.ts

@@ -0,0 +1,60 @@
+import type { ConfiguredDocumentClassForName } from '../../../../../types/helperTypes';
+
+declare global {
+  /**
+   * The Application responsible for configuring a single MeasuredTemplate document within a parent Scene.
+   * @see {@link MeasuredTemplate}
+   * @typeParam Options - the type of the options object
+   * @typeParam Data    - The data structure used to render the handlebars template.
+   */
+  class MeasuredTemplateConfig<
+    Options extends DocumentSheet.Options = DocumentSheet.Options,
+    Data extends object = MeasuredTemplateConfig.Data
+  > extends DocumentSheet<Options, Data, InstanceType<ConfiguredDocumentClassForName<'MeasuredTemplate'>>> {
+    /**
+     * @override
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   id: "template-config",
+     *   classes: ["sheet", "template-sheet"],
+     *   title: "Measurement Template Configuration",
+     *   template: "templates/scene/template-config.html",
+     *   width: 400,
+     * })
+     * ```
+     */
+    static get defaultOptions(): DocumentSheet.Options;
+
+    /** @override */
+    getData(): Data | Promise<Data>;
+
+    /** @override */
+    protected _updateObject(
+      event: Event,
+      formData: MeasuredTemplateConfig.FormData
+    ): Promise<InstanceType<ConfiguredDocumentClassForName<'MeasuredTemplate'>> | undefined>;
+  }
+
+  namespace MeasuredTemplateConfig {
+    interface Data<Options extends DocumentSheet.Options = DocumentSheet.Options>
+      extends DocumentSheet.Data<InstanceType<ConfiguredDocumentClassForName<'MeasuredTemplate'>>, Options> {
+      templateTypes: typeof CONFIG.MeasuredTemplate.types;
+      gridUnits: string;
+      submitText: string;
+    }
+
+    type FormData = {
+      angle: number | null;
+      borderColor: string;
+      direction: number | null;
+      distance: number | null;
+      fillColor: string;
+      t: ValueOf<foundry.CONST.MEASURED_TEMPLATE_TYPES>;
+      texture: string;
+      width: number | null;
+      x: number | null;
+      y: number | null;
+    };
+  }
+}

package/src/foundry/foundry.js/applications/formApplications/documentSheets/noteConfig.d.ts

@@ -0,0 +1,72 @@
+import type { ConfiguredDocumentClassForName } from '../../../../../types/helperTypes';
+
+declare global {
+  /**
+   * The Application responsible for configuring a single Note document within a parent Scene.
+   * @typeParam Options - the type of the options object
+   * @typeParam Data    - The data structure used to render the handlebars template.
+   */
+  class NoteConfig<
+    Options extends DocumentSheet.Options = DocumentSheet.Options,
+    Data extends object = NoteConfig.Data<Options>
+  > extends DocumentSheet<Options, Data, InstanceType<ConfiguredDocumentClassForName<'Note'>>> {
+    /**
+     * @override
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   title: game.i18n.localize("NOTE.ConfigTitle"),
+     *   template: "templates/scene/note-config.html",
+     *   width: 400,
+     * })
+     * ```
+     */
+    static get defaultOptions(): DocumentSheet.Options;
+
+    /**
+     * @param options - (unused)
+     * @override
+     */
+    getData(options?: Partial<Options>): Data | Promise<Data>;
+
+    /**
+     * @param event - (unused)
+     * @override
+     */
+    protected _updateObject(
+      event: Event,
+      formData: NoteConfig.FormData
+    ): Promise<ConfiguredDocumentClassForName<'Note'> | undefined>;
+
+    /**
+     * @override
+     */
+    close(options?: Application.CloseOptions): Promise<void>;
+  }
+
+  namespace NoteConfig {
+    interface Data<Options extends DocumentSheet.Options>
+      extends DocumentSheet.Data<InstanceType<ConfiguredDocumentClassForName<'Note'>>, Options> {
+      entry: ConfiguredDocumentClassForName<'JournalEntry'> | {};
+      entries: Journal['contents'];
+      icons: CONFIG['JournalEntry']['noteIcons'];
+      fontFamilies: Record<string, string>;
+      textAnchors: Record<foundry.CONST.TEXT_ANCHOR_POINTS, string>;
+      submitText: string;
+    }
+
+    interface FormData {
+      entryId: string;
+      fontFamily: string;
+      fontSize: number | null;
+      icon: string;
+      iconSize: number | null;
+      iconTint: string;
+      text: string;
+      textAnchor: foundry.CONST.TEXT_ANCHOR_POINTS;
+      textColor: string;
+      x: number | null;
+      y: number | null;
+    }
+  }
+}

package/src/foundry/foundry.js/applications/formApplications/documentSheets/permissionControl.d.ts

@@ -43,14 +43,14 @@ declare global {
   namespace PermissionControl {
     interface Data<ConcreteDocument extends foundry.abstract.Document<any, any>> extends DocumentSheet.Data {
       entity: ConcreteDocument;
-      currentDefault: foundry.CONST.EntityPermission | '-1';
+      currentDefault: foundry.CONST.DOCUMENT_PERMISSION_LEVELS | '-1';
       instructions: string;
-      defaultLevels: Record<foundry.CONST.EntityPermission, string> & { '-1'?: string };
-      playerLevels: Record<foundry.CONST.EntityPermission | '-1', string> & { '-2'?: string };
+      defaultLevels: Record<foundry.CONST.DOCUMENT_PERMISSION_LEVELS, string> & { '-1'?: string };
+      playerLevels: Record<foundry.CONST.DOCUMENT_PERMISSION_LEVELS | '-1', string> & { '-2'?: string };
       isFolder: boolean;
       users: {
         user: InstanceType<ConfiguredDocumentClassForName<'User'>>;
-        level: foundry.CONST.EntityPermission | '-1';
+        level: foundry.CONST.DOCUMENT_PERMISSION_LEVELS | '-1';
       }[];
     }
 
@@ -60,7 +60,7 @@ declare global {
     }
 
     namespace FormData {
-      type InputPermissionLevel = foundry.CONST.EntityPermission | -1 | -2;
+      type InputPermissionLevel = foundry.CONST.DOCUMENT_PERMISSION_LEVELS | -1 | -2;
     }
   }
 }

package/src/foundry/foundry.js/applications/formApplications/documentSheets/playlistConfig.d.ts

@@ -43,7 +43,7 @@ declare global {
   namespace PlaylistConfig {
     interface Data<Options extends DocumentSheet.Options = DocumentSheet.Options>
       extends DocumentSheet.Data<InstanceType<ConfiguredDocumentClass<typeof Playlist>>, Options> {
-      modes: Record<foundry.CONST.PlaylistMode, string>;
+      modes: Record<foundry.CONST.PLAYLIST_MODES, string>;
     }
   }
 }