@league-of-foundry-developers/foundry-vtt-types 9.280.1 → 12.331.1-beta

package/src/foundry/client/apps/sidebar/apps/compendium.d.mts

@@ -0,0 +1,93 @@
+export {};
+
+declare global {
+  /**
+   * An interface for displaying the content of a CompendiumCollection.
+   * @typeParam Metadata - The metadata of the compendium
+   * @typeParam Options  - The type of the options object
+   */
+  class Compendium<
+    Metadata extends CompendiumCollection.Metadata,
+    Options extends Compendium.Options<Metadata> = Compendium.Options<Metadata>,
+  > extends DocumentDirectory<"Compendium", Options> {
+    /**
+     * @param options    - Compendium configuration options.
+     */
+    constructor(options: Partial<Options>);
+
+    collection: CompendiumCollection<Metadata>;
+
+    override get entryType(): Metadata["type"];
+
+    static override entryPartial: string;
+
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   template: "templates/apps/compendium.html",
+     *   width: 350,
+     *   height: window.innerHeight - 100,
+     *   top: 70,
+     *   left: 120,
+     *   popOut: true
+     * });
+     * ```
+     */
+    static override get defaultOptions(): ApplicationOptions;
+
+    override get id(): string;
+
+    override get title(): string;
+
+    override get tabName(): string;
+
+    override get canCreateEntry(): boolean;
+
+    override get canCreateFolder(): boolean;
+
+    /**
+     * A convenience redirection back to the metadata object of the associated CompendiumCollection
+     */
+    get metadata(): this["collection"]["metadata"];
+
+    override initialize(): void;
+
+    override render(force?: boolean, options?: Application.RenderOptions<ApplicationOptions>): unknown;
+
+    // TODO: Implement GetDataReturnType
+    override getData(options?: Partial<Options>): Promise<object>;
+
+    protected override _entryAlreadyExists(entry: DirectoryMixinEntry): boolean;
+
+    protected override _createDroppedEntry(entry: DirectoryMixinEntry, folderId?: string): Promise<DirectoryMixinEntry>;
+
+    protected override _getEntryDragData(entryId: string): { type: string; uuid: string };
+
+    protected override _onCreateEntry(event: PointerEvent): Promise<void>;
+
+    /**
+     * Handle clicks on a footer button
+     * @param event - The originating pointer event
+     * @internal
+     */
+    _onClickFooterButton(event: PointerEvent): AdventureExporter | void;
+
+    protected _getDocumentDragData(documentId: string): { type: string; uuid: string };
+
+    protected override _getFolderDragData(folderId: string): { type: "Folder"; uuid: string };
+
+    protected override _getFolderContextOptions(): ContextMenuEntry[];
+
+    protected override _getEntryContextOptions(): ContextMenuEntry[];
+  }
+
+  namespace Compendium {
+    type Any = Compendium<any, any>;
+
+    interface Options<Metadata extends CompendiumCollection.Metadata = CompendiumCollection.Metadata>
+      extends DocumentDirectoryOptions {
+      collection: CompendiumCollection<Metadata>;
+    }
+  }
+}

package/src/foundry/client/apps/sidebar/apps/index.d.mts

@@ -0,0 +1,10 @@
+import "./chat-popout.d.mts";
+import "./client-settings.d.mts";
+import "./compendium.d.mts";
+import "./invitation-links.d.mts";
+import "./keybindings-config.d.mts";
+import "./module-management.d.mts";
+import "./permission-config.d.mts";
+import "./support-details.d.mts";
+import "./tours-management.d.mts";
+import "./world-config.d.mts";

package/src/foundry/client/apps/sidebar/apps/invitation-links.d.mts

@@ -0,0 +1,32 @@
+export {};
+
+declare global {
+  /**
+   * Game Invitation Links Reference
+   *
+   * @typeParam Options - the type of the options object
+   */
+  class InvitationLinks<Options extends ApplicationOptions = ApplicationOptions> extends Application<Options> {
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   id: "invitation-links",
+     *   template: "templates/sidebar/apps/invitation-links.html",
+     *   title: game.i18n.localize("INVITATIONS.Title"),
+     *   width: 400
+     * })
+     * ```
+     */
+    static override get defaultOptions(): ApplicationOptions;
+
+    // TODO: Implement GetDataReturnType
+    override getData(options?: Partial<Options>): Promise<object>;
+
+    override activateListeners(html: JQuery): void;
+  }
+
+  namespace InvitationLinks {
+    type Any = InvitationLinks<any>;
+  }
+}

