@ckeditor/ckeditor5-engine 36.0.1 → 37.0.0-alpha.0

package/src/view/observer/bubblingemittermixin.js

@@ -9,11 +9,20 @@ import { CKEditorError, EmitterMixin, EventInfo, toArray } from '@ckeditor/ckedi
 import BubblingEventInfo from './bubblingeventinfo';
 const contextsSymbol = Symbol('bubbling contexts');
 /**
- * Bubbling emitter mixin for the view document as described in the
- * {@link ~BubblingEmitter} interface.
+ * Bubbling emitter mixin for the view document as described in the {@link ~BubblingEmitter} interface.
  *
- * @mixin BubblingEmitterMixin
- * @implements module:engine/view/observer/bubblingemittermixin~BubblingEmitter
+ * This function creates a class that inherits from the provided `base` and implements `Emitter` interface.
+ * The base class must implement {@link module:utils/emittermixin~Emitter} interface.
+ *
+ * ```ts
+ * class BaseClass extends EmitterMixin() {
+ * 	// ...
+ * }
+ *
+ * class MyClass extends BubblingEmitterMixin( BaseClass ) {
+ * 	// This class derives from `BaseClass` and implements the `BubblingEmitter` interface.
+ * }
+ * ```
  */
 export default function BubblingEmitterMixin(base) {
     class Mixin extends base {
@@ -100,25 +109,26 @@ export default function BubblingEmitterMixin(base) {
         BubblingEmitterMixin[key] = mixin.prototype[key];
     });
 }
-// Update the event info bubbling fields.
-//
-// @param {module:utils/eventinfo~EventInfo} eventInfo The event info object to update.
-// @param {'none'|'capturing'|'atTarget'|'bubbling'} eventPhase The current event phase.
-// @param {module:engine/view/document~Document|module:engine/view/node~Node} currentTarget The current bubbling target.
+/**
+ * Update the event info bubbling fields.
+ *
+ * @param eventInfo The event info object to update.
+ * @param eventPhase The current event phase.
+ * @param currentTarget The current bubbling target.
+ */
 function updateEventInfo(eventInfo, eventPhase, currentTarget) {
     if (eventInfo instanceof BubblingEventInfo) {
         eventInfo._eventPhase = eventPhase;
         eventInfo._currentTarget = currentTarget;
     }
 }
