@7h3laughingman/foundry-types 13.351.0

package/src/client/applications/api/category-browser.d.mts

@@ -0,0 +1,78 @@
+import { ApplicationClosingOptions, ApplicationConfiguration, ApplicationRenderContext, ApplicationTabsConfiguration } from "../_types.mjs";
+import ApplicationV2 from "./application.mjs";
+import HandlebarsApplicationMixin, { HandlebarsRenderOptions, HandlebarsTemplatePart } from "./handlebars-application.mjs";
+
+export interface CategoryBrowserConfiguration extends ApplicationConfiguration {
+    /** Where this application displays is a list of tagged FVTT packages */
+    packageList: boolean;
+    /**
+     * The initial category tab: a `null` value will result in an initial active tab that corresponds with the first
+     * category by insertion order.
+     */
+    initialCategory: string | null;
+    /** Additional Template partials for specific use with this class */
+    subtemplates: {
+        category: string;
+        filters: string | null;
+        sidebarFooter: string | null;
+    };
+}
+
+/**
+ * An abstract class responsible for displaying a 2-pane Application that allows for entries to be grouped and filtered
+ * by category.
+ */
+export default abstract class CategoryBrowser extends HandlebarsApplicationMixin(ApplicationV2) {
+    static override DEFAULT_OPTIONS: DeepPartial<CategoryBrowserConfiguration>;
+
+    static override PARTS: Record<string, HandlebarsTemplatePart>;
+
+    /**
+     * Is category and/or entry data loaded? Most subclasses will already have their data close at hand.
+     */
+    protected get _dataLoaded(): boolean;
+
+    protected override _initializeApplicationOptions(options: DeepPartial<CategoryBrowserConfiguration>): CategoryBrowserConfiguration;
+
+    protected override _configureRenderParts(options: HandlebarsRenderOptions): Record<string, HandlebarsTemplatePart>;
+
+    /**
+     * Perform a text search without a KeyboardEvent.
+     */
+    search(query: string): void;
+
+    override render(options?: boolean | DeepPartial<HandlebarsRenderOptions>): Promise<this>;
+
+    protected override _prepareContext(options: HandlebarsRenderOptions): Promise<ApplicationRenderContext>;
+
+    /**
+     * Prepare the structure of category data which is rendered in this configuration form.
+     */
+    protected abstract _prepareCategoryData(): Promise<Record<string, { id: string; label: string; entries: object[] }>>;
+
+    /**
+     * An optional method to make a potentially long-running request to load category data: a temporary message will be
+     * displayed until completion.
+     */
+    protected _loadCategoryData(): Promise<void>;
+
+    /**
+     * Reusable logic for how categories are sorted in relation to each other.
+     */
+    protected _sortCategories(a: { label: string; [key: string]: unknown }, b: { label: string; [key: string]: unknown }): number;
+
+    protected override _getTabsConfig(group: string): ApplicationTabsConfiguration | null;
+
+    protected override _tearDown(options: ApplicationClosingOptions): void;
+
+    protected override _onRender(context: ApplicationRenderContext, options: HandlebarsRenderOptions): Promise<void>;
+
+    /* -------------------------------------------- */
+    /*  Event Listeners and Handlers                */
+    /* -------------------------------------------- */
+
+    /**
+     * Handle search inputs.
+     */
+    protected _onSearchFilter(_event: KeyboardEvent, query: string, rgx?: RegExp, content?: HTMLElement | null): void;
+}

package/src/client/applications/api/dialog.d.mts

