@league-of-foundry-developers/foundry-vtt-types 0.8.9-4 → 0.8.9-8

package/src/foundry/foundry.js/clientDatabaseBackend.d.ts

@@ -0,0 +1,210 @@
+import type { ConfiguredDocumentClassForName } from '../../types/helperTypes';
+import type { Request } from '../common/abstract/backend.mjs';
+import type Document from '../common/abstract/document.mjs';
+
+declare global {
+  /**
+   * The client-side database backend implementation which handles Document modification operations.
+   */
+  class ClientDatabaseBackend extends foundry.abstract.DatabaseBackend {
+    /**
+     * Activate the Socket event listeners used to receive responses from events which modify database documents
+     * @param socket - The active game socket
+     */
+    activateSocketListeners(socket: io.Socket): void;
+
+    /** @override */
+    protected _getDocuments<T extends Document<any, any>>(
+      documentClass: ConstructorOf<T>,
+      request: Request,
+      user: InstanceType<ConfiguredDocumentClassForName<'User'>>
+    ): Promise<T[]>;
+
+    /**
+     * @override
+     * @remarks
+     * Get operations for embedded Documents are currently un-supported.
+     * The returned promise always rejects.
+     */
+    protected _getEmbeddedDocuments<T extends Document<any, any>>(
+      documentClass: ConstructorOf<T>,
+      parent: T extends Document<any, infer U> ? U : never,
+      request: Request,
+      user: InstanceType<ConfiguredDocumentClassForName<'User'>>
+    ): Promise<never>;
+
+    /** @override */
+    protected _createDocuments<T extends Document<any, any>>(
+      documentClass: ConstructorOf<T>,
+      request: Request,
+      user: InstanceType<ConfiguredDocumentClassForName<'User'>>
+    ): Promise<T[]>;
+
+    /** @override */
+    protected _createEmbeddedDocuments<T extends Document<any, any>>(
+      documentClass: ConstructorOf<T>,
+      parent: T extends Document<any, infer U> ? U : never,
+      request: Request,
+      user: InstanceType<ConfiguredDocumentClassForName<'User'>>
+    ): Promise<T[]>;
+
+    /**
+     * Perform a standardized pre-creation workflow for all Document types. For internal use only.
+     * @internal
+     */
+    protected _preCreateDocumentArray<T extends Document<any, any>>(
+      documentClass: ConstructorOf<T>,
+      {
+        data,
+        options,
+        pack,
+        parent,
+        user
+      }: Pick<Request, 'data' | 'pack' | 'parent' | 'options'> & {
+        user: InstanceType<ConfiguredDocumentClassForName<'User'>>;
+      }
+    ): Promise<T[]>;
+
+    /**
+     * Handle a SocketResponse from the server when one or multiple documents were created
+     * @param response - The provided Socket response
+     * @returns An Array of created Document instances
+     */
+    protected _handleCreateDocuments(response: SocketResponse): foundry.abstract.Document<any, any>[];
+
+    /**
+     * Handle a SocketResponse from the server when one or multiple documents were created
+     * @param response - The provided Socket response
+     * @returns An Array of created Document instances
+     */
+    protected _handleCreateEmbeddedDocuments(response: SocketResponse): foundry.abstract.Document<any, any>[];
+
+    /**
+     * Perform a standardized post-creation workflow for all Document types. For internal use only.
+     * @returns An array of callback operations to perform once every Document is created
+     * @internal
+     */
+    protected _postCreateDocumentCallbacks(
+      type: string,
+      collection: Collection<foundry.abstract.Document<any, any>>,
+      result: object[],
+      { options, userId, parent, pack }: Pick<Request, 'options' | 'parent' | 'pack'> & { userId?: string }
+    ): (() => void)[];
+
+    /** @override */
+    protected _updateDocuments<T extends Document<any, any>>(
+      documentClass: ConstructorOf<T>,
+      request: Request,
+      user: InstanceType<ConfiguredDocumentClassForName<'User'>>
+    ): Promise<T[]>;
+
+    /** @override */
+    protected _updateEmbeddedDocuments<T extends Document<any, any>>(
+      documentClass: ConstructorOf<T>,
+      parent: T extends Document<any, infer U> ? U : never,
+      request: Request,
+      user: InstanceType<ConfiguredDocumentClassForName<'User'>>
+    ): Promise<T[]>;
+
+    /**
+     * Perform a standardized pre-update workflow for all Document types. For internal use only.
+     * @internal
+     */
+    protected _preUpdateDocumentArray<T extends Document<any, any>>(
+      collection: Collection<T>,
+      {
+        updates,
+        options,
+        user
+      }: Pick<Request, 'updates' | 'options'> & {
+        user: InstanceType<ConfiguredDocumentClassForName<'User'>>;
+      }
+    ): Promise<T[]>;
+
+    /**
+     * Handle a SocketResponse from the server when one or multiple documents were updated
+     * @param response - The provided Socket response
+     * @returns An Array of updated Document instances
+     */
+    protected _handleUpdateDocuments(response: SocketResponse): foundry.abstract.Document<any, any>[];
+
+    /**
+     * Handle a SocketResponse from the server when embedded Documents are updated in a parent Document.
+     * @param response - The provided Socket response
+     * @returns An Array of updated Document instances
+     */
+    protected _handleUpdateEmbeddedDocuments(response: SocketResponse): foundry.abstract.Document<any, any>[];
+
+    /**
+     * Perform a standardized post-update workflow for all Document types. For internal use only.
+     * @returns An array of callback operations to perform after every Document is updated
+     * @internal
+     */
+    protected _postUpdateDocumentCallbacks(
+      collection: Collection<foundry.abstract.Document<any, any>>,
+      result: object[],
+      { options, userId }: Pick<Request, 'options'> & { userId?: string }
+    ): () => void;
+
+    /** @override */
+    protected _deleteDocuments<T extends Document<any, any>>(
+      documentClass: ConstructorOf<T>,
+      request: Request,
+      user: InstanceType<ConfiguredDocumentClassForName<'User'>>
+    ): Promise<T[]>;
+
+    /** @override */
+    protected _deleteEmbeddedDocuments<T extends Document<any, any>>(
+      documentClass: ConstructorOf<T>,
+      parent: T extends Document<any, infer U> ? U : never,
+      request: Request,
+      user: InstanceType<ConfiguredDocumentClassForName<'User'>>
+    ): Promise<T[]>;
+
+    /**
+     * Perform a standardized pre-delete workflow for all Document types. For internal use only.
+     * @internal
+     */
+    protected _preDeleteDocumentArray<T extends Document<any, any>>(
+      collection: Collection<T>,
+      {
+        ids,
+        options,
+        user
+      }: Pick<Request, 'ids' | 'options'> & { user: InstanceType<ConfiguredDocumentClassForName<'User'>> }
+    ): Promise<T[]>;
+
+    /**
+     * Handle a SocketResponse from the server where Documents are deleted.
+     * @param response - The provided Socket response
+     * @returns An Array of deleted Document instances
+     */
+    protected _handleDeleteDocuments(response: SocketResponse): foundry.abstract.Document<any, any>[];
+
+    /**
+     * Handle a SocketResponse from the server when embedded Documents are deleted from a parent Document.
+     * @param response - The provided Socket response
+     * @returns An Array of deleted Document instances
+     */
+    protected _handleDeleteEmbeddedDocuments(response: SocketResponse): foundry.abstract.Document<any, any>[];
+
+    /**
+     * Perform a standardized post-deletion workflow for all Document types. For internal use only.
+     * @returns An array of callback operations to perform after every Document is deleted
+     * @internal
+     */
+    protected _postDeleteDocumentCallbacks(
+      collection: Collection<foundry.abstract.Document<any, any>>,
+      result: object[],
+      { options, userId }: Pick<Request, 'options'> & { userId?: string }
+    ): (() => void)[];
+
+    /** @override */
+    getFlagScopes(): string[];
+
+    /** @override */
+    getCompendiumScopes(): string[];
+  }
+}
+
+export {};

