@ckeditor/ckeditor5-core 0.0.0-internal-20241017.0

package/CHANGELOG.md

@@ -0,0 +1,4 @@
+Changelog
+=========
+
+All changes in the package are documented in https://github.com/ckeditor/ckeditor5/blob/master/CHANGELOG.md.

package/LICENSE.md

@@ -0,0 +1,21 @@
+Software License Agreement
+==========================
+
+**CKEditor&nbsp;5 core editor architecture** – https://github.com/ckeditor/ckeditor5-core <br>
+Copyright (c) 2003–2024, [CKSource Holding sp. z o.o.](https://cksource.com) All rights reserved.
+
+Licensed under the terms of [GNU General Public License Version 2 or later](http://www.gnu.org/licenses/gpl.html).
+
+Sources of Intellectual Property Included in CKEditor
+-----------------------------------------------------
+
+Where not otherwise indicated, all CKEditor content is authored by CKSource engineers and consists of CKSource-owned intellectual property. In some specific instances, CKEditor will incorporate work done by developers outside of CKSource with their express permission.
+
+The following libraries are included in CKEditor under the [MIT license](https://opensource.org/licenses/MIT):
+
+* Lodash - Copyright (c) JS Foundation and other contributors https://js.foundation/. Based on Underscore.js, copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors http://underscorejs.org/.
+
+Trademarks
+----------
+
+**CKEditor** is a trademark of [CKSource Holding sp. z o.o.](https://cksource.com) All other brand and product names are trademarks, registered trademarks, or service marks of their respective holders.

package/README.md

@@ -0,0 +1,24 @@
+CKEditor 5 core editor architecture
+========================================
+
+[![npm version](https://badge.fury.io/js/%40ckeditor%2Fckeditor5-core.svg)](https://www.npmjs.com/package/@ckeditor/ckeditor5-core)
+[![Coverage Status](https://coveralls.io/repos/github/ckeditor/ckeditor5/badge.svg?branch=master)](https://coveralls.io/github/ckeditor/ckeditor5?branch=master)
+[![Build Status](https://travis-ci.com/ckeditor/ckeditor5.svg?branch=master)](https://app.travis-ci.com/github/ckeditor/ckeditor5)
+
+This package implements CKEditor 5's core editor architecture – a set of classes and interfaces which glue everything together.
+
+## Documentation
+
+For general introduction see the [Overview of CKEditor 5 framework](https://ckeditor.com/docs/ckeditor5/latest/framework/index.html) guide and then the [core editor architecture guide](https://ckeditor.com/docs/ckeditor5/latest/framework/architecture/core-editor-architecture.html).
+
+Additionally, see the [`@ckeditor/ckeditor5-core` package](https://ckeditor.com/docs/ckeditor5/latest/api/core.html) page in [CKEditor 5 documentation](https://ckeditor.com/docs/ckeditor5/latest/) for even more information.
+
+## Installation
+
+```bash
+npm install ckeditor5
+```
+
+## License
+
+Licensed under the terms of [GNU General Public License Version 2 or later](http://www.gnu.org/licenses/gpl.html). For full details about the license, please check the `LICENSE.md` file or [https://ckeditor.com/legal/ckeditor-oss-license](https://ckeditor.com/legal/ckeditor-oss-license).

package/dist/accessibility.d.ts

@@ -0,0 +1,365 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+import type Editor from './editor/editor.js';
+export declare const DEFAULT_GROUP_ID: "common";
+/**
+ * A common namespace for various accessibility features of the editor.
+ *
+ * **Information about editor keystrokes**
+ *
+ * * The information about keystrokes available in the editor is stored in the {@link #keystrokeInfos} property.
+ * * New info entries can be added using the {@link #addKeystrokeInfoCategory}, {@link #addKeystrokeInfoGroup},
+ * and {@link #addKeystrokeInfos} methods.
+ */
+export default class Accessibility {
+    /**
+     * Stores information about keystrokes brought by editor features for the users to interact with the editor, mainly
+     * keystroke combinations and their accessible labels.
+     *
+     * This information is particularly useful for screen reader and other assistive technology users. It gets displayed
+     * by the {@link module:ui/editorui/accessibilityhelp/accessibilityhelp~AccessibilityHelp Accessibility help} dialog.
+     *
+     * Keystrokes are organized in categories and groups. They can be added using ({@link #addKeystrokeInfoCategory},
+     * {@link #addKeystrokeInfoGroup}, and {@link #addKeystrokeInfos}) methods.
+     *
+     * Please note that:
+     * * two categories are always available:
+     *   * `'contentEditing'` for keystrokes related to content creation,
+     *   * `'navigation'` for keystrokes related to navigation in the UI and the content.
+     * * unless specified otherwise, new keystrokes are added into the `'contentEditing'` category and the `'common'`
+     * keystroke group within that category while using the {@link #addKeystrokeInfos} method.
+     */
+    readonly keystrokeInfos: KeystrokeInfos;
+    /**
+     * The editor instance.
+     */
+    private readonly _editor;
+    /**
+     * @inheritDoc
+     */
+    constructor(editor: Editor);
+    /**
+     * Adds a top-level category in the {@link #keystrokeInfos keystroke information database} with a label and optional description.
+     *
+     * Categories organize keystrokes and help users to find the right keystroke. Each category can have multiple groups
+     * of keystrokes that narrow down the context in which the keystrokes are available. Every keystroke category comes
+     * with a `'common'` group by default.
+     *
+     * By default, two categories are available:
+     * * `'contentEditing'` for keystrokes related to content creation,
+     * * `'navigation'` for keystrokes related to navigation in the UI and the content.
+     *
+     * To create a new keystroke category with new groups, use the following code:
+     *
+     * ```js
+     * class MyPlugin extends Plugin {
+     * 	// ...
+     * 	init() {
+     * 		const editor = this.editor;
+     * 		const t = editor.t;
+     *
+     * 		// ...
+     *
+     * 		editor.accessibility.addKeystrokeInfoCategory( {
+     * 			id: 'myCategory',
+     * 			label: t( 'My category' ),
+     * 			description: t( 'My category description.' ),
+     * 			groups: [
+     * 				{
+     * 					id: 'myGroup',
+     * 					label: t( 'My keystroke group' ),
+     * 					keystrokes: [
+     * 						{
+     * 							label: t( 'Keystroke label 1' ),
+     * 							keystroke: 'Ctrl+Shift+N'
+     * 						},
+     * 						{
+     * 							label: t( 'Keystroke label 2' ),
+     * 							keystroke: 'Ctrl+Shift+M'
+     * 						}
+     * 					]
+     * 				}
+     * 			]
+     * 		};
+     * 	}
+     * }
+     * ```
+     *
+     * See {@link #keystrokeInfos}, {@link #addKeystrokeInfoGroup}, and {@link #addKeystrokeInfos}.
+     */
+    addKeystrokeInfoCategory({ id, label, description, groups }: AddKeystrokeInfoCategoryData): void;
+    /**
+     * Adds a group of keystrokes in a specific category to the {@link #keystrokeInfos keystroke information database}.
+     *
+     * Groups narrow down the context in which the keystrokes are available. When `categoryId` is not specified,
+     * the group goes to the `'contentEditing'` category (default).
+     *
+     * To create a new group within an existing category, use the following code:
+     *
+     * ```js
+     * class MyPlugin extends Plugin {
+     * 	// ...
+     * 	init() {
+     * 		const editor = this.editor;
+     * 		const t = editor.t;
+     *
+     * 		// ...
+     *
+     * 		editor.accessibility.addKeystrokeInfoGroup( {
+     * 			id: 'myGroup',
+     * 			categoryId: 'navigation',
+     * 			label: t( 'My keystroke group' ),
+     * 			keystrokes: [
+     * 				{
+     * 					label: t( 'Keystroke label 1' ),
+     * 					keystroke: 'Ctrl+Shift+N'
+     * 				},
+     * 				{
+     * 					label: t( 'Keystroke label 2' ),
+     * 					keystroke: 'Ctrl+Shift+M'
+     * 				}
+     * 			]
+     * 		} );
+     * 	}
+     * }
+     * ```
+     *
+     * See {@link #keystrokeInfos}, {@link #addKeystrokeInfoCategory}, and {@link #addKeystrokeInfos}.
+     */
+    addKeystrokeInfoGroup({ categoryId, id, label, keystrokes }: AddKeystrokeInfoGroupData): void;
+    /**
+     * Adds information about keystrokes to the {@link #keystrokeInfos keystroke information database}.
+     *
+     * Keystrokes without specified `groupId` or `categoryId` go to the `'common'` group in the `'contentEditing'` category (default).
+     *
+     * To add a keystroke brought by your plugin (using default group and category), use the following code:
+     *
+     * ```js
+     * class MyPlugin extends Plugin {
+     * 	// ...
+     * 	init() {
+     * 		const editor = this.editor;
+     * 		const t = editor.t;
+     *
+     * 		// ...
+     *
+     * 		editor.accessibility.addKeystrokeInfos( {
+     * 			keystrokes: [
+     * 				{
+     * 					label: t( 'Keystroke label' ),
+     * 					keystroke: 'CTRL+B'
+     * 				}
+     * 			]
+     * 		} );
+     * 	}
+     * }
+     * ```
+     * To add a keystroke in a specific existing `'widget'` group in the default `'contentEditing'` category:
+     *
+     * ```js
+     * class MyPlugin extends Plugin {
+     * 	// ...
+     * 	init() {
+     * 		const editor = this.editor;
+     * 		const t = editor.t;
+     *
+     * 		// ...
+     *
+     * 		editor.accessibility.addKeystrokeInfos( {
+     * 			// Add a keystroke to the existing "widget" group.
+     * 			groupId: 'widget',
+     * 			keystrokes: [
+     * 				{
+     * 					label: t( 'A an action on a selected widget' ),
+     * 					keystroke: 'Ctrl+D',
+     * 				}
+     * 			]
+     * 		} );
+     * 	}
+     * }
+     * ```
+     *
+     * To add a keystroke to another existing category (using default group):
+     *
+     * ```js
+     * class MyPlugin extends Plugin {
+     * 	// ...
+     * 	init() {
+     * 		const editor = this.editor;
+     * 		const t = editor.t;
+     *
+     * 		// ...
+     *
+     * 		editor.accessibility.addKeystrokeInfos( {
+     * 			// Add keystrokes to the "navigation" category (one of defaults).
+     * 			categoryId: 'navigation',
+     * 			keystrokes: [
+     * 				{
+     * 					label: t( 'Keystroke label' ),
+     * 					keystroke: 'CTRL+B'
+     * 				}
+     * 			]
+     * 		} );
+     * 	}
+     * }
+     * ```
+     *
+     * See {@link #keystrokeInfos}, {@link #addKeystrokeInfoGroup}, and {@link #addKeystrokeInfoCategory}.
+     */
+    addKeystrokeInfos({ categoryId, groupId, keystrokes }: AddKeystrokeInfosData): void;
+}
+/**
+ * A description of category of keystrokes accepted by the {@link module:core/accessibility~Accessibility#addKeystrokeInfoCategory} method.
+ *
+ * Top-level categories organize keystrokes and help users to find the right keystroke. Each category can have multiple groups of
+ * keystrokes that narrow down the context in which the keystrokes are available.
+ *
+ * See {@link module:core/accessibility~Accessibility#addKeystrokeInfoGroup} and
+ * {@link module:core/accessibility~Accessibility#addKeystrokeInfos}.
+ */
+export interface AddKeystrokeInfoCategoryData {
+    /**
+     * The unique id of the category.
+     */
+    id: string;
+    /**
+     * The label of the category.
+     */
+    label: string;
+    /**
+     * The description of the category (optional).
+     */
+    description?: string;
+    /**
+     * Groups of keystrokes within the category.
+     */
+    groups?: Array<AddKeystrokeInfoGroupData>;
+}
+/**
+ * A description of keystroke group accepted by the {@link module:core/accessibility~Accessibility#addKeystrokeInfoGroup} method.
+ *
+ * Groups narrow down the context in which the keystrokes are available. When `categoryId` is not specified, the group goes
+ * to the `'contentEditing'` category (default).
+ *
+ * See {@link module:core/accessibility~Accessibility#addKeystrokeInfoCategory} and
+ * {@link module:core/accessibility~Accessibility#addKeystrokeInfos}.
+ */
+export interface AddKeystrokeInfoGroupData {
+    /**
+     * The category id the group belongs to.
+     */
+    categoryId?: string;
+    /**
+     * The unique id of the group.
+     */
+    id: string;
+    /**
+     * The label of the group (optional).
+     */
+    label?: string;
+    /**
+     * Keystroke definitions within the group.
+     */
+    keystrokes?: Array<KeystrokeInfoDefinition>;
+}
+/**
+ * Description of keystrokes accepted by the {@link module:core/accessibility~Accessibility#addKeystrokeInfos} method.
+ *
+ * Keystrokes without specified `groupId` or `categoryId` go to the `'common'` group in the `'contentEditing'` category (default).
+ *
+ * See {@link module:core/accessibility~Accessibility#addKeystrokeInfoCategory} and
+ * {@link module:core/accessibility~Accessibility#addKeystrokeInfoGroup}.
+ */
+export interface AddKeystrokeInfosData {
+    /**
+     * The category id the keystrokes belong to.
+     */
+    categoryId?: string;
+    /**
+     * The group id the keystrokes belong to.
+     */
+    groupId?: string;
+    /**
+     * An array of keystroke definitions.
+     */
+    keystrokes: Array<KeystrokeInfoDefinition>;
+}
+export type KeystrokeInfos = Map<string, KeystrokeInfoCategory>;
+/**
+ * A category of keystrokes in {@link module:core/accessibility~Accessibility#keystrokeInfos}.
+ */
+export type KeystrokeInfoCategory = {
+    /**
+     * The unique id of the category.
+     */
+    id: string;
+    /**
+     * The label of the category.
+     */
+    label: string;
+    /**
+     * The description of the category (optional).
+     */
+    description?: string;
+    /**
+     * Groups of keystrokes within the category.
+     */
+    groups: Map<string, KeystrokeInfoGroup>;
+};
+/**
+ * A group of keystrokes in {@link module:core/accessibility~Accessibility#keystrokeInfos}.
+ */
+export type KeystrokeInfoGroup = {
+    /**
+     * The unique id of the group.
+     */
+    id: string;
+    /**
+     * The label of the group (optional).
+     */
+    label?: string;
+    /**
+     * Keystroke definitions within the group.
+     */
+    keystrokes: Array<KeystrokeInfoDefinition>;
+};
+/**
+ * A keystroke info definition in {@link module:core/accessibility~Accessibility#keystrokeInfos}
+ */
+export interface KeystrokeInfoDefinition {
+    /**
+     * The label of the keystroke. It should briefly describe the action that the keystroke performs. It may contain HTML.
+     */
+    label: string;
+    /**
+     * The keystroke string. In its basic form, it must be a combination of {@link module:utils/keyboard#keyCodes known key names}
+     * joined by the `+` sign, the same as the keystroke format accepted by the
+     * {@link module:utils/keystrokehandler~KeystrokeHandler#set `KeystrokeHandler#set()`} method used to register most of the
+     * keystroke interactions in the editor.
+     *
+     * * The keystroke string can represent a single keystroke, for instance: `keystroke: 'Ctrl+B'`, `keystroke: 'Shift+Enter'`,
+     * `keystroke: 'Alt+F10'`, etc.
+     * * The keystroke can be activated by successive press of multiple keys. For instance `keystroke: [ [ 'arrowleft', 'arrowleft' ] ]`
+     * will indicate that a specific action will be performed by pressing <kbd>←</kbd> twice in a row.
+     * * Keystrokes can have alternatives. For instance `keystroke: [ [ 'Ctrl+Y' ], [ 'Ctrl+Shift+Z' ] ]` will indicate that
+     * a specific action can be performed by pressing either <kbd>Ctrl</kbd> + <kbd>Y</kbd> or
+     * <kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>Z</kbd>.
+     *
+     * Please note that the keystrokes are automatically translated to the environment-specific form. For example, `Ctrl+A`
+     * will be rendered as `⌘A` in the {@link module:utils/env~EnvType#isMac Mac environment}. Always use the IBM PC keyboard
+     * syntax, for instance `Ctrl` instead of `⌘`, `Alt` instead of `⌥`, etc.
+     */
+    keystroke: string | Array<string> | Array<Array<string>>;
+    /**
+     * This (optional) flag suggests that the keystroke(s) may require a function (<kbd>Fn</kbd>) key to be pressed
+     * in order to work in the {@link module:utils/env~EnvType#isMac Mac environment}. If set `true`, an additional
+     * information will be displayed next to the keystroke.
+     */
+    mayRequireFn?: boolean;
+}

package/dist/augmentation.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+import type { PendingActions } from './index.js';
+declare module '@ckeditor/ckeditor5-core' {
+    interface PluginsMap {
+        [PendingActions.pluginName]: PendingActions;
+    }
+}

package/dist/command.d.ts

@@ -0,0 +1,193 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module core/command
+ */
+import { type DecoratedMethodEvent } from '@ckeditor/ckeditor5-utils';
+import type Editor from './editor/editor.js';
+declare const Command_base: {
+    new (): import("@ckeditor/ckeditor5-utils").Observable;
+    prototype: import("@ckeditor/ckeditor5-utils").Observable;
+};
+/**
+ * Base class for the CKEditor commands.
+ *
+ * Commands are the main way to manipulate the editor contents and state. They are mostly used by UI elements (or by other
+ * commands) to make changes in the model. Commands are available in every part of the code that has access to
+ * the {@link module:core/editor/editor~Editor editor} instance.
+ *
+ * Instances of registered commands can be retrieved from {@link module:core/editor/editor~Editor#commands `editor.commands`}.
+ * The easiest way to execute a command is through {@link module:core/editor/editor~Editor#execute `editor.execute()`}.
+ *
+ * By default, commands are disabled when the editor is in the {@link module:core/editor/editor~Editor#isReadOnly read-only} mode
+ * but commands with the {@link module:core/command~Command#affectsData `affectsData`} flag set to `false` will not be disabled.
+ */
+export default class Command extends /* #__PURE__ */ Command_base {
+    /**
+     * The editor on which this command will be used.
+     */
+    readonly editor: Editor;
+    /**
+     * The value of the command. A given command class should define what it represents for it.
+     *
+     * For example, the `'bold'` command's value indicates whether the selection starts in a bolded text.
+     * And the value of the `'link'` command may be an object with link details.
+     *
+     * It is possible for a command to have no value (e.g. for stateless actions such as `'uploadImage'`).
+     *
+     * A given command class should control this value by overriding the {@link #refresh `refresh()`} method.
+     *
+     * @observable
+     * @readonly
+     */
+    value: unknown;
+    /**
+     * Flag indicating whether a command is enabled or disabled.
+     * A disabled command will do nothing when executed.
+     *
+     * A given command class should control this value by overriding the {@link #refresh `refresh()`} method.
+     *
+     * It is possible to disable a command "from outside" using {@link #forceDisabled} method.
+     *
+     * @observable
+     * @readonly
+     */
+    isEnabled: boolean;
+    /**
+     * A flag indicating whether a command's `isEnabled` state should be changed depending on where the document
+     * selection is placed.
+     *
+     * By default, it is set to `true`. If the document selection is placed in a
+     * {@link module:engine/model/model~Model#canEditAt non-editable} place (such as non-editable root), the command becomes disabled.
+     *
+     * The flag should be changed to `false` in a concrete command's constructor if the command should not change its `isEnabled`
+     * accordingly to the document selection.
+     */
+    protected _isEnabledBasedOnSelection: boolean;
+    /**
+     * A flag indicating whether a command execution changes the editor data or not.
+     *
+     * @see #affectsData
+     */
+    private _affectsData;
+    /**
+     * Holds identifiers for {@link #forceDisabled} mechanism.
+     */
+    private readonly _disableStack;
+    /**
+     * Creates a new `Command` instance.
+     *
+     * @param editor The editor on which this command will be used.
+     */
+    constructor(editor: Editor);
+    /**
+     * A flag indicating whether a command execution changes the editor data or not.
+     *
+     * Commands with `affectsData` set to `false` will not be automatically disabled in
+     * the {@link module:core/editor/editor~Editor#isReadOnly read-only mode} and
+     * {@glink features/read-only#related-features other editor modes} with restricted user write permissions.
+     *
+     * **Note:** You do not have to set it for your every command. It is `true` by default.
+     *
+     * @default true
+     */
+    get affectsData(): boolean;
+    protected set affectsData(affectsData: boolean);
+    /**
+     * Refreshes the command. The command should update its {@link #isEnabled} and {@link #value} properties
+     * in this method.
+     *
+     * This method is automatically called when
+     * {@link module:engine/model/document~Document#event:change any changes are applied to the document}.
+     */
+    refresh(): void;
+    /**
+     * Disables the command.
+     *
+     * Command may be disabled by multiple features or algorithms (at once). When disabling a command, unique id should be passed
+     * (e.g. the feature name). The same identifier should be used when {@link #clearForceDisabled enabling back} the command.
+     * The command becomes enabled only after all features {@link #clearForceDisabled enabled it back}.
+     *
+     * Disabling and enabling a command:
+     *
+     * ```ts
+     * command.isEnabled; // -> true
+     * command.forceDisabled( 'MyFeature' );
+     * command.isEnabled; // -> false
+     * command.clearForceDisabled( 'MyFeature' );
+     * command.isEnabled; // -> true
+     * ```
+     *
+     * Command disabled by multiple features:
+     *
+     * ```ts
+     * command.forceDisabled( 'MyFeature' );
+     * command.forceDisabled( 'OtherFeature' );
+     * command.clearForceDisabled( 'MyFeature' );
+     * command.isEnabled; // -> false
+     * command.clearForceDisabled( 'OtherFeature' );
+     * command.isEnabled; // -> true
+     * ```
+     *
+     * Multiple disabling with the same identifier is redundant:
+     *
+     * ```ts
+     * command.forceDisabled( 'MyFeature' );
+     * command.forceDisabled( 'MyFeature' );
+     * command.clearForceDisabled( 'MyFeature' );
+     * command.isEnabled; // -> true
+     * ```
+     *
+     * **Note:** some commands or algorithms may have more complex logic when it comes to enabling or disabling certain commands,
+     * so the command might be still disabled after {@link #clearForceDisabled} was used.
+     *
+     * @param id Unique identifier for disabling. Use the same id when {@link #clearForceDisabled enabling back} the command.
+     */
+    forceDisabled(id: string): void;
+    /**
+     * Clears forced disable previously set through {@link #forceDisabled}. See {@link #forceDisabled}.
+     *
+     * @param id Unique identifier, equal to the one passed in {@link #forceDisabled} call.
+     */
+    clearForceDisabled(id: string): void;
+    /**
+     * Executes the command.
+     *
+     * A command may accept parameters. They will be passed from {@link module:core/editor/editor~Editor#execute `editor.execute()`}
+     * to the command.
+     *
+     * The `execute()` method will automatically abort when the command is disabled ({@link #isEnabled} is `false`).
+     * This behavior is implemented by a high priority listener to the {@link #event:execute} event.
+     *
+     * In order to see how to disable a command from "outside" see the {@link #isEnabled} documentation.
+     *
+     * This method may return a value, which would be forwarded all the way down to the
+     * {@link module:core/editor/editor~Editor#execute `editor.execute()`}.
+     *
+     * @fires execute
+     */
+    execute(...args: Array<unknown>): unknown;
+    /**
+     * Destroys the command.
+     */
+    destroy(): void;
+}
+/**
+ * Event fired by the {@link module:core/command~Command#execute} method. The command action is a listener to this event so it's
+ * possible to change/cancel the behavior of the command by listening to this event.
+ *
+ * See {@link module:utils/observablemixin~Observable#decorate} for more information and samples.
+ *
+ * **Note:** This event is fired even if command is disabled. However, it is automatically blocked
+ * by a high priority listener in order to prevent command execution.
+ *
+ * @eventName ~Command#execute
+ */
+export type CommandExecuteEvent = DecoratedMethodEvent<Command, 'execute'>;
+export {};