package/src/foundry/client/apps/sidebar/apps/keybindings-config.d.mts

@@ -0,0 +1,180 @@
+import type { MaybePromise } from "../../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * Allows for viewing and editing of Keybinding Actions
+   */
+  class KeybindingsConfig<
+    Options extends PackageConfiguration.Options = PackageConfiguration.Options,
+  > extends PackageConfiguration<Options> {
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   title: game.i18n.localize("SETTINGS.Keybindings"),
+     *   id: "keybindings",
+     *   categoryTemplate: "templates/sidebar/apps/keybindings-config-category.html",
+     *   scrollY: [".scrollable"]
+     * });
+     * ```
+     */
+    static override get defaultOptions(): PackageConfiguration.Options;
+
+    /**
+     * @returns ["all", "core", "core-mouse", "system", "module", "unmapped"]
+     */
+    static override get categoryOrder(): string[];
+
+    protected override _categorizeEntry(namespace: string): PackageConfiguration.Category;
+
+    protected override _prepareCategoryData(): PackageConfiguration.CategoryData;
+
+    /**
+     * Add faux-keybind actions that represent the possible Mouse Controls
+     * @param categories - The current Map of Categories to add to
+     * @returns The number of Actions added
+     * @internal
+     */
+    protected _addMouseControlsReference(categories: Map<string, KeybindingsConfig.Category>): number;
+
+    /**
+     * Given an Binding and its parent Action, detects other Actions that might conflict with that binding
+     * @param actionId - The namespaced Action ID the Binding belongs to
+     * @param action   - The Action config
+     * @param binding  - The Binding
+     * @internal
+     */
+    protected _detectConflictingActions(
+      actionId: string,
+      action: KeybindingActionConfig,
+      binding: KeybindingActionBinding,
+    ): KeybindingAction[];
+
+    /**
+     * Transforms a Binding into a human readable string representation
+     * @param binding - The Binding
+     * @returns A human readable string
+     * @internal
+     */
+    protected static _humanizeBinding(binding: KeybindingActionBinding): string;
+
+    override activateListeners(html: JQuery): void;
+
+    protected override _onResetDefaults(event: JQuery.ClickEvent): Promise<void>;
+
+    /**
+     * Handle Control clicks
+     * @internal
+     */
+    protected _onClickBindingControl(event: MouseEvent): MaybePromise<void>;
+
+    /**
+     * Handle left-click events to show / hide a certain category
+     * @internal
+     */
+    protected _onClickAdd(event: MouseEvent): Promise<void>;
+
+    /**
+     * Handle left-click events to show / hide a certain category
+     * @internal
+     */
+    protected _onClickDelete(event: MouseEvent): Promise<void>;
+
+    /**
+     * Inserts a Binding into the Pending Edits object, creating a new Map entry as needed
+     * @internal
+     */
+    protected _addPendingEdit(
+      namespace: string,
+      action: string,
+      bindingIndex: number,
+      binding: KeybindingsConfig.PendingBinding,
+    ): void;
+
+    /**
+     * Toggle visibility of the Edit / Save UI
+     * @internal
+     */
+    protected _onClickEditableBinding(event: MouseEvent): void;
+
+    /**
+     * Toggle visibility of the Edit UI
+     * @internal
+     */
+    protected _onDoubleClickKey(event: MouseEvent): void;
+
+    /**
+     * Save the new Binding value and update the display of the UI
+     * @internal
+     */
+    protected _onClickSaveBinding(event: MouseEvent): Promise<void>;
+
+    /**
+     * Given a clicked Action element, finds the parent Action
+     * @internal
+     */
+    protected _getParentAction(event: KeyboardEvent | MouseEvent): {
+      actionId: string;
+      actionHtml: HTMLElement;
+      namespace: string;
+      action: string;
+    };
+
+    /**
+     * Given a Clicked binding control element, finds the parent Binding
+     * @internal
+     */
+    protected _getParentBinding(event: KeyboardEvent | MouseEvent): { bindingHtml: HTMLElement; bindingId: string };
+
+    /**
+     * Iterates over all Pending edits, merging them in with unedited Bindings and then saving and resetting the UI
+     * @internal
+     */
+    protected _savePendingEdits(): Promise<void>;
+
+    /**
+     * Processes input from the keyboard to form a list of pending Binding edits
+     * @param event - The keyboard event
+     * @internal
+     */
+    protected _onKeydownBindingInput(event: KeyboardEvent): void;
+
+    /** @remarks KeybindingsConfig does not implement this method. */
+    protected _updateObject(event?: unknown, formData?: unknown): Promise<never>;
+  }
+
+  namespace KeybindingsConfig {
+    type Any = KeybindingsConfig<any>;
+
+    interface Category extends PackageConfiguration.Category {
+      actions: ActionData[];
+      count: number;
+    }
+
+    interface CategoryData extends PackageConfiguration.CategoryData<Category> {}
+
+    interface ActionData extends KeybindingActionConfig {
+      category: string;
+      bindings: DisplayBinding[];
+      id: string;
+      name: string;
+      hint?: string;
+      cssClass?: string;
+      notes: string;
+    }
+
+    interface DisplayBinding extends Partial<KeybindingActionBinding> {
+      id: string;
+      display: string;
+      cssClasses: string;
+      isEditable: boolean;
+      isFirst: boolean;
+      conflicts: string;
+      hasConflicts: boolean;
+    }
+
+    interface PendingBinding extends KeybindingActionBinding {
+      index: number;
+    }
+  }
+}

package/src/foundry/client/apps/sidebar/apps/module-management.d.mts

@@ -0,0 +1,135 @@
+import type { MaybePromise } from "../../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * The Module Management Application.
+   * This application provides a view of which modules are available to be used and allows for configuration of the
+   * set of modules which are active within the World.
+   * @typeParam Options - The type of the options object
+   */
+  class ModuleManagement<Options extends FormApplicationOptions = FormApplicationOptions> extends FormApplication<
+    Options,
+    undefined
+  > {
+    /**
+     * @param options - Module Management application options.
+     */
+    constructor(options: Partial<Options>);
+
+    /** @internal */
+    protected _filter: ModuleManagement.FilterName;
+
+    /**
+     * @defaultValue `true`
+     * @internal
+     */
+    protected _expanded: boolean;
+
+    /**
+     * The named game setting which persists module configuration.
+     */
+    static CONFIG_SETTING: "moduleConfiguration";
+
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   title: game.i18n.localize("MODMANAGE.Title"),
+     *   id: "module-management",
+     *   template: "templates/sidebar/apps/module-management.html",
+     *   popOut: true,
+     *   width: 680,
+     *   height: "auto",
+     *   scrollY: [".package-list"],
+     *   closeOnSubmit: false,
+     *   filters: [{inputSelector: 'input[name="search"]', contentSelector: ".package-list"}]
+     * });
+     * ```
+     */
+    static override get defaultOptions(): FormApplicationOptions;
+
+    override get isEditable(): boolean;
+
+    // TODO: Implement GetDataReturnType
+    override getData(options?: Partial<Options>): MaybePromise<object>;
+
+    /**
+     * Given a module, determines if it meets minimum and maximum compatibility requirements of its dependencies.
+     * If not, it is marked as being unable to be activated.
+     * If the package does not meet verified requirements, it is marked with a warning instead.
+     * @param module - The module.
+     */
+    protected _evaluateDependencies(module: Module): void;
+
+    /**
+     * Given a module, determine if it meets the minimum and maximum system compatibility requirements.
+     * @param module - The module.
+     */
+    protected _evaluateSystemCompatibility(module: Module): void;
+
+    override activateListeners(html: JQuery): void;
+
+    protected override _renderInner(data: ReturnType<this["getData"]>): Promise<JQuery>;
+
+    protected override _getSubmitData(updateData?: object | null): ModuleManagement.FormData;
+
+    protected override _updateObject(
+      event: Event,
+      formData: ModuleManagement.FormData,
+    ): Promise<Record<string, boolean> | number>;
+
+    /**
+     * Handle changes to a module checkbox to prompt for whether or not to enable dependencies
+     * @internal
+     */
+    protected _onChangeCheckbox(event: JQuery.ChangeEvent): Promise<unknown>;
+
+    // #checkImpactedDependency
+    // #checkUpstreamPackages
+
+    /**
+     * Indicate if any Documents would become unavailable if the module were disabled, and confirm if the user wishes to
+     * proceed.
+     * @param module - The module being disabled.
+     * @returns A Promise which resolves to true if disabling should continue.
+     */
+    protected _confirmDocumentsUnavailable(module: Module): Promise<boolean>;
+
+    /**
+     * Handle a button-click to deactivate all modules
+     * @internal
+     */
+    protected _onDeactivateAll(event: JQuery.ClickEvent): void;
+
+    /**
+     * Handle expanding or collapsing the display of descriptive elements
+     * @internal
+     */
+    protected _onExpandCollapse(event: JQuery.ClickEvent): void;
+
+    /**
+     * Handle a button-click to deactivate all modules
+     * @internal
+     */
+    protected _onFilterList(event: JQuery.ClickEvent): void;
+
+    protected override _onSearchFilter(event: KeyboardEvent, query: string, rgx: RegExp, html: HTMLElement): void;
+
+    /**
+     * Format a document count collection for display.
+     * @param counts   - An object of sub-type counts.
+     * @param isActive - Whether the module is active.
+     */
+    protected _formatDocumentSummary(counts: ModuleSubTypeCounts, isActive: boolean): string;
+  }
+
+  namespace ModuleManagement {
+    type Any = ModuleManagement<any>;
+
+    type FilterName = "all" | "active" | "inactive";
+
+    type FormData = Record<string, boolean> & {
+      search: string;
+    };
+  }
+}

