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

package/src/foundry/client/apps/sidebar/apps/client-settings.d.mts

@@ -0,0 +1,98 @@
+export {};
+
+declare global {
+  /**
+   * The Application responsible for displaying and editing the client and world settings for this world.
+   * This form renders the settings defined via the game.settings.register API which have config = true
+   * @typeParam Options - The type of the options object
+   */
+  class SettingsConfig<
+    Options extends FormApplicationOptions = FormApplicationOptions,
+  > extends PackageConfiguration<Options> {
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   title: game.i18n.localize("SETTINGS.Title"),
+     *   id: "client-settings",
+     *   template: "templates/sidebar/apps/settings-config.html",
+     *   submitButton: true
+     * })
+     * ```
+     */
+    static override get defaultOptions(): (typeof FormApplication)["defaultOptions"];
+
+    override _prepareCategoryData(): SettingsConfig.CategoryData;
+
+    override activateListeners(html: JQuery): void;
+
+    /**
+     * Handle activating the button to configure User Role permissions
+     * @param event - The initial button click event
+     * @internal
+     */
+    protected _onClickSubmenu(event: JQuery.ClickEvent): void;
+
+    /**
+     * Preview font scaling as the setting is changed.
+     * @param event - The triggering event.
+     * @internal
+     */
+    protected _previewFontScaling(event: JQuery.ChangeEvent): void;
+
+    override close(options?: Application.CloseOptions): Promise<void>;
+
+    protected override _updateObject(event: Event, formData: SettingsConfig.FormData): Promise<unknown>;
+
+    /**
+     * Handle button click to reset default settings
+     * @param event - The initial button click event
+     * @internal
+     */
+    protected _onResetDefaults(event: JQuery.ClickEvent): void;
+
+    /**
+     * Confirm if the user wishes to reload the application
+     * @param options - Additional options to configure the prompt
+     */
+    static reloadConfirm(options?: {
+      /**
+       * Whether to reload all connected clients as well.
+       * @defaultValue `false`
+       */
+      world: boolean;
+    }): Promise<void>;
+  }
+
+  namespace SettingsConfig {
+    type Any = SettingsConfig<any>;
+
+    interface Category extends PackageConfiguration.Category {
+      menus: ClientSettings.SettingSubmenuConfig[];
+      settings: SettingConfig[];
+      count: number;
+    }
+
+    interface CategoryData extends PackageConfiguration.CategoryData<Category> {
+      user: Game["user"];
+      canConfigure: boolean;
+    }
+
+    interface FormData {
+      "core.animateRollTable": 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;
+    }
+  }
+}

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: ClientKeybindings.KeybindingActionConfig,
+      binding: ClientKeybindings.KeybindingActionBinding,
+    ): ClientKeybindings.KeybindingAction[];
+
+    /**
+     * Transforms a Binding into a human readable string representation
+     * @param binding - The Binding
+     * @returns A human readable string
+     * @internal
+     */
+    protected static _humanizeBinding(binding: ClientKeybindings.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 ClientKeybindings.KeybindingActionConfig {
+      category: string;
+      bindings: DisplayBinding[];
+      id: string;
+      name: string;
+      hint?: string;
+      cssClass?: string;
+      notes: string;
+    }
+
+    interface DisplayBinding extends Partial<ClientKeybindings.KeybindingActionBinding> {
+      id: string;
+      display: string;
+      cssClasses: string;
+      isEditable: boolean;
+      isFirst: boolean;
+      conflicts: string;
+      hasConflicts: boolean;
+    }
+
+    interface PendingBinding extends ClientKeybindings.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;
+      }
+    }
+  }
+}