@@ -0,0 +1,213 @@
+import { ApplicationConfiguration, ApplicationRenderContext, ApplicationRenderOptions } from "../_types.mjs";
+import User from "./../../documents/user.mjs";
+import ApplicationV2 from "./application.mjs";
+
+export default class DialogV2<
+    TConfig extends DialogV2Configuration = DialogV2Configuration,
+    TRenderOptions extends ApplicationRenderOptions = ApplicationRenderOptions,
+> extends ApplicationV2<TConfig, TRenderOptions> {
+    static override DEFAULT_OPTIONS: DeepPartial<DialogV2Configuration>;
+
+    protected override _initializeApplicationOptions(options: DeepPartial<TConfig>): TConfig;
+
+    protected override _renderHTML(context: ApplicationRenderContext, options: TRenderOptions): Promise<HTMLFormElement>;
+
+    /**
+     * Render configured buttons
+     * @returns
+     */
+    protected _renderButtons(): string;
+
+    /**
+     * Handle submitting the dialog
+     * @param target The button that was clicked or the default button
+     * @param event The triggering event
+     */
+    protected _onSubmit(target: HTMLButtonElement, event: PointerEvent | SubmitEvent): Promise<DialogV2>;
+
+    protected override _onFirstRender(context: object, options: TRenderOptions): Promise<void>;
+
+    protected override _attachFrameListeners(): void;
+
+    protected override _replaceHTML(result: unknown, content: HTMLFormElement, options: TRenderOptions): void;
+
+    /**
+     * Handle keypresses within the dialog
+     * @param event The triggering event
+     */
+    protected _onKeyDown(event: KeyboardEvent): void;
+
+    /**
+     * @param event The originating click event.
+     * @param target The button element that was clicked
+     */
+    protected static _onClickButton(event: PointerEvent, target: HTMLButtonElement): void;
+
+    /**
+     * A utility helper to generate a dialog with yes and no buttons.
+     * @param [yes] Options to overwrite the default yes button configuration.
+     * @param [no]  Options to overwrite the default no button configuration.
+     * @returns     Resolves to true if the yes button was pressed, or false if the
+     *              no button was pressed. If additional buttons were provided, the Promise
+     *              resolves to the identifier of the one that was pressed, or the value
+     *              returned by its callback. If the dialog was dismissed, and rejectClose is
+     *              false, the Promise resolves to null.
+     */
+    static confirm({
+        yes,
+        no,
+        ...options
+    }: {
+        yes?: Partial<DialogV2Button>;
+        no?: Partial<DialogV2Button>;
+    } & DeepPartial<DialogV2Configuration & DialogV2WaitOptions>): Promise<boolean>;
+
+    /**
+     * A utility helper to generate a dialog with a single confirmation button.
+     * @param [ok] Options to overwrite the default confirmation button configuration.
+     * @returns    Resolves to the identifier of the button used to submit the dialog,
+     *             or the value returned by that button's callback. If the dialog was
+     *             dismissed, and rejectClose is false, the Promise resolves to null.
+     */
+    static prompt({ ok, ...options }: { ok: Partial<DialogV2Button> } & DeepPartial<DialogV2Configuration & DialogV2WaitOptions>): Promise<unknown>;
+
+    /**
+     * Spawn a dialog and wait for it to be dismissed or submitted.
+     * @param [render]            A function to invoke whenever the dialog is rendered.
+     * @param [close]             A function to invoke when the dialog is closed under any
+     *                            circumstances.
+     * @param [rejectClose=true] Throw a Promise rejection if the dialog is dismissed.
+     * @returns                  Resolves to the identifier of the
+     *                           button used to submit the dialog, or the value returned by that button's
+     *                           callback. If the dialog was dismissed, and rejectClose is false, the
+     *                           Promise resolves to null.
+     */
+    static wait({
+        rejectClose,
+        close,
+        render,
+        ...options
+    }: {
+        rejectClose?: boolean;
+        close?: DialogV2CloseCallback;
+        render?: DialogV2RenderCallback;
+    } & DeepPartial<DialogV2Configuration>): Promise<unknown>;
+
+    /**
+     * Present an asynchronous Dialog query to a specific User for response.
+     * @param user A User instance or a User id
+     * @param type The type of Dialog to present
+     * @param config Dialog configuration forwarded on to the Dialog.prompt, Dialog.confirm, Dialog.input, or
+     *               Dialog.wait function depending on the query type. Callback options are not supported.
+     * @returns The query response or null if no response was provided
+     *
+     * @see {@link DialogV2.prompt}
+     * @see {@link DialogV2.confirm}
+     * @see {@link DialogV2.input}
+     * @see {@link DialogV2.wait}
+     */
+    static query(user: User | string, type: "prompt" | "confirm" | "input" | "wait", config?: object): Promise<unknown>;
+
+    /**
+     * The dialog query handler.
+     * @internal
+     */
+    static _handleQuery: (options: { type: "prompt" | "confirm" | "input" | "wait"; config: object }) => unknown;
+}
+
+export interface DialogV2Button {
+    /** The button action identifier. */
+    action: string;
+
+    /** The button label. Will be localized. */
+    label: string;
+
+    /** FontAwesome icon classes. */
+    icon?: string;
+
+    /** CSS classes to apply to the button. */
+    class?: string;
+
+    /** CSS style to apply to the button. */
+    style?: Record<string, string>;
+
+    /** The button type. */
+    type?: string;
+
+    /** Whether the button is disabled */
+    disabled?: boolean;
+
+    /**
+     * Whether this button represents the default action to take if the user submits the form without pressing a button,
+     * i.e. with an Enter keypress.
+     */
+    default?: boolean;
+
+    /**
+     * A function to invoke when the button is clicked. The value returned from this function will be used as the
+     * dialog's submitted value. Otherwise, the button's identifier is used.
+     */
+    callback?: DialogV2ButtonCallback;
+}
+
+export interface DialogV2Configuration extends ApplicationConfiguration {
+    /** Modal dialogs prevent interaction with the rest of the UI until they are dismissed or submitted. */
+    modal?: boolean;
+
+    /** Button configuration. */
+    buttons: DialogV2Button[];
+
+    /**
+     * The dialog content: a HTML string or a <div> element. If string,
+     *     the content is cleaned with {@link foundry.utils.cleanHTML}.
+     *     Otherwise, the content is not cleaned.
+     */
+    content?: string | HTMLDivElement;
+
+    /**
+     * A function to invoke when the dialog is submitted. This will not be
+     *     called if the dialog is dismissed.
+     */
+    submit?: DialogV2SubmitCallback;
+}
+
+export interface DialogV2WaitOptions {
+    /** A synchronous function to invoke whenever the dialog is rendered. */
+    render?: DialogV2RenderCallback;
+
+    /** A synchronous function to invoke when the dialog is closed under any circumstances. */
+    close?: DialogV2CloseCallback;
+
+    /** Throw a Promise rejection if the dialog is dismissed. */
+    rejectClose?: boolean;
+
+    /** Options forwarded to the dialog's render call. */
+    renderOptions?: ApplicationRenderOptions;
+}
+
+/**
+ * A button click handler method.
+ * @param event The button click event, or a form submission event if the dialog was
+ * @param button If the form was submitted via keyboard, this will be the default
+ * @param dialog The dialog element.
+ */
+export type DialogV2ButtonCallback = (event: PointerEvent | SubmitEvent, button: HTMLButtonElement, dialog: DialogV2) => Promise<unknown> | unknown;
+
+/**
+ * A dialog render handler method.
+ * @param event The render event.
+ * @param dialog The dialog element.
+ */
+export type DialogV2RenderCallback = (event: Event, dialog: DialogV2) => void;
+
+/**
+ * @param event The close event
+ * @param dialog The dialog instance
+ */
+export type DialogV2CloseCallback = (event: Event, dialog: DialogV2) => void;
+
+/**
+ * @param result Either the identifier of the button that was clicked to submit
+ * the dialog, or the result returned by that button's callback
+ */
+export type DialogV2SubmitCallback = (result: unknown) => Promise<void>;