package/src/foundry/client/apps/sidebar/apps/permission-config.d.mts

@@ -0,0 +1,72 @@
+export {};
+
+declare global {
+  /**
+   * An application for configuring the permissions which are available to each User role.
+   */
+  class PermissionConfig<Options extends FormApplicationOptions = FormApplicationOptions> extends FormApplication<
+    Options,
+    undefined
+  > {
+    /**
+     * @defaultValue
+     * ```typescript
+     * mergeObject(super.defaultOptions, {
+     *   title: game.i18n.localize("PERMISSION.Title"),
+     *   id: "permissions-config",
+     *   template: "templates/sidebar/apps/permission-config.html",
+     *   width: 660,
+     *   height: "auto",
+     *   scrollY: [".permissions-list"],
+     *   closeOnSubmit: true
+     * })
+     * ```
+     */
+    static override get defaultOptions(): FormApplicationOptions;
+
+    // TODO: Implement GetDataReturnType
+    override getData(options?: Partial<FormApplicationOptions>): Promise<object>;
+
+    /**
+     * Prepare the permissions object used to render the configuration template
+     * @param current - The current permission configuration
+     * @returns Permission data for sheet rendering
+     * @internal
+     */
+    protected _getPermissions(current: Game.Permissions): PermissionConfig.Permission[];
+
+    override activateListeners(html: JQuery): void;
+
+    /**
+     * Handle button click to reset default settings
+     * @param event - The initial button click event
+     */
+    protected _onResetDefaults(event: JQuery.ClickEvent): Promise<Application>;
+
+    protected override _onSubmit(
+      event: Event,
+      options?: FormApplication.OnSubmitOptions,
+    ): ReturnType<FormApplication["_onSubmit"]>;
+
+    protected override _updateObject(event: Event, formData: PermissionConfig.FormData): Promise<void>;
+  }
+
+  namespace PermissionConfig {
+    type Any = PermissionConfig<any>;
+
+    type FormData = Record<string, boolean>;
+
+    interface Permission extends foundry.CONST.UserPermission {
+      id: string;
+      roles: Permission.Role[];
+    }
+
+    namespace Permission {
+      interface Role {
+        name: string;
+        value: boolean;
+        disabled: boolean;
+      }
+    }
+  }
+}