-// Fires the listener for the specified context. Returns `true` if event was stopped.
-//
-// @private
-// @param {Map.<String|Function, module:utils/emittermixin~Emitter>} eventContexts
-// @param {String|module:engine/view/node~Node} context
-// @param {module:utils/eventinfo~EventInfo} eventInfo The `EventInfo` object.
-// @param {...*} [eventArgs] Additional arguments to be passed to the callbacks.
-// @returns {Boolean} True if event stop was called.
+/**
+ * Fires the listener for the specified context. Returns `true` if event was stopped.
+ *
+ * @param eventInfo The `EventInfo` object.
+ * @param eventArgs Additional arguments to be passed to the callbacks.
+ * @returns True if event stop was called.
+ */
 function fireListenerFor(eventContexts, context, eventInfo, ...eventArgs) {
     const emitter = typeof context == 'string' ? eventContexts.get(context) : getCustomContext(eventContexts, context);
     if (!emitter) {
@@ -127,12 +137,9 @@ function fireListenerFor(eventContexts, context, eventInfo, ...eventArgs) {
     emitter.fire(eventInfo, ...eventArgs);
     return eventInfo.stop.called;
 }
-// Returns an emitter for a specified view node.
-//
-// @private
-// @param {Map.<String|Function, module:utils/emittermixin~Emitter>} eventContexts
-// @param {module:engine/view/node~Node} node
-// @returns {module:utils/emittermixin~Emitter|null}
+/**
+ * Returns an emitter for a specified view node.
+ */
 function getCustomContext(eventContexts, node) {
     for (const [context, emitter] of eventContexts) {
         if (typeof context == 'function' && context(node)) {
@@ -141,14 +148,18 @@ function getCustomContext(eventContexts, node) {
     }
     return null;
 }
-// Returns bubbling contexts map for the source (emitter).
+/**
+ * Returns bubbling contexts map for the source (emitter).
+ */
 function getBubblingContexts(source) {
     if (!source[contextsSymbol]) {
         source[contextsSymbol] = new Map();
     }
     return source[contextsSymbol];
 }
-// Returns the deeper parent element for the range.
+/**
+ * Returns the deeper parent element for the range.
+ */
 function getDeeperRangeParent(range) {
     if (!range) {
         return null;

package/src/view/observer/bubblingeventinfo.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module engine/view/observer/bubblingeventinfo
+ */
+import { EventInfo } from '@ckeditor/ckeditor5-utils';
+import type Document from '../document';
+import type Node from '../node';
+import type Range from '../range';
+/**
+ * The event object passed to bubbling event callbacks. It is used to provide information about the event as well as a tool to
+ * manipulate it.
+ */
+export default class BubblingEventInfo<TName extends string = string, TReturn = unknown> extends EventInfo<TName, TReturn> {
+    /**
+     * The view range that the bubbling should start from.
+     */
+    readonly startRange: Range;
+    /**
+     * The current event phase.
+     */
+    private _eventPhase;
+    /**
+     * The current bubbling target.
+     */
+    private _currentTarget;
+    /**
+     * @param source The emitter.
+     * @param name The event name.
+     * @param startRange The view range that the bubbling should start from.
+     */
+    constructor(source: object, name: TName, startRange: Range);
+    /**
+     * The current event phase.
+     */
+    get eventPhase(): EventPhase;
+    /**
+     * The current bubbling target.
+     */
+    get currentTarget(): Document | Node | null;
+}
+/**
+ * The phase the event is in.
+ */
+export type EventPhase = 'none' | 'capturing' | 'atTarget' | 'bubbling';

package/src/view/observer/bubblingeventinfo.js

@@ -9,53 +9,27 @@ import { EventInfo } from '@ckeditor/ckeditor5-utils';
 /**
  * The event object passed to bubbling event callbacks. It is used to provide information about the event as well as a tool to
  * manipulate it.
- *
- * @extends module:utils/eventinfo~EventInfo
  */
 export default class BubblingEventInfo extends EventInfo {
     /**
-     * @param {Object} source The emitter.
-     * @param {String} name The event name.
-     * @param {module:engine/view/range~Range} startRange The view range that the bubbling should start from.
+     * @param source The emitter.
+     * @param name The event name.
+     * @param startRange The view range that the bubbling should start from.
      */
     constructor(source, name, startRange) {
         super(source, name);
-        /**
-         * The view range that the bubbling should start from.
-         *
-         * @readonly
-         * @member {module:engine/view/range~Range}
-         */
         this.startRange = startRange;
-        /**
-         * The current event phase.
-         *
-         * @protected
-         * @member {'none'|'capturing'|'atTarget'|'bubbling'}
-         */
         this._eventPhase = 'none';
-        /**
-         * The current bubbling target.
-         *
-         * @protected
-         * @member {module:engine/view/document~Document|module:engine/view/node~Node|null}
-         */
         this._currentTarget = null;
     }
     /**
      * The current event phase.
-     *
-     * @readonly
-     * @member {'none'|'capturing'|'atTarget'|'bubbling'}
      */
     get eventPhase() {
         return this._eventPhase;
     }
     /**
      * The current bubbling target.
-     *
-     * @readonly
-     * @member {module:engine/view/document~Document|module:engine/view/node~Node|null}
      */
     get currentTarget() {
         return this._currentTarget;

package/src/view/observer/clickobserver.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module engine/view/observer/clickobserver
+ */
+import DomEventObserver from './domeventobserver';
+import type DomEventData from './domeventdata';
+import type { BubblingEvent } from './bubblingemittermixin';
+/**
+ * {@link module:engine/view/document~Document#event:click Click} event observer.
+ *
+ * Note that this observer is not available by default. To make it available it needs to be added to
+ * {@link module:engine/view/view~View view controller} by a {@link module:engine/view/view~View#addObserver} method.
+ */
+export default class ClickObserver extends DomEventObserver<'click'> {
+    /**
+     * @inheritDoc
+     */
+    readonly domEventType: "click";
+    /**
+     * @inheritDoc
+     */
+    onDomEvent(domEvent: MouseEvent): void;
+}
+/**
+ * Fired when one of the editables has been clicked.
+ *
+ * Introduced by {@link module:engine/view/observer/clickobserver~ClickObserver}.
+ *
+ * Note that this event is not available by default. To make it available
+ * {@link module:engine/view/observer/clickobserver~ClickObserver} needs to be added
+ * to {@link module:engine/view/view~View} by a {@link module:engine/view/view~View#addObserver} method.
+ *
+ * @see module:engine/view/observer/clickobserver~ClickObserver
+ * @eventName click
+ * @param data Event data.
+ */
+export type ViewDocumentClickEvent = BubblingEvent<{
+    name: 'click';
+    args: [data: DomEventData<MouseEvent>];
+}>;

package/src/view/observer/clickobserver.js

@@ -10,30 +10,20 @@ import DomEventObserver from './domeventobserver';
  * {@link module:engine/view/document~Document#event:click Click} event observer.
  *
  * Note that this observer is not available by default. To make it available it needs to be added to
- * {@link module:engine/view/view~View view controller}
- * by a {@link module:engine/view/view~View#addObserver} method.
- *
- * @extends module:engine/view/observer/domeventobserver~DomEventObserver
+ * {@link module:engine/view/view~View view controller} by a {@link module:engine/view/view~View#addObserver} method.
  */
 export default class ClickObserver extends DomEventObserver {
-    constructor(view) {
-        super(view);
+    constructor() {
+        super(...arguments);
+        /**
+         * @inheritDoc
+         */
         this.domEventType = 'click';
     }
+    /**
+     * @inheritDoc
+     */
     onDomEvent(domEvent) {
         this.fire(domEvent.type, domEvent);
     }
 }
-/**
- * Fired when one of the editables has been clicked.
- *
- * Introduced by {@link module:engine/view/observer/clickobserver~ClickObserver}.
- *
- * Note that this event is not available by default. To make it available
- * {@link module:engine/view/observer/clickobserver~ClickObserver} needs to be added
- * to {@link module:engine/view/view~View} by a {@link module:engine/view/view~View#addObserver} method.
- *
- * @see module:engine/view/observer/clickobserver~ClickObserver
- * @event module:engine/view/document~Document#event:click
- * @param {module:engine/view/observer/domeventdata~DomEventData} data Event data.
- */

package/src/view/observer/compositionobserver.d.ts

@@ -0,0 +1,82 @@
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module engine/view/observer/compositionobserver
+ */
+import DomEventObserver from './domeventobserver';
+import type View from '../view';
+import type DomEventData from './domeventdata';
+/**
+ * {@link module:engine/view/document~Document#event:compositionstart Compositionstart},
+ * {@link module:engine/view/document~Document#event:compositionupdate compositionupdate} and
+ * {@link module:engine/view/document~Document#event:compositionend compositionend} events observer.
+ *
+ * Note that this observer is attached by the {@link module:engine/view/view~View} and is available by default.
+ */
+export default class CompositionObserver extends DomEventObserver<'compositionstart' | 'compositionupdate' | 'compositionend'> {
+    /**
+     * @inheritDoc
+     */
+    readonly domEventType: readonly ["compositionstart", "compositionupdate", "compositionend"];
+    /**
+     * @inheritDoc
+     */
+    constructor(view: View);
+    /**
+     * @inheritDoc
+     */
+    onDomEvent(domEvent: CompositionEvent): void;
+}
+export interface CompositionEventData extends DomEventData<CompositionEvent> {
+    data: string | null;
+}
+/**
+ * Fired when composition starts inside one of the editables.
+ *
+ * Introduced by {@link module:engine/view/observer/compositionobserver~CompositionObserver}.
+ *
+ * Note that because {@link module:engine/view/observer/compositionobserver~CompositionObserver} is attached by the
+ * {@link module:engine/view/view~View} this event is available by default.
+ *
+ * @see module:engine/view/observer/compositionobserver~CompositionObserver
+ * @eventName compositionstart
+ * @param data Event data.
+ */
+export type ViewDocumentCompositionStartEvent = {
+    name: 'compositionstart';
+    args: [data: CompositionEventData];
+};
+/**
+ * Fired when composition is updated inside one of the editables.
+ *
+ * Introduced by {@link module:engine/view/observer/compositionobserver~CompositionObserver}.
+ *
+ * Note that because {@link module:engine/view/observer/compositionobserver~CompositionObserver} is attached by the
+ * {@link module:engine/view/view~View} this event is available by default.
+ *
+ * @see module:engine/view/observer/compositionobserver~CompositionObserver
+ * @eventName compositionupdate
+ * @param data Event data.
+ */
+export type ViewDocumentCompositionUpdateEvent = {
+    name: 'compositionupdate';
+    args: [data: CompositionEventData];
+};
+/**
+ * Fired when composition ends inside one of the editables.
+ *
+ * Introduced by {@link module:engine/view/observer/compositionobserver~CompositionObserver}.
+ *
+ * Note that because {@link module:engine/view/observer/compositionobserver~CompositionObserver} is attached by the
+ * {@link module:engine/view/view~View} this event is available by default.
+ *
+ * @see module:engine/view/observer/compositionobserver~CompositionObserver
+ * @eventName compositionend
+ * @param data Event data.
+ */
+export type ViewDocumentCompositionEndEvent = {
+    name: 'compositionend';
+    args: [data: CompositionEventData];
+};

package/src/view/observer/compositionobserver.js

@@ -12,16 +12,20 @@ import DomEventObserver from './domeventobserver';
  * {@link module:engine/view/document~Document#event:compositionend compositionend} events observer.
  *
  * Note that this observer is attached by the {@link module:engine/view/view~View} and is available by default.
- *
- * @extends module:engine/view/observer/domeventobserver~DomEventObserver
  */
 export default class CompositionObserver extends DomEventObserver {
+    /**
+     * @inheritDoc
+     */
     constructor(view) {
         super(view);
+        /**
+         * @inheritDoc
+         */
         this.domEventType = ['compositionstart', 'compositionupdate', 'compositionend'];
         const document = this.document;
         document.on('compositionstart', () => {
-            // @if CK_DEBUG_TYPING // if ( window.logCKETyping ) {
+            // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
             // @if CK_DEBUG_TYPING // 	console.log( '%c[CompositionObserver] ' +
             // @if CK_DEBUG_TYPING // 		'┌───────────────────────────── isComposing = true ─────────────────────────────┐',
             // @if CK_DEBUG_TYPING // 		'font-weight: bold; color: green'
@@ -30,7 +34,7 @@ export default class CompositionObserver extends DomEventObserver {
             document.isComposing = true;
         }, { priority: 'low' });
         document.on('compositionend', () => {
-            // @if CK_DEBUG_TYPING // if ( window.logCKETyping ) {
+            // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
             // @if CK_DEBUG_TYPING // 	console.log( '%c[CompositionObserver] ' +
             // @if CK_DEBUG_TYPING // 		'└───────────────────────────── isComposing = false ─────────────────────────────┘',
             // @if CK_DEBUG_TYPING // 		'font-weight: bold; color: green'
@@ -39,51 +43,18 @@ export default class CompositionObserver extends DomEventObserver {
             document.isComposing = false;
         }, { priority: 'low' });
     }
+    /**
+     * @inheritDoc
+     */
     onDomEvent(domEvent) {
-        // @if CK_DEBUG_TYPING // if ( window.logCKETyping ) {
+        // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
         // @if CK_DEBUG_TYPING // 	console.group( `%c[CompositionObserver]%c ${ domEvent.type }`, 'color: green', '' );
         // @if CK_DEBUG_TYPING // }
         this.fire(domEvent.type, domEvent, {
             data: domEvent.data
         });
-        // @if CK_DEBUG_TYPING // if ( window.logCKETyping ) {
+        // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
         // @if CK_DEBUG_TYPING // 	console.groupEnd();
         // @if CK_DEBUG_TYPING // }
     }
 }
-/**
- * Fired when composition starts inside one of the editables.
- *
- * Introduced by {@link module:engine/view/observer/compositionobserver~CompositionObserver}.
- *
- * Note that because {@link module:engine/view/observer/compositionobserver~CompositionObserver} is attached by the
- * {@link module:engine/view/view~View} this event is available by default.
- *
- * @see module:engine/view/observer/compositionobserver~CompositionObserver
- * @event module:engine/view/document~Document#event:compositionstart
- * @param {module:engine/view/observer/domeventdata~DomEventData} data Event data.
- */
-/**
- * Fired when composition is updated inside one of the editables.
- *
- * Introduced by {@link module:engine/view/observer/compositionobserver~CompositionObserver}.
- *
- * Note that because {@link module:engine/view/observer/compositionobserver~CompositionObserver} is attached by the
- * {@link module:engine/view/view~View} this event is available by default.
- *
- * @see module:engine/view/observer/compositionobserver~CompositionObserver
- * @event module:engine/view/document~Document#event:compositionupdate
- * @param {module:engine/view/observer/domeventdata~DomEventData} data Event data.
- */
-/**
- * Fired when composition ends inside one of the editables.
- *
- * Introduced by {@link module:engine/view/observer/compositionobserver~CompositionObserver}.
- *
- * Note that because {@link module:engine/view/observer/compositionobserver~CompositionObserver} is attached by the
- * {@link module:engine/view/view~View} this event is available by default.
- *
- * @see module:engine/view/observer/compositionobserver~CompositionObserver
- * @event module:engine/view/document~Document#event:compositionend
- * @param {module:engine/view/observer/domeventdata~DomEventData} data Event data.
- */

package/src/view/observer/domeventdata.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+import type Document from '../document';
+import type Element from '../element';
+import type View from '../view';
+/**
+ * Information about a DOM event in context of the {@link module:engine/view/document~Document}.
+ * It wraps the native event, which usually should not be used as the wrapper contains
+ * additional data (like key code for keyboard events).
+ *
+ * @typeParam TEvent The type of DOM Event that this class represents.
+ */
+export default class DomEventData<TEvent extends Event = Event> {
+    /**
+     * Instance of the view controller.
+     */
+    readonly view: View;
+    /**
+     * The instance of the document.
+     */
+    readonly document: Document;
+    /**
+     * The DOM event.
+     */
+    readonly domEvent: TEvent;
+    /**
+     * The DOM target.
+     */
+    readonly domTarget: HTMLElement;
+    /**
+     * @param view The instance of the view controller.
+     * @param domEvent The DOM event.
+     * @param additionalData Additional properties that the instance should contain.
+     */
+    constructor(view: View, domEvent: TEvent, additionalData?: object);
+    /**
+     * The tree view element representing the target.
+     */
+    get target(): Element;
+    /**
+     * Prevents the native's event default action.
+     */
+    preventDefault(): void;
+    /**
+     * Stops native event propagation.
+     */
+    stopPropagation(): void;
+}

package/src/view/observer/domeventdata.js

@@ -10,49 +10,24 @@ import { extend } from 'lodash-es';
  * Information about a DOM event in context of the {@link module:engine/view/document~Document}.
  * It wraps the native event, which usually should not be used as the wrapper contains
  * additional data (like key code for keyboard events).
+ *
+ * @typeParam TEvent The type of DOM Event that this class represents.
  */
 export default class DomEventData {
     /**
-     * @param {module:engine/view/view~View} view The instance of the view controller.
-     * @param {Event} domEvent The DOM event.
-     * @param {Object} [additionalData] Additional properties that the instance should contain.
+     * @param view The instance of the view controller.
+     * @param domEvent The DOM event.
+     * @param additionalData Additional properties that the instance should contain.
      */
     constructor(view, domEvent, additionalData) {
-        /**
-         * Instance of the view controller.
-         *
-         * @readonly
-         * @member {module:engine/view/view~View} module:engine/view/observer/observer~Observer.DomEvent#view
-         */
         this.view = view;
-        /**
-         * The instance of the document.
-         *
-         * @readonly
-         * @member {module:engine/view/document~Document} module:engine/view/observer/observer~Observer.DomEvent#document
-         */
         this.document = view.document;
-        /**
-         * The DOM event.
-         *
-         * @readonly
-         * @member {Event} module:engine/view/observer/observer~Observer.DomEvent#domEvent
-         */
         this.domEvent = domEvent;
-        /**
-         * The DOM target.
-         *
-         * @readonly
-         * @member {HTMLElement} module:engine/view/observer/observer~Observer.DomEvent#target
-         */
         this.domTarget = domEvent.target;
         extend(this, additionalData);
     }
     /**
      * The tree view element representing the target.
-     *
-     * @readonly
-     * @type module:engine/view/element~Element
      */
     get target() {
         return this.view.domConverter.mapDomToView(this.domTarget);

package/src/view/observer/domeventobserver.d.ts

@@ -0,0 +1,69 @@
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module engine/view/observer/domeventobserver
+ */
+import Observer from './observer';
+import type { EventInfo } from '@ckeditor/ckeditor5-utils';
+/**
+ * Base class for DOM event observers. This class handles
+ * {@link module:engine/view/observer/observer~Observer#observe adding} listeners to DOM elements,
+ * {@link module:engine/view/observer/observer~Observer#disable disabling} and
+ * {@link module:engine/view/observer/observer~Observer#enable re-enabling} events.
+ * Child class needs to define
+ * {@link module:engine/view/observer/domeventobserver~DomEventObserver#domEventType DOM event type} and
+ * {@link module:engine/view/observer/domeventobserver~DomEventObserver#onDomEvent callback}.
+ *
+ * For instance:
+ *
+ * ```ts
+ * class ClickObserver extends DomEventObserver<'click'> {
+ * 	// It can also be defined as a normal property in the constructor.
+ * 	get domEventType(): 'click' {
+ * 		return 'click';
+ * 	}
+ *
+ * 	onDomEvent( domEvent: MouseEvent ): void {
+ * 		this.fire( 'click', domEvent );
+ * 	}
+ * }
+ * ```
+ *
+ * @typeParam EventType DOM Event type name or an union of those.
+ * @typeParam AdditionalData Additional data passed along with the event.
+ */
+export default abstract class DomEventObserver<EventType extends keyof HTMLElementEventMap, AdditionalData extends object = object> extends Observer {
+    /**
+     * Type of the DOM event the observer should listen to. Array of types can be defined
+     * if the observer should listen to multiple DOM events.
+     */
+    abstract get domEventType(): EventType | ReadonlyArray<EventType>;
+    /**
+     * If set to `true` DOM events will be listened on the capturing phase.
+     * Default value is `false`.
+     */
+    useCapture: boolean;
+    /**
+     * Callback which should be called when the DOM event occurred. Note that the callback will not be called if
+     * observer {@link #isEnabled is not enabled}.
+     *
+     * @see #domEventType
+     */
+    abstract onDomEvent(event: HTMLElementEventMap[EventType]): void;
+    /**
+     * @inheritDoc
+     */
+    observe(domElement: HTMLElement): void;
+    /**
+     * Calls `Document#fire()` if observer {@link #isEnabled is enabled}.
+     *
+     * @see module:utils/emittermixin~Emitter#fire
+     * @param eventType The event type (name).
+     * @param domEvent The DOM event.
+     * @param additionalData The additional data which should extend the
+     * {@link module:engine/view/observer/domeventdata~DomEventData event data} object.
+     */
+    fire(eventType: string | EventInfo, domEvent: Event, additionalData?: AdditionalData): void;
+}