package/src/foundry/foundry.js/clientDocumentMixin.d.ts

@@ -339,7 +339,7 @@ export declare class ClientDocumentMixin<T extends foundry.abstract.Document<any
     T['data']['_source'],
     '_id' | 'folder' | 'permission'
   > & {
-    permission?: T extends { toObject(): infer U } ? U : never;
+    permission?: T['data']['_source']['permission'];
   };
 
   /**

package/src/foundry/foundry.js/clientDocuments/canvasDocuments/index.d.ts

@@ -0,0 +1,8 @@
+import './ambientLightDocument';
+import './ambientSoundDocument';
+import './drawingDocument';
+import './measuredTemplateDocument';
+import './noteDocument';
+import './tileDocument';
+import './tokenDocument';
+import './wallDocument';

package/src/foundry/foundry.js/clientDocuments/canvasDocuments/tokenDocument.d.ts

@@ -204,7 +204,7 @@ declare global {
     /**
      * Inspect the Actor data model and identify the set of attributes which could be used for a Token Bar
      */
-    static getTrackedAttributeChoices(attributes?: TrackedAttributes): Partial<Record<string, string[]>>;
+    static getTrackedAttributeChoices(attributes?: TrackedAttributes): Record<string, string[]>;
   }
 }
 

package/src/foundry/foundry.js/clientDocuments/index.d.ts