package/src/foundry/client/apps/sidebar/apps/support-details.d.mts

@@ -0,0 +1,121 @@
+import type { MaybePromise } from "../../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * Support Info and Report
+   * @typeParam Options - the type of the options object
+   */
+  class SupportDetails<Options extends ApplicationOptions = ApplicationOptions> extends Application<Options> {
+    /**
+     * @defaultValue
+     * ```typescript
+     * const options = super.defaultOptions;
+     * options.title = "SUPPORT.Title";
+     * options.id = "support-details";
+     * options.template = "templates/sidebar/apps/support-details.html";
+     * options.width = 780;
+     * options.height = 680;
+     * options.resizable = true;
+     * options.classes = ["sheet"];
+     * options.tabs = [{navSelector: ".tabs", contentSelector: "article", initial: "support"}];
+     * return options;
+     * ```
+     */
+    static override get defaultOptions(): ApplicationOptions;
+
+    /**
+     * Returns the support report data
+     */
+    // TODO: Implement GetDataReturnType
+    getData(options?: Partial<Options>): MaybePromise<object>;
+
+    /**
+     * Binds the Support Report copy button
+     */
+    override activateListeners(html: JQuery): void;
+
+    protected override _render(force?: boolean, options?: Application.RenderOptions): Promise<void>;
+
+    /**
+     * @internal
+     */
+    protected override _renderInner(data: ReturnType<this["getData"]>): Promise<JQuery>;
+
+    /**
+     * Handle a button click action.
+     * @param event - The click event
+     */
+    protected _onClickAction(event: MouseEvent): void;
+
+    /**
+     * Copy the support details report to clipboard.
+     */
+    protected _copyReport(): void;
+
+    /**
+     * Marshal information on Documents that failed validation and format it for display.
+     */
+    protected _getDocumentValidationErrors(): {
+      label: string;
+      documents: {
+        name: string;
+        validationError: string;
+      };
+    }[];
+
+    /**
+     * Marshal package-related warnings and errors and format it for display.
+     */
+    protected _getModuleIssues(): {
+      label: string;
+      issues: {
+        label: string;
+        issues: {
+          severity: "error" | "warning";
+          message: string;
+        }[];
+      }[];
+    }[];
+
+    /**
+     * Collects a number of metrics that is useful for Support
+     */
+    static generateSupportReport(): SupportReportData;
+
+    /**
+     * Get a WebGL renderer information string
+     * @param gl - The rendering context
+     * @returns The unmasked renderer string
+     */
+    static getWebGLRendererInfo(gl: WebGLRenderingContext): string;
+  }
+
+  namespace SupportDetails {
+    type Any = SupportDetails<any>;
+  }
+
+  interface SupportReportData {
+    coreVersion: number;
+    systemVersion: string;
+    activeModuleCount: number;
+    os: string;
+    client: string;
+    gpu: string;
+    maxTextureSize: number | string;
+    sceneDimensions: string;
+    grid: number;
+    padding: number; // note: float in actual code
+    walls: number;
+    lights: number;
+    sounds: number;
+    tiles: number;
+    tokens: number;
+    actors: number;
+    items: number;
+    journals: number;
+    tables: number;
+    playlists: number;
+    packs: number;
+    messages: number;
+  }
+}

