@league-of-foundry-developers/foundry-vtt-types 12.331.4-beta → 13.340.1

package/src/foundry/client-esm/applications/ui/notifications.d.mts

@@ -0,0 +1,208 @@
+/**
+ * A common framework for displaying notifications to the client.
+ * Submitted notifications are added to a queue, and up to {@link Notifications.MAX_ACTIVE} notifications are
+ * displayed at once. Each notification is displayed for {@link Notifications.LIFETIME_MS} milliseconds before being
+ * removed, at which point further notifications are pulled from the queue.
+ *
+ *
+ * @example Displaying Notification Messages
+ * ```js
+ * ui.notifications.error("This is a permanent error message", {permanent: true});
+ * ui.notifications.warn("LOCALIZED.WARNING.MESSAGE", {localize: true});
+ * ui.notifications.success("This is a success message, not logged to the console", {console: false});
+ * ui.notifications.info("LOCALIZED.FORMAT.STRING", {format: {key1: "foo", key2: "bar"}});
+ * ```
+ *
+ * @example Progress Bar Notification
+ * ```js
+ * const progress = ui.notifications.info("Thing Happening!", {progress: true});
+ * progress.update({pct: 0.25, message: "Still happening!"});
+ * progress.update({pct: 0.50, message: "Almost there!"});
+ * progress.update({pct: 0.75, message: "Stay on target!"});
+ * progress.update({pct: 1.0, message: "Done!"});
+ * ```
+ */
+declare class Notifications {
+  constructor();
+
+  /**
+   * The maximum number of active notifications.
+   * @defaultValue `5`
+   */
+  static MAX_ACTIVE: number;
+
+  /**
+   * The maximum number of active notifications.
+   * @defaultValue `5000`
+   */
+  static LIFETIME_MS: number;
+
+  /**
+   * Push a new notification into the queue
+   * @param message   - The content of the notification message
+   * @param type      - The type of notification, "info", "warning", and "error" are supported
+   *                    (default: `"info"`)
+   * @param options   - Additional options which affect the notification
+   *                    (default: `{}`)
+   * @returns The ID of the notification (positive integer)
+   * @remarks `type` and `options` use parameter defaults so `null` causes an error
+   */
+  notify<T extends Notifications.Type = "info">(
+    message: string,
+    type?: T,
+    options?: Notifications.NotifyOptions,
+  ): Readonly<Notifications.Notification<T>>;
+
+  /**
+   * Display a notification with the "info" type
+   * @param message - The content of the notification message
+   * @param options - Notification options passed to the notify function
+   * @returns The ID of the notification (positive integer)
+   * @remarks `options` use parameter defaults so `null` causes an error
+   */
+  info(message: string, options?: Notifications.NotifyOptions): Readonly<Notifications.Notification<"info">>;
+
+  /**
+   * Display a notification with the "warning" type
+   * @param message - The content of the notification message
+   * @param options - Notification options passed to the notify function
+   * @returns The ID of the notification (positive integer)
+   * @remarks `options` use parameter defaults so `null` causes an error
+   */
+  warn(message: string, options?: Notifications.NotifyOptions): Readonly<Notifications.Notification<"warning">>;
+
+  /**
+   * Display a notification with the "error" type
+   * @param message - The content of the notification message
+   * @param options - Notification options passed to the notify function
+   * @returns The ID of the notification (positive integer)
+   * @remarks `options` use parameter defaults so `null` causes an error
+   */
+  error(message: string, options?: Notifications.NotifyOptions): Readonly<Notifications.Notification<"error">>;
+
+  /**
+   * Display a notification with the "success" type.
+   * @param message - The content of the success message
+   * @param options - Notification options passed to the notify function
+   * @returns The registered notification
+   */
+  success(message: string, options?: Notifications.NotifyOptions): Readonly<Notifications.Notification<"success">>;
+
+  /**
+   * Update the progress of the notification.
+   * @param notification - A Notification or ID to update
+   * @param update       - An incremental progress update
+   */
+  update(notification: Notifications.Notification | number, update: Notifications.UpdateOptions): void;
+
+  /**
+   * Remove the notification linked to the ID.
+   * @param id - The Notification or ID to remove
+   */
+  remove(id: Notifications.Notification | number): void;
+
+  /**
+   * Clear all notifications.
+   */
+  clear(): void;
+
+  #private: true;
+}
+
+declare abstract class AnyNotifications extends Notifications {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare namespace Notifications {
+  type Any = AnyNotifications;
+  type AnyConstructor = typeof AnyNotifications;
+
+  type Type = "info" | "warning" | "error" | "success";
+
+  interface Notification<T extends Type = Type> {
+    id: number;
+    type: T;
+    timestamp: number;
+    message: string;
+    permanent: boolean;
+    console: boolean;
+    active: boolean;
+    progress: boolean;
+    pct: number;
+    element?: HTMLLIElement;
+    remove?: () => void;
+    update?: (pct: number) => void;
+  }
+
+  interface FormatOptions {
+    /**
+     * Whether to escape the values of `format`
+     * @defaultValue `true`
+     * @remarks `null` equivalent to `false`
+     */
+    escape?: boolean | null | undefined;
+
+    /**
+     * Whether to clean the provided message string as untrusted user input.
+     * No cleaning is applied if `format` is passed and `escape` is true or `localize` is true and `format` is not passed.
+     * @defaultValue `true`
+     * @remarks `null` equivalent to `false`
+     */
+    clean?: boolean | null | undefined;
+
+    /**
+     * A mapping of formatting strings passed to Localization#format
+     */
+    format?: Record<string, string> | null | undefined;
+  }
+
+  interface NotifyOptions extends FormatOptions {
+    /**
+     * Should the notification be permanently displayed until dismissed
+     * @defaultValue `false`
+     * @remarks Overridden as `true` if `progress` is true. `null` equivalent to `false`
+     */
+    permanent?: boolean | null | undefined;
+
+    /**
+     * Does this Notification include a progress bar?
+     * @defaultValue `false`
+     * @remarks `null` equivalent to `false`
+     */
+    progress?: boolean | null | undefined;
+
+    /**
+     * Whether to localize the message content before displaying it
+     * @defaultValue `false`
+     */
+    localize?: boolean;
+
+    /**
+     * Whether to log the message to the console
+     * @defaultValue `true`
+     * @remarks `null` equivalent to `false`
+     */
+    console?: boolean | null | undefined;
+  }
+
+  interface UpdateOptions extends FormatOptions {
+    /**
+     * An update to the string message
+     */
+    message?: string | null | undefined;
+
+    /**
+     * Localize updates to presented progress text
+     * @defaultValue `false`
+     * @remarks `null` equivalent to `false`
+     */
+    localize?: boolean | null | undefined;
+
+    /**
+     * An update to the completion percentage
+     */
+    pct?: number | null | undefined;
+  }
+}
+
+export default Notifications;

package/src/foundry/client-esm/applications/ui/players.d.mts

@@ -0,0 +1,26 @@
+import type ApplicationV2 from "../api/application.d.mts";
+import type HandlebarsApplicationMixin from "../api/handlebars-application.d.mts";
+
+/**
+ * A UI element which displays the Users defined for this world.
+ * Currently active users are always displayed, while inactive users can be displayed on toggle.
+ * @remarks TODO: Stub
+ */
+declare class Players<
+  RenderContext extends Players.RenderContext = Players.RenderContext,
+  Configuration extends ApplicationV2.Configuration = ApplicationV2.Configuration,
+  RenderOptions extends ApplicationV2.RenderOptions = ApplicationV2.RenderOptions,
+> extends HandlebarsApplicationMixin(ApplicationV2)<RenderContext, Configuration, RenderOptions> {}
+
+declare namespace Players {
+  interface UserContext {
+    id: string;
+  }
+
+  interface RenderContext {
+    active: UserContext[];
+    inactive: UserContext[];
+  }
+}
+
+export default Players;

package/src/foundry/client-esm/applications/ui/region-legend.d.mts

@@ -27,9 +27,12 @@ export default class RegionLegend<
 
   override close(options?: DeepPartial<ApplicationV2.ClosingOptions>): Promise<this>;
 
-  protected override _onFirstRender(context: DeepPartial<RenderContext>, options: DeepPartial<RenderOptions>): void;
+  protected override _onFirstRender(
+    context: DeepPartial<RenderContext>,
+    options: DeepPartial<RenderOptions>,
+  ): Promise<void>;
 
-  protected override _onRender(context: DeepPartial<RenderContext>, options: DeepPartial<RenderOptions>): void;
+  protected override _onRender(context: DeepPartial<RenderContext>, options: DeepPartial<RenderOptions>): Promise<void>;
 
   protected override _onClose(options: DeepPartial<RenderOptions>): void;
 

package/src/foundry/client-esm/applications/ui/scene-controls.d.mts

@@ -0,0 +1,20 @@
+import type ApplicationV2 from "../api/application.d.mts";
+import type HandlebarsApplicationMixin from "../api/handlebars-application.d.mts";
+
+/**
+ * The Scene Controls UI element.
+ * @remarks TODO: Stub
+ */
+declare class SceneControls<
+  RenderContext extends SceneControls.RenderContext = SceneControls.RenderContext,
+  Configuration extends ApplicationV2.Configuration = ApplicationV2.Configuration,
+  RenderOptions extends SceneControls.RenderOptions = SceneControls.RenderOptions,
+> extends HandlebarsApplicationMixin(ApplicationV2)<RenderContext, Configuration, RenderOptions> {}
+
+declare namespace SceneControls {
+  interface RenderContext extends ApplicationV2.RenderContext {}
+
+  interface RenderOptions extends ApplicationV2.RenderOptions {}
+}
+
+export default SceneControls;

package/src/foundry/client-esm/applications/ui/scene-navigation.d.mts

@@ -0,0 +1,28 @@
+import type ApplicationV2 from "../api/application.d.mts";
+import type HandlebarsApplicationMixin from "../api/handlebars-application.d.mts";
+
+/**
+ * The Scene Navigation UI element.
+ * @remarks TODO: Stub
+ */
+declare class SceneNavigation<
+  RenderContext extends SceneNavigation.RenderContext = SceneNavigation.RenderContext,
+  Configuration extends ApplicationV2.Configuration = ApplicationV2.Configuration,
+  RenderOptions extends ApplicationV2.RenderOptions = ApplicationV2.RenderOptions,
+> extends HandlebarsApplicationMixin(ApplicationV2)<RenderContext, Configuration, RenderOptions> {}
+
+declare namespace SceneNavigation {
+  interface PreparedScene {
+    id: string;
+  }
+
+  interface RenderContext {
+    scenes: {
+      inactive: PreparedScene[];
+      active: PreparedScene[];
+    };
+    canExpand: number;
+  }
+}
+
+export default SceneNavigation;

package/src/foundry/client-esm/applications/ux/_module.d.mts

@@ -0,0 +1,14 @@
+// In Foundry itself this file contains re-exports of these other modules.
+// Therefore it has a runtime effect and uses `.mjs` instead of `.d.mts`.
+// While `.mts` could work, to avoid `import/no-unresolved` from erroring `.mjs` is used.
+/* eslint-disable import-x/extensions */
+
+export { default as ContextMenu } from "./context-menu.mjs";
+export { default as DragDrop } from "./drag-drop.mjs";
+export { default as Draggable } from "./draggable.mjs";
+export { default as FormDataExtended } from "./form-data-extended.mjs";
+export { default as HTMLSecret } from "./html-secret.mjs";
+export { default as ProseMirrorEditor } from "./prosemirror-editor.mjs";
+export { default as SearchFilter } from "./search-filter.mjs";
+export { default as Tabs } from "./tabs.mjs";
+export { default as TextEditor } from "./text-editor.mjs";

package/src/foundry/client-esm/applications/ux/context-menu.d.mts

@@ -0,0 +1,379 @@
+import type { InexactPartial } from "fvtt-types/utils";
+
+declare global {
+  /**
+   * @deprecated Use {@link foundry.applications.ux.ContextMenu.Entry | `foundry.applications.ux.ContextMenu.Entry`}
+   */
+  type ContextMenuEntry = ContextMenu.Entry<JQuery>;
+}
+
+/**
+ * Display a right-click activated Context Menu which provides a dropdown menu of options.
+ * A ContextMenu is constructed by designating a parent HTML container and a target selector.
+ * An Array of menuItems defines the entries of the menu which is displayed.
+ */
+declare class ContextMenu<UsesJQuery extends boolean = true> {
+  /**
+   * @param container   - The containing HTML element within which the menu is positioned
+   * @param selector  - A CSS selector which activates the context menu.
+   * @param menuItems - An Array of entries to display in the menu
+   * @param options   - Additional options to configure the context menu.
+   */
+  constructor(
+    container: HTMLElement,
+    selector: string | null | undefined,
+    menuItems: ContextMenu.Entry<ContextMenu.JQueryOrHTML<UsesJQuery>>[],
+    options: ContextMenu.ConstructorOptions<UsesJQuery>,
+  );
+
+  /**
+   * @deprecated "ContextMenu is changing to no longer transact jQuery objects.
+   * You may temporarily pass the jQuery option to nominate a behavior.
+   * In v14 the default will become false."
+   */
+  constructor(
+    element: JQuery,
+    selector: string | null | undefined,
+    menuItems: ContextMenu.Entry<ContextMenu.JQueryOrHTML<UsesJQuery>>[],
+    options: ContextMenu.ConstructorOptions<UsesJQuery>,
+  );
+
+  /**
+   * @deprecated "ContextMenu is changing to no longer transact jQuery objects for menu item callbacks.
+   * Because the jQuery option provided to the ContextMenu constructor was undefined, your  callbacks will receive jQuery objects.
+   * You may opt-out and receive HTMLElement references instead by passing jQuery: false to the constructor.
+   * This parameter will be false by default in v14 and deprecated entirely in v15 at which point only HTMLElement references will be used."
+   */
+  constructor(
+    element: HTMLElement,
+    selector: string | null | undefined,
+    menuItems: ContextMenu.Entry<ContextMenu.JQueryOrHTML<UsesJQuery>>[],
+    options?: InexactPartial<ContextMenu.ConstructorOptions<UsesJQuery>, "jQuery">,
+  );
+
+  /**
+   * @deprecated "ContextMenu is changing to no longer transact jQuery objects. You must begin passing an HTMLElement instead."
+   *
+   * @deprecated "ContextMenu is changing to no longer transact jQuery objects for menu item callbacks.
+   * Because the jQuery option provided to the ContextMenu constructor was undefined, your  callbacks will receive jQuery objects.
+   * You may opt-out and receive HTMLElement references instead by passing jQuery: false to the constructor.
+   * This parameter will be false by default in v14 and deprecated entirely in v15 at which point only HTMLElement references will be used."
+   */
+  constructor(
+    element: JQuery,
+    selector: string | null | undefined,
+    menuItems: ContextMenu.Entry<ContextMenu.JQueryOrHTML<UsesJQuery>>[],
+    options?: InexactPartial<ContextMenu.ConstructorOptions<UsesJQuery>, "jQuery">,
+  );
+
+  /**
+   * Create a ContextMenu for this Application and dispatch hooks.
+   * @param app       - The Application this ContextMenu belongs to.
+   * @param html      - The Application's rendered HTML.
+   * @param selector  - The target CSS selector which activates the menu.
+   * @param menuItems - The array of menu items being rendered.
+   * @param options   - Additional options to configure context menu initialization.
+   *                    (default: `"EntryContext"`)
+   */
+  static create<UsesJQuery extends boolean = true>(
+    app: Application.Any,
+    html: HTMLElement,
+    selector: string,
+    menuItems: ContextMenu.Entry<ContextMenu.JQueryOrHTML<UsesJQuery>>[],
+    options: ContextMenu.CreateOptions<UsesJQuery>,
+  ): ContextMenu<UsesJQuery>;
+
+  /**
+   * @deprecated "ContextMenu is changing to no longer transact jQuery objects for menu item callbacks.
+   * Because the jQuery option provided to the ContextMenu constructor was undefined, your  callbacks will receive jQuery objects.
+   * You may opt-out and receive HTMLElement references instead by passing jQuery: false to the constructor.
+   * This parameter will be false by default in v14 and deprecated entirely in v15 at which point only HTMLElement references will be used."
+   */
+  static create(
+    app: Application.Any,
+    html: HTMLElement,
+    selector: string,
+    menuItems: ContextMenu.Entry<ContextMenu.JQueryOrHTML<true>>[],
+    options?: InexactPartial<ContextMenu.CreateOptions<true>, "jQuery">,
+  ): ContextMenu<true>;
+
+  /**
+   * @deprecated "ContextMenu is changing to no longer transact jQuery objects. You must begin passing an HTMLElement instead."
+   */
+  static create<UsesJQuery extends boolean = true>(
+    app: Application.Any,
+    html: JQuery,
+    selector: string,
+    menuItems: ContextMenu.Entry<ContextMenu.JQueryOrHTML<UsesJQuery>>[],
+    options: ContextMenu.CreateOptions<UsesJQuery>,
+  ): ContextMenu<UsesJQuery>;
+
+  /**
+   * @deprecated "ContextMenu is changing to no longer transact jQuery objects for menu item callbacks.
+   * Because the jQuery option provided to the ContextMenu constructor was undefined, your  callbacks will receive jQuery objects.
+   * You may opt-out and receive HTMLElement references instead by passing jQuery: false to the constructor.
+   * This parameter will be false by default in v14 and deprecated entirely in v15 at which point only HTMLElement references will be used."
+   * @deprecated "ContextMenu is changing to no longer transact jQuery objects. You must begin passing an HTMLElement instead."
+   */
+  static create(
+    app: Application.Any,
+    html: JQuery,
+    selector: string,
+    menuItems: ContextMenu.Entry<ContextMenu.JQueryOrHTML<true>>[],
+    options?: InexactPartial<ContextMenu.CreateOptions<true>, "jQuery">,
+  ): ContextMenu<true>;
+
+  /**
+   * The menu element.
+   */
+  get element(): HTMLElement;
+
+  /**
+   * A CSS selector to identify context menu targets.
+   * @defaultValue `container.attr("id")`
+   */
+  get selector(): string;
+
+  /**
+   * The event name to listen for.
+   * @defaultValue `"contextmenu"`
+   */
+  get eventName(): string;
+
+  /**
+   * The array of menu items to render.
+   */
+  menuItems: ContextMenu.Entry<ContextMenu.JQueryOrHTML<UsesJQuery>>[];
+
+  /**
+   * A function to call when the context menu is opened.
+   */
+  onOpen: ContextMenu.ContextMenuCallback | null | undefined;
+
+  /**
+   * A function to call when the context menu is closed.
+   */
+  onClose: ContextMenu.ContextMenuCallback | null | undefined;
+
+  /**
+   * Check which direction the menu is expanded in.
+   * @defaultValue `false`
+   */
+  get expandUp(): boolean;
+
+  /**
+   * Whether to position the context menu as a fixed element, or inject it into the target.
+   */
+  get fixed(): boolean;
+
+  /**
+   * The parent HTML element to which the context menu is attached
+   */
+  get target(): HTMLElement;
+
+  /**
+   * Animate the context menu's height when opening or closing.
+   * @param open - Whether the menu is opening or closing.
+   * @returns A Promise that resolves when the animation completes.
+   */
+  protected _animate(open?: boolean): Promise<void>;
+
+  /**
+   * Closes the menu and removes it from the DOM.
+   * @param options - Options to configure the closing behavior.
+   */
+  close(options?: ContextMenu.CloseOptions): Promise<void>;
+
+  /**
+   * Close the menu and remove it from the DOM.
+   */
+  protected _close(): void;
+
+  /**
+   * Called before the context menu begins rendering.
+   * @param target - The context target
+   * @param options - (default: `{}`)
+   */
+  protected _preRender(target: HTMLElement, options?: ContextMenu.RenderOptions): Promise<void>;
+
+  /**
+   * Render the Context Menu by iterating over the menuItems it contains
+   * Check the visibility of each menu item, and only render ones which are allowed by the item's logical condition
+   * Attach a click handler to each item which is rendered
+   * @param target  - The target element to which the context menu is attached
+   * @param options - (default: `{}`)
+   */
+  render(target: HTMLElement, options?: ContextMenu.RenderOptions): Promise<void>;
+
+  /**
+   * Called after the context menu has finished rendering and animating open.
+   * @param options - (default: `{}`)
+   */
+  protected _onRender(options?: ContextMenu.RenderOptions): Promise<void>;
+
+  /**
+   * Set the position of the context menu, taking into consideration whether the menu should expand upward or downward
+   * @param html    - The context menu element.
+   * @param target  - The element that the context menu was spawned on.
+   * @param options - (default: `{}`)
+   */
+  protected _setPosition(html: HTMLElement, target: HTMLElement, options?: ContextMenu.RenderOptions): void;
+
+  /**
+   * Inject the menu inside the target.
+   * @param menu   - The menu element.
+   * @param target - The context target.
+   */
+  protected _injectMenu(menu: HTMLElement, target: HTMLElement): void;
+
+  /**
+   * Set the context menu at a fixed position in the viewport.
+   * @param html    - The menu element.
+   * @param target  - The context target.
+   * @param options - (default: `{}`)
+   */
+  protected _setFixedPosition(menu: HTMLElement, target: HTMLElement, options?: ContextMenu.RenderOptions): void;
+
+  /**
+   * Local listeners which apply to each ContextMenu instance which is created.
+   * @param html - The context menu element.
+   */
+  activateListeners(html: HTMLElement): void;
+
+  /**
+   * Handle context menu activation.
+   * @param event - The triggering event.
+   */
+  protected _onActivate(event: PointerEvent): Promise<void>;
+
+  /**
+   * Global listeners which apply once only to the document.
+   */
+  static eventListeners(): void;
+
+  /**
+   * @deprecated since v13 until v15
+   * @remarks ""ContextMenu#_expandUp is deprecated. Please use ContextMenu#expandUp instead."
+   */
+  get _expandUp(): boolean;
+
+  /**
+   * @deprecated since v13 until v15
+   * @remarks "ContextMenu#menu is deprecated. Please use ContextMenu#element instead."
+   */
+  get menu(): JQuery;
+
+  #private: true;
+}
+
+declare namespace ContextMenu {
+  interface Entry<ElementType extends JQuery | HTMLElement> {
+    /**
+     * The context menu label. Can be localized.
+     */
+    name: string;
+
+    /**
+     * A string containing an HTML icon element for the menu item
+     */
+    icon?: string;
+
+    /**
+     * An identifier for a group this entry belongs to.
+     * @defaultValue `_none`
+     */
+    group?: string | null | undefined;
+
+    /**
+     * The element that the context menu has been triggered for. Will
+     * either be a jQuery object or an HTMLElement instance, depending
+     * on how the ContextMenu was configured.
+     */
+    callback: (target: ElementType) => void;
+
+    /**
+     * A function to call or boolean value to determine if this entry
+     * appears in the menu.
+     * @remarks `null` equivalent to `false`
+     */
+    condition?: boolean | Condition<ElementType> | null | undefined;
+  }
+
+  /**
+   * @param html - The element of the context menu entry.
+   * @returns Whether the entry should be rendered in the context menu.
+   * @remarks `null` equivalent to `false`
+   */
+  type Condition<ElementType extends JQuery | HTMLElement> = (target: ElementType) => boolean | null;
+
+  interface RenderOptions {
+    /**
+     * The event that triggered the context menu opening.
+     */
+    event?: PointerEvent | undefined | null;
+
+    /**
+     * Animate the context menu opening
+     * @defaultValue `true`
+     * @remarks No null because an explicit check for `options.animate !== false` would treat null as truthy
+     */
+    animate?: boolean | undefined;
+  }
+
+  interface CloseOptions {
+    /**
+     * Animate the context menu closing.
+     * @defaultValue `true`
+     * @remarks `null` equivalent to `false`
+     */
+    animate?: boolean | null;
+  }
+
+  type ContextMenuCallback =
+    /**
+     * @param target - The element that the context menu has been triggered for.
+     */
+    (target: HTMLElement) => void;
+
+  interface ConstructorOptions<IsJQuery extends boolean = true> {
+    /**
+     * Optionally override the triggering event which can spawn the menu. If the menu is using a fixed position, this event must be a MouseEvent
+     * @defaultValue `"contextmenu"`
+     */
+    eventName?: string;
+
+    /**
+     * A function to call when the context menu is opened.
+     */
+    onOpen?: ContextMenuCallback | null | undefined;
+
+    /**
+     * A function to call when the context menu is closed.
+     */
+    onClose?: ContextMenuCallback | null | undefined;
+
+    /**
+     * If true, callbacks will be passed jQuery objects instead of HTMLElement instances
+     * @defaultValue `true`
+     */
+    jQuery: IsJQuery;
+
+    /**
+     * If true, the context menu is given a fixed position rather than being injected into the target.
+     * @defaultValue `false`
+     */
+    fixed?: boolean | undefined;
+  }
+
+  interface CreateOptions<IsJQuery extends boolean = true> extends ConstructorOptions<IsJQuery> {
+    /**
+     * The name of the hook to call
+     * @defaultValue `EntryContext`
+     */
+    hookName?: string;
+  }
+
+  type JQueryOrHTML<IsJQuery extends boolean | undefined> = IsJQuery extends false ? HTMLElement : JQuery;
+}
+
+export default ContextMenu;