@@ -0,0 +1,19 @@
+import './activeEffect';
+import './actor';
+import './canvasDocuments';
+import './chatMessage';
+import './combat';
+import './combatant';
+import './fogExploration';
+import './folder';
+import './item';
+import './journalEntry';
+import './macro';
+import './playlist';
+import './playlistSound';
+import './prototypeToken';
+import './rollTable';
+import './scene';
+import './setting';
+import './tableResult';
+import './user';

package/src/foundry/foundry.js/clientDocuments/playlist.d.ts

@@ -1,7 +1,9 @@
-// TODO
+import type { ConfiguredDocumentClass, ConstructorDataType } from '../../../types/helperTypes';
+import type { DocumentModificationOptions } from '../../common/abstract/document.mjs';
+
 declare global {
   /**
-   * The client-side Playlist document which extends the common BasePlaylist abstraction.
+   * The client-side Playlist document which extends the common BasePlaylist model.
    * Each Playlist document contains PlaylistData which defines its data schema.
    *
    * @see {@link data.PlaylistData}               The Playlist data schema
@@ -9,9 +11,196 @@ declare global {
    * @see {@link embedded.PlaylistSound}          The PlaylistSound embedded document within a parent Playlist
    * @see {@link applications.PlaylistConfig}     The Playlist configuration application
    *
-   * @param data - Initial data provided to construct the Playlist document
    */
-  class Playlist extends ClientDocumentMixin(foundry.documents.BasePlaylist) {}
-}
+  class Playlist extends ClientDocumentMixin(foundry.documents.BasePlaylist) {
+    /**
+     * @param data - Initial data provided to construct the Playlist document
+     */
+    constructor(
+      data: ConstructorParameters<typeof foundry.documents.BasePlaylist>[0],
+      context?: ConstructorParameters<typeof foundry.documents.BasePlaylist>[1]
+    );
+
+    /**
+     * Each sound which is played within the Playlist has a created Sound instance.
+     * The keys of this object are the sound IDs and the values are the Sound instances.
+     * @remarks This seems to be unused and will always be the empty object, see https://gitlab.com/foundrynet/foundryvtt/-/issues/5970
+     */
+    audio: {};
+
+    /**
+     * Playlists may have a playback order which defines the sequence of Playlist Sounds
+     * @defaultValue `undefined`
+     * @internal
+     */
+    protected _playbackOrder: string[] | undefined;
+
+    /**
+     * The playback mode for the Playlist instance
+     */
+    get mode(): foundry.CONST.PlaylistMode;
+
+    /**
+     * The order in which sounds within this playlist will be played (if sequential or shuffled)
+     * Uses a stored seed for randomization to guarantee that all clients generate the same random order.
+     */
+    get playbackOrder(): string[];
+
+    /**
+     * An indicator for whether any Sound within the Playlist is currently playing
+     */
+    get playing(): boolean;
+
+    /** @override */
+    get visible(): boolean;
+
+    /**
+     * Begin simultaneous playback for all sounds in the Playlist.
+     * @returns The updated Playlist entity
+     */
+    playAll(): Promise<InstanceType<ConfiguredDocumentClass<typeof Playlist>> | undefined>;
+
+    /**
+     * Play the next Sound within the sequential or shuffled Playlist.
+     * @param soundId - The currently playing sound ID, if known
+     * @param options - Additional options which configure the next track
+     * @returns The updated Playlist document
+     */
+    playNext(
+      soundId?: string,
+      options?: Partial<Playlist.PlayNextOptions>
+    ): Promise<InstanceType<ConfiguredDocumentClass<typeof Playlist>> | undefined | null>;
+
+    /**
+     * Begin playback of a specific Sound within this Playlist.
+     * Determine which other sounds should remain playing, if any.
+     * @param sound - The desired sound that should play
+     * @returns The updated Playlist
+     */
+    playSound(
+      sound: InstanceType<ConfiguredDocumentClass<typeof PlaylistSound>>
+    ): Promise<InstanceType<ConfiguredDocumentClass<typeof Playlist>> | undefined>;
+
+    /**
+     * Stop playback of a specific Sound within this Playlist.
+     * Determine which other sounds should remain playing, if any.
+     * @param sound - The desired sound that should play
+     * @returns The updated Playlist
+     */
+    stopSound(
+      sound: InstanceType<ConfiguredDocumentClass<typeof PlaylistSound>>
+    ): Promise<InstanceType<ConfiguredDocumentClass<typeof Playlist>> | undefined>;
+
+    /**
+     * End playback for any/all currently playing sounds within the Playlist.
+     * @returns The updated Playlist entity
+     */
+    stopAll(): Promise<InstanceType<ConfiguredDocumentClass<typeof Playlist>> | undefined>;
+
+    /**
+     * Cycle the playlist mode
+     * @returns A promise which resolves to the updated Playlist instance
+     */
+    cycleMode(): Promise<InstanceType<ConfiguredDocumentClass<typeof Playlist>> | undefined>;
 
-export {};
+    /**
+     * Get the next sound in the cached playback order. For internal use.
+     * @internal
+     */
+    protected _getNextSound(soundId: string): InstanceType<ConfiguredDocumentClass<typeof PlaylistSound>> | undefined;
+
+    /**
+     * Get the previous sound in the cached playback order. For internal use.
+     * @internal
+     */
+    protected _getPreviousSound(
+      soundId: string
+    ): InstanceType<ConfiguredDocumentClass<typeof PlaylistSound>> | undefined;
+
+    /**
+     * Define the sorting order for the Sounds within this Playlist. For internal use.
+     * @internal
+     */
+    protected _sortSounds(
+      a: InstanceType<ConfiguredDocumentClass<typeof PlaylistSound>>,
+      b: InstanceType<ConfiguredDocumentClass<typeof PlaylistSound>>
+    ): number;
+
+    /** @override */
+    protected _preUpdate(
+      changed: DeepPartial<ConstructorDataType<foundry.data.PlaylistData>>,
+      options: DocumentModificationOptions,
+      user: foundry.documents.BaseUser
+    ): Promise<void>;
+
+    /** @override */
+    protected _onUpdate(
+      changed: DeepPartial<foundry.data.PlaylistData['_source']>,
+      options: DocumentModificationOptions,
+      userId: string
+    ): void;
+
+    /** @override */
+    protected _onDelete(options: DocumentModificationOptions, userId: string): void;
+
+    /** @override */
+    protected _onCreateEmbeddedDocuments(
+      embeddedName: string,
+      documents: foundry.abstract.Document<any, any>[],
+      result: Record<string, unknown>[],
+      options: DocumentModificationOptions,
+      userId: string
+    ): void;
+
+    /** @override */
+    protected _onUpdateEmbeddedDocuments(
+      embeddedName: string,
+      documents: foundry.abstract.Document<any, any>[],
+      result: Record<string, unknown>[],
+      options: DocumentModificationContext,
+      userId: string
+    ): void;
+
+    /** @override */
+    protected _onDeleteEmbeddedDocuments(
+      embeddedName: string,
+      documents: foundry.abstract.Document<any, any>[],
+      result: string[],
+      options: DocumentModificationContext,
+      userId: string
+    ): void;
+
+    /**
+     * Handle callback logic when an individual sound within the Playlist concludes playback naturally
+     * @internal
+     */
+    _onSoundEnd(
+      sound: InstanceType<ConfiguredDocumentClass<typeof PlaylistSound>>
+    ): Promise<InstanceType<ConfiguredDocumentClass<typeof Playlist>> | undefined>;
+
+    /**
+     * Handle callback logic when playback for an individual sound within the Playlist is started.
+     * Schedule auto-preload of next track
+     * @internal
+     */
+    _onSoundStart(sound: InstanceType<ConfiguredDocumentClass<typeof PlaylistSound>>): Promise<void>;
+
+    /** @override */
+    toCompendium(pack?: CompendiumCollection<CompendiumCollection.Metadata>): Omit<
+      foundry.data.PlaylistData['_source'],
+      '_id' | 'folder' | 'permission'
+    > & {
+      permission?: foundry.data.PlaylistData['_source']['permission'];
+    };
+  }
+
+  namespace Playlist {
+    interface PlayNextOptions {
+      /**
+       * Whether to advance forward (if 1) or backwards (if -1)
+       * @defaultValue `1`
+       */
+      direction: 1 | -1;
+    }
+  }
+}