package/src/foundry/client/apps/sidebar/apps/tours-management.d.mts

@@ -0,0 +1,54 @@
+import type { MaybePromise } from "../../../../../types/utils.d.mts";
+
+declare global {
+  /** A management app for configuring which Tours are available or have been completed. */
+  class ToursManagement extends PackageConfiguration {
+    /** @remarks This is not implemented in {@link ToursManagement} and will throw. */
+    protected override _updateObject(event: Event, formData?: object): Promise<never>;
+
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   id: "tours-management",
+     *   title: game.i18n.localize("SETTINGS.Tours"),
+     *   categoryTemplate: "templates/sidebar/apps/tours-management-category.html"
+     * });
+     * ```
+     */
+    static override get defaultOptions(): PackageConfiguration.Options;
+
+    override _prepareCategoryData(): ToursManagement.TourCategoryData;
+
+    override activateListeners(html: JQuery<HTMLElement>): void;
+
+    protected override _onResetDefaults(event: JQuery.ClickEvent): void;
+
+    /**
+     * Handle Control clicks
+     * @internal
+     */
+    protected _onClickControl(event: JQuery.ClickEvent): MaybePromise<unknown>;
+  }
+
+  namespace ToursManagement {
+    interface TourData {
+      category: string;
+      id: string;
+      title: string;
+      description: string;
+      cssClass: string;
+      notes: string;
+      status: string;
+      canBePlayed?: boolean;
+      startOrResume?: string;
+    }
+
+    interface Category extends PackageConfiguration.Category {
+      tours: TourData[];
+      count: number;
+    }
+
+    interface TourCategoryData extends PackageConfiguration.CategoryData<Category> {}
+  }
+}