package/src/client/applications/api/document-sheet.d.mts

@@ -0,0 +1,148 @@
+import {
+    ApplicationClosingOptions,
+    ApplicationConfiguration,
+    ApplicationFormConfiguration,
+    ApplicationHeaderControlsEntry,
+    ApplicationRenderContext,
+    ApplicationRenderOptions,
+} from "../_types.mjs";
+import FormDataExtended from "../ux/form-data-extended.mjs";
+import { DatabaseCreateOperation, DatabaseUpdateOperation, DataSchema } from "./../../../common/abstract/_types.mjs";
+import Document from "./../../../common/abstract/document.mjs";
+import User from "./../../documents/user.mjs";
+import ApplicationV2 from "./application.mjs";
+
+export interface DocumentSheetRenderContext extends ApplicationRenderContext {
+    document: Document;
+    source: Record<string, JSONValue | undefined>;
+    fields: DataSchema;
+    editable: boolean;
+    user: User;
+    rootId: string;
+}
+
+export default abstract class DocumentSheetV2<
+    TConfig extends DocumentSheetConfiguration = DocumentSheetConfiguration,
+    TRenderOptions extends DocumentSheetRenderOptions = DocumentSheetRenderOptions,
+> extends ApplicationV2<TConfig, TRenderOptions> {
+    constructor(options?: DeepPartial<TConfig>);
+
+    static override DEFAULT_OPTIONS: DeepPartial<DocumentSheetConfiguration>;
+
+    get document(): TConfig["document"];
+
+    override get title(): string;
+
+    /**
+     * Is this Document sheet visible to the current User?
+     * This is governed by the viewPermission threshold configured for the class.
+     */
+    get isVisible(): boolean;
+
+    /**
+     * Is this Document sheet editable by the current User?
+     * This is governed by the editPermission threshold configured for the class.
+     */
+    get isEditable(): boolean;
+
+    protected override _initializeApplicationOptions(options: DeepPartial<TConfig>): TConfig;
+
+    protected override _headerControlButtons(): Generator<ApplicationHeaderControlsEntry>;
+
+    protected override _configureRenderOptions(options: DeepPartial<TRenderOptions>): TRenderOptions;
+
+    protected override _prepareContext(options: TRenderOptions): Promise<DocumentSheetRenderContext>;
+
+    protected override _renderFrame(options: TRenderOptions): Promise<HTMLElement>;
+
+    /**
+     * Disable or reenable all form fields in this application.
+     * @param disabled Should the fields be disabled?
+     */
+    protected _toggleDisabled(disabled: boolean): void;
+
+    /* -------------------------------------------- */
+    /*  Application Life-Cycle Events               */
+    /* -------------------------------------------- */
+
+    protected override _canRender(): void;
+
+    protected override _onFirstRender(context: object, options: TRenderOptions): Promise<void>;
+
+    protected override _onRender(context: object, options: TRenderOptions): Promise<void>;
+
+    protected override _onClose(options: ApplicationClosingOptions): void;
+
+    /* -------------------------------------------- */
+    /*  Event Listeners and Handlers                */
+    /* -------------------------------------------- */
+
+    /* -------------------------------------------- */
+    /*  Form Submission                             */
+    /* -------------------------------------------- */
+
+    protected override _onChangeForm(formConfig: ApplicationFormConfiguration, event: Event): void;
+
+    /**
+     * Handle toggling the revealed state of a secret embedded in some content.
+     * @param event The triggering event.
+     */
+    protected _onRevealSecret(event: Event): void;
+
+    /**
+     * Prepare data used to update the Item upon form submission.
+     * This data is cleaned and validated before being returned for further processing.
+     * @param event      The originating form submission event
+     * @param form       The form element that was submitted
+     * @param formData   Processed data for the submitted form
+     * @param updateData Additional data passed in if this form is submitted manually which should be merged with
+     *                   prepared formData.
+     * @throws {Error} Subclasses may throw validation errors here to prevent form submission
+     * @returns Prepared submission data as an object
+     */
+    protected _prepareSubmitData(event: SubmitEvent, form: HTMLFormElement, formData: FormDataExtended, updateData?: object): object;
+
+    /**
+     * Customize how form data is extracted into an expanded object.
+     * @param event    The originating form submission event
+     * @param form     The form element that was submitted
+     * @param formData Processed data for the submitted form
+     * @returns An expanded object of processed form data
+     * @throws {Error} Subclasses may throw validation errors here to prevent form submission
+     */
+    protected _processFormData(event: SubmitEvent | null, form: HTMLFormElement, formData: FormDataExtended): Record<string, unknown>;
+
+    /**
+     * Submit a document update or creation request based on the processed form data.
+     * @param event      The originating form submission event
+     * @param form       The form element that was submitted
+     * @param submitData Processed and validated form data to be used for a document update
+     * @param options Additional options altering the request
+     */
+    protected _processSubmitData(
+        event: SubmitEvent,
+        form: HTMLFormElement,
+        submitData: Record<string, unknown>,
+        options?: Partial<DatabaseCreateOperation<TConfig["document"]["parent"]>> | Partial<DatabaseUpdateOperation<TConfig["document"]["parent"]>>,
+    ): Promise<void>;
+}
+
+export interface DocumentSheetConfiguration<TDocument extends Document = Document> extends ApplicationConfiguration {
+    /** The Document instance associated with this sheet */
+    document: TDocument;
+    /** A permission level in CONST.DOCUMENT_OWNERSHIP_LEVELS */
+    viewPermission: number;
+    /** A permission level in CONST.DOCUMENT_OWNERSHIP_LEVELS */
+    editPermission: number;
+    /** Can this sheet class be used to create a new Document? */
+    canCreate: boolean;
+    /** Allow sheet configuration as a header button */
+    sheetConfig: boolean;
+}
+
+export interface DocumentSheetRenderOptions extends ApplicationRenderOptions {
+    /** A string with the format "{operation}{documentName}" providing context */
+    renderContext?: string;
+    /** Data describing the document modification that occurred */
+    renderData?: object;
+}

package/src/client/applications/api/handlebars-application.d.mts

@@ -0,0 +1,120 @@
+import type { ApplicationFormConfiguration, ApplicationRenderContext, ApplicationRenderOptions } from "../_types.mjs";
+import type ApplicationV2 from "./application.mjs";
+
+/** Augment an Application class with [Handlebars](https://handlebarsjs.com) template rendering behavior. */
+export default function HandlebarsApplicationMixin<TBase extends AbstractConstructorOf<ApplicationV2<any>>>(
+    BaseApplication: TBase,
+): ConstructorOf<HandlebarsApplication> & HandlebarsApplicationStatic & TBase;
+
+export class HandlebarsApplication extends ApplicationV2 {
+    static PARTS: Record<string, HandlebarsTemplatePart>;
+
+    /** A record of all rendered template parts. */
+    get parts(): Record<string, HTMLElement>;
+
+    protected override _configureRenderOptions(options: HandlebarsRenderOptions): void;
+
+    /** Allow subclasses to dynamically configure render parts. */
+    protected _configureRenderParts(options: HandlebarsRenderOptions): Record<string, HandlebarsTemplatePart>;
+
+    /**
+     * Render each configured application part using Handlebars templates.
+     * @param context Context data for the render operation
+     * @param options Options which configure application rendering behavior
+     * @returns A single rendered HTMLElement for each requested part
+     */
+    protected override _renderHTML(context: object, options: HandlebarsRenderOptions): Promise<Record<string, HTMLElement>>;
+
+    /**
+     * Prepare context that is specific to only a single rendered part.
+     *
+     * It is recommended to augment or mutate the shared context so that downstream methods like _onRender have
+     * visibility into the data that was used for rendering. It is acceptable to return a different context object
+     * rather than mutating the shared context at the expense of this transparency.
+     *
+     * @param partId       The part being rendered
+     * @param context      Shared context provided by _prepareContext
+     * @returns Context data for a specific part
+     */
+    protected _preparePartContext(partId: string, context: ApplicationRenderContext, options: HandlebarsRenderOptions): Promise<ApplicationRenderContext>;
+
+    /**
+     * Replace the HTML of the application with the result provided by Handlebars rendering.
+     * @param result  The result from Handlebars template rendering
+     * @param content The content element into which the rendered result must be inserted
+     * @param options     Options which configure application rendering behavior
+     */
+    protected override _replaceHTML(result: Record<string, HTMLElement>, content: HTMLElement, options: HandlebarsRenderOptions): void;
+
+    /**
+     * Prepare data used to synchronize the state of a template part.
+     * @param partId       The id of the part being rendered
+     * @param newElement   The new rendered HTML element for the part
+     * @param priorElement The prior rendered HTML element for the part
+     * @param state        A state object which is used to synchronize after replacement
+     */
+    protected _preSyncPartState(partId: string, newElement: HTMLElement, priorElement: HTMLElement, state: object): void;
+
+    /**
+     * Synchronize the state of a template part after it has been rendered and replaced in the DOM.
+     * @param partId                  The id of the part being rendered
+     * @param newElement              The new rendered HTML element for the part
+     * @param priorElement            The prior rendered HTML element for the part
+     * @param state                   A state object which is used to synchronize after replacement
+     */
+    protected _syncPartState(partId: string, newElement: HTMLElement, priorElement: HTMLElement, state: object): void;
+
+    /* -------------------------------------------- */
+    /*  Event Listeners and Handlers                */
+    /* -------------------------------------------- */
+
+    /**
+     * Attach event listeners to rendered template parts.
+     * @param partId       The id of the part being rendered
+     * @param htmlElement  The rendered HTML element for the part
+     * @param options       Rendering options passed to the render method
+     */
+    protected _attachPartListeners(partId: string, htmlElement: HTMLElement, options: HandlebarsRenderOptions): void;
+}
+
+declare interface HandlebarsApplicationStatic {
+    PARTS: Record<string, HandlebarsTemplatePart>;
+}
+
+export interface HandlebarsTemplatePart {
+    /** The template entry-point for the part */
+    template: string;
+
+    /**
+     * A CSS id to assign to the top-level element of the rendered part.
+     * This id string is automatically prefixed by the application id.
+     */
+    id?: string;
+
+    /** Does this rendered contents of this template part replace the children of the root element? */
+    root?: boolean;
+
+    /** An array of CSS classes to apply to the top-level element of the rendered part. */
+    classes?: string[];
+
+    /**
+     * An array of templates that are required to render the part.
+     * If omitted, only the entry-point is inferred as required.
+     */
+    templates?: string[];
+
+    /**
+     * An array of selectors within this part whose scroll positions should
+     * be persisted during a re-render operation. A blank string is used
+     * to denote that the root level of the part is scrollable.
+     */
+    scrollable?: string[];
+
+    /** A registry of forms selectors and submission handlers. */
+    forms?: Record<string, ApplicationFormConfiguration>;
+}
+
+export interface HandlebarsRenderOptions extends ApplicationRenderOptions {
+    /** An array of named template parts to render */
+    parts: string[];
+}