package/src/foundry/foundry.js/clientDocuments/playlistSound.d.ts

@@ -0,0 +1,113 @@
+import type { ConfiguredDocumentClassForName } from '../../../types/helperTypes';
+import type { DocumentModificationOptions } from '../../common/abstract/document.mjs';
+
+declare global {
+  /**
+   * The client-side PlaylistSound document which extends the common BasePlaylistSound model.
+   * Each PlaylistSound belongs to the sounds collection of a Playlist entity.
+   * Each PlaylistSound contains a PlaylistSoundData object which provides its source data.
+   *
+   * @see {@link foundry.data.PlaylistSoundData} The PlaylistSound data schema
+   * @see {@link Playlist}                       The Playlist document which contains PlaylistSound embedded documents
+   * @see {@link Sound}                          The Sound API which manages web audio playback
+   *
+   */
+  class PlaylistSound extends ClientDocumentMixin(foundry.documents.BasePlaylistSound) {
+    /**
+     * @param data   - Initial data provided to construct the PlaylistSound document
+     * @param parent - The parent Playlist document to which this result belongs
+     */
+    constructor(
+      data: ConstructorParameters<typeof foundry.documents.BasePlaylistSound>[0],
+      context?: ConstructorParameters<typeof foundry.documents.BasePlaylistSound>[1]
+    );
+
+    /**
+     * The Sound which manages playback for this playlist sound
+     */
+    sound: Sound | null;
+
+    /**
+     * A debounced function, accepting a single volume parameter to adjust the volume of this sound
+     * @param volume - The desired volume level
+     */
+    debounceVolume: (volume: number) => void;
+
+    /**
+     * The debounce tolerance for processing rapid volume changes into database updates in milliseconds
+     * @defaultValue `100`
+     */
+    static VOLUME_DEBOUNCE_MS: number;
+
+    /**
+     * Create a Sound used to play this PlaylistSound document
+     * @internal
+     */
+    protected _createSound(): Sound | null;
+
+    /**
+     * A convenience reference to the HTTP path to the source audio file
+     */
+    get path(): string | undefined | null;
+
+    /**
+     * A convenience indicator for whether this sound is currently playing.
+     */
+    get playing(): boolean;
+
+    /**
+     * The effective volume at which this PlaylistSound should be playing, including the global playlist volume modifier
+     */
+    get volume(): number;
+
+    /**
+     * Determine the fade duration for this PlaylistSound based on its own configuration and that of its parent.
+     */
+    get fadeDuration(): number;
+
+    /**
+     * Synchronize playback for this particular PlaylistSound instance
+     */
+    sync(): void | Promise<void> | Promise<Sound>;
+
+    /** @override */
+    protected _onUpdate(
+      changed: DeepPartial<foundry.data.PlaylistSoundData['_source']>,
+      options: DocumentModificationOptions,
+      userId: string
+    ): void;
+
+    /** @override */
+    protected _onDelete(options: DocumentModificationOptions, userId: string): void;
+
+    /**
+     * Special handling that occurs when a PlaylistSound reaches the natural conclusion of its playback.
+     * @internal
+     */
+    protected _onEnd(): Promise<void | InstanceType<ConfiguredDocumentClassForName<'Playlist'>> | undefined>;
+
+    /**
+     * Special handling that occurs when playback of a PlaylistSound is started.
+     * @internal
+     */
+    protected _onStart(): Promise<void>;
+
+    /**
+     * Special handling that occurs when a PlaylistSound is manually stopped before its natural conclusion.
+     * @internal
+     */
+    protected _onStop(): Promise<void>;
+
+    /**
+     * Handle fading in the volume for this sound when it begins to play (or loop)
+     * @internal
+     */
+    protected _fadeIn(sound: Sound): void;
+
+    /**
+     * Handle fading out the volume for this sound when it begins to play (or loop)
+     * @internal
+     */
+    protected _fadeOut(sound: Sound): void;
+  }
+}

package/src/foundry/foundry.js/clientDocuments/prototypeToken.d.ts

@@ -0,0 +1,15 @@
+/**
+ * An extended Document definition used specifically
+ * This ensures that the PrototypeTokenData schema is used instead of the standard TokenData.
+ * This exists specifically for prototype Token configuration in the TokenConfig app and should not be used otherwise.
+ * @internal
+ * @remarks The types for this are incorrect, in particular everything related to the data should use
+ * {@link foundry.data.PrototypeTokenData} instead of {@link foundry.data.TokenData}. However, with the current approach
+ * to type documents, we don't see a way to do this. This class is just added for reference. As the documentation above
+ * says, don't use it (there really shouldn't be a need to do so).
+ */
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+declare class PrototypeTokenDocument extends TokenDocument {
+  static get schema(): typeof foundry.data.PrototypeTokenData;
+}

package/src/foundry/foundry.js/clientSettings.d.ts

@@ -219,7 +219,7 @@ declare namespace ClientSettings {
   }
 
   interface Values {
-    'core.combatTrackerConfig': { resource: string; skipDefeated: boolean };
+    'core.combatTrackerConfig': { resource: string; skipDefeated: boolean } | {};
     'core.compendiumConfiguration': Partial<Record<string, CompendiumCollection.Configuration>>;
     'core.rollMode': foundry.CONST.DiceRollMode;
     'core.animateRollTable': boolean;
@@ -229,6 +229,19 @@ declare namespace ClientSettings {
     'core.globalPlaylistVolume': number;
     'core.globalAmbientVolume': number;
     'core.globalInterfaceVolume': number;
+    'core.moduleConfiguration': Record<string, boolean>;
+    'core.chatBubbles': boolean;
+    'core.chatBubblesPan': boolean;
+    'core.coneTemplateType': 'round' | 'flat';
+    'core.language': string;
+    'core.leftClickRelease': boolean;
+    'core.lightAnimation': boolean;
+    'core.maxFPS': number;
+    'core.mipmap': boolean;
+    'core.noCanvas': boolean;
+    'core.softShadows': boolean;
+    'core.tokenDragPreview': boolean;
+    'core.visionAnimation': boolean;
     [key: string]: unknown;
   }
 }