package/src/client/applications/apps/_module.d.mts

@@ -0,0 +1,10 @@
+export * as av from "./av/_module.mjs";
+
+export { default as CombatTrackerConfig } from "./combat-tracker-config.mjs";
+export { default as CompendiumArtConfig } from "./compendium-art-config.mjs";
+export { default as DocumentOwnershipConfig } from "./document-ownership.mjs";
+export { default as DocumentSheetConfig } from "./document-sheet-config.mjs";
+export { default as FilePicker } from "./file-picker.mjs";
+export { default as GridConfig } from "./grid-config.mjs";
+export { default as ImagePopout } from "./image-popout.mjs";
+export { default as PermissionConfig } from "./permission-config.mjs";

package/src/client/applications/apps/av/_module.d.mts

@@ -0,0 +1,2 @@
+export { default as CameraPopout } from "./camera-popout.mjs";
+export { default as CameraViews } from "./cameras.mjs";

package/src/client/applications/apps/av/camera-popout.d.mts

@@ -0,0 +1,53 @@
+import ApplicationV2 from "../../api/application.mjs";
+import HandlebarsApplicationMixin, { HandlebarsRenderOptions, HandlebarsTemplatePart } from "../../api/handlebars-application.mjs";
+import { ApplicationConfiguration, ApplicationPosition, ApplicationRenderContext } from "./../../../applications/_types.mjs";
+import User from "./../../../documents/user.mjs";
+
+interface CameraPopoutConfiguration extends ApplicationConfiguration {
+    user: User;
+}
+
+/**
+ * An application for a single popped-out camera.
+ * @extends {ApplicationV2<CameraPopoutConfiguration, HandlebarsRenderOptions>}
+ * @mixes HandlebarsApplication
+ */
+export default class CameraPopout extends HandlebarsApplicationMixin(ApplicationV2) {
+    constructor(options?: DeepPartial<ApplicationConfiguration> & { user: User });
+
+    static override DEFAULT_OPTIONS: DeepPartial<ApplicationConfiguration>;
+
+    static override PARTS: Record<string, HandlebarsTemplatePart>;
+
+    /* -------------------------------------------- */
+    /*  Properties                                  */
+    /* -------------------------------------------- */
+
+    /**
+     * The user this camera view is for.
+     */
+    get user(): User;
+
+    /* -------------------------------------------- */
+    /*  Rendering                                   */
+    /* -------------------------------------------- */
+
+    /** @inheritDoc */
+    _initializeApplicationOptions(options: DeepPartial<ApplicationConfiguration>): ApplicationConfiguration;
+
+    protected override _onFirstRender(context: ApplicationRenderContext, options: HandlebarsRenderOptions): Promise<void>;
+
+    protected override _prepareContext(options: HandlebarsRenderOptions): Promise<ApplicationRenderContext>;
+
+    /* -------------------------------------------- */
+    /*  Positioning                                 */
+    /* -------------------------------------------- */
+
+    override setPosition(position?: Partial<ApplicationPosition>): ApplicationPosition;
+
+    /* -------------------------------------------- */
+    /*  Event Listeners & Handlers                  */
+    /* -------------------------------------------- */
+
+    protected override _onClickAction(event: PointerEvent, target: HTMLElement): void | Promise<void>;
+}