@ckeditor/ckeditor5-core 41.2.0 → 41.3.0-alpha.0

package/dist/types/editor/utils/dataapimixin.d.ts

@@ -0,0 +1,79 @@
+/**
+ * @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/editor/utils/dataapimixin
+ */
+import type Editor from '../editor.js';
+import type { Constructor } from '@ckeditor/ckeditor5-utils';
+/**
+ * Implementation of the {@link module:core/editor/utils/dataapimixin~DataApi}.
+ *
+ * @deprecated This functionality is already implemented by the `Editor` class.
+ */
+export default function DataApiMixin<Base extends Constructor<Editor>>(base: Base): Base;
+/**
+ * Interface defining editor methods for setting and getting data to and from the editor's main root element
+ * using the {@link module:core/editor/editor~Editor#data data pipeline}.
+ *
+ * This interface is not a part of the {@link module:core/editor/editor~Editor} class because one may want to implement
+ * an editor with multiple root elements, in which case the methods for setting and getting data will need to be implemented
+ * differently.
+ *
+ * @deprecated This interface is implemented by all `Editor` instances by default.
+ */
+export interface DataApi {
+    /**
+     * Sets the data in the editor.
+     *
+     * ```ts
+     * editor.setData( '<p>This is editor!</p>' );
+     * ```
+     *
+     * If your editor implementation uses multiple roots, you should pass an object with keys corresponding
+     * to the editor root names and values equal to the data that should be set in each root:
+     *
+     * ```ts
+     * editor.setData( {
+     *     header: '<p>Content for header part.</p>',
+     *     content: '<p>Content for main part.</p>',
+     *     footer: '<p>Content for footer part.</p>'
+     * } );
+     * ```
+     *
+     * By default the editor accepts HTML. This can be controlled by injecting a different data processor.
+     * See the {@glink features/markdown Markdown output} guide for more details.
+     *
+     * @param data Input data.
+     */
+    setData(data: string | Record<string, string>): void;
+    /**
+     * Gets the data from the editor.
+     *
+     * ```ts
+     * editor.getData(); // -> '<p>This is editor!</p>'
+     * ```
+     *
+     * If your editor implementation uses multiple roots, you should pass root name as one of the options:
+     *
+     * ```ts
+     * editor.getData( { rootName: 'header' } ); // -> '<p>Content for header part.</p>'
+     * ```
+     *
+     * By default, the editor outputs HTML. This can be controlled by injecting a different data processor.
+     * See the {@glink features/markdown Markdown output} guide for more details.
+     *
+     * A warning is logged when you try to retrieve data for a detached root, as most probably this is a mistake. A detached root should
+     * be treated like it is removed, and you should not save its data. Note, that the detached root data is always an empty string.
+     *
+     * @param options Additional configuration for the retrieved data.
+     * Editor features may introduce more configuration options that can be set through this parameter.
+     * @param options.rootName Root name. Default to `'main'`.
+     * @param options.trim Whether returned data should be trimmed. This option is set to `'empty'` by default,
+     * which means that whenever editor content is considered empty, an empty string is returned. To turn off trimming
+     * use `'none'`. In such cases exact content will be returned (for example `'<p>&nbsp;</p>'` for an empty editor).
+     * @returns Output data.
+     */
+    getData(options?: Record<string, unknown>): string;
+}

package/dist/types/editor/utils/elementapimixin.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @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/editor/utils/elementapimixin
+ */
+import { type Constructor, type Mixed } from '@ckeditor/ckeditor5-utils';
+import type Editor from '../editor.js';
+/**
+ * Implementation of the {@link module:core/editor/utils/elementapimixin~ElementApi}.
+ */
+export default function ElementApiMixin<Base extends Constructor<Editor>>(base: Base): Mixed<Base, ElementApi>;
+/**
+ * Interface describing an editor that replaced a DOM element (was "initialized on an element").
+ *
+ * Such an editor should provide a method to
+ * {@link module:core/editor/utils/elementapimixin~ElementApi#updateSourceElement update the replaced element with the current data}.
+ */
+export interface ElementApi {
+    /**
+     * The element on which the editor has been initialized.
+     *
+     * @readonly
+     */
+    sourceElement: HTMLElement | undefined;
+    /**
+     * Updates the {@link #sourceElement editor source element}'s content with the data if the
+     * {@link module:core/editor/editorconfig~EditorConfig#updateSourceElementOnDestroy `updateSourceElementOnDestroy`}
+     * configuration option is set to `true`.
+     *
+     * @param data Data that the {@link #sourceElement editor source element} should be updated with.
+     */
+    updateSourceElement(data?: string): void;
+}

package/dist/types/editor/utils/securesourceelement.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @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 { default as Editor } from '../editor.js';
+/**
+ * Marks the source element on which the editor was initialized. This prevents other editor instances from using this element.
+ *
+ * Running multiple editor instances on the same source element causes various issues and it is
+ * crucial this helper is called as soon as the source element is known to prevent collisions.
+ *
+ * @param editor Editor instance.
+ * @param sourceElement Element to bind with the editor instance.
+ */
+export default function secureSourceElement(editor: Editor, sourceElement: HTMLElement & {
+    ckeditorInstance?: Editor;
+}): void;

package/dist/types/index.d.ts

@@ -0,0 +1,89 @@
+/**
+ * @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
+ */
+export { default as Plugin, type PluginDependencies, type PluginConstructor } from './plugin.js';
+export { default as Command, type CommandExecuteEvent } from './command.js';
+export { default as MultiCommand } from './multicommand.js';
+export type { CommandsMap } from './commandcollection.js';
+export type { PluginsMap, default as PluginCollection } from './plugincollection.js';
+export { default as Context, type ContextConfig } from './context.js';
+export { default as ContextPlugin, type ContextPluginDependencies } from './contextplugin.js';
+export { type EditingKeystrokeCallback } from './editingkeystrokehandler.js';
+export type { PartialBy } from './typings.js';
+export { default as Editor, type EditorReadyEvent, type EditorDestroyEvent } from './editor/editor.js';
+export type { EditorConfig, LanguageConfig, ToolbarConfig, ToolbarConfigItem, UiConfig } from './editor/editorconfig.js';
+export { default as attachToForm } from './editor/utils/attachtoform.js';
+export { default as DataApiMixin, type DataApi } from './editor/utils/dataapimixin.js';
+export { default as ElementApiMixin, type ElementApi } from './editor/utils/elementapimixin.js';
+export { default as secureSourceElement } from './editor/utils/securesourceelement.js';
+export { default as PendingActions, type PendingAction } from './pendingactions.js';
+export type { KeystrokeInfos as KeystrokeInfoDefinitions, KeystrokeInfoGroup as KeystrokeInfoGroupDefinition, KeystrokeInfoCategory as KeystrokeInfoCategoryDefinition, KeystrokeInfoDefinition as KeystrokeInfoDefinition } from './accessibility.js';
+export declare const icons: {
+    bold: string;
+    cancel: string;
+    caption: string;
+    check: string;
+    cog: string;
+    colorPalette: string;
+    eraser: string;
+    history: string;
+    image: string;
+    imageUpload: string;
+    imageAssetManager: string;
+    imageUrl: string;
+    lowVision: string;
+    textAlternative: string;
+    loupe: string;
+    previousArrow: string;
+    nextArrow: string;
+    importExport: string;
+    paragraph: string;
+    plus: string;
+    text: string;
+    alignBottom: string;
+    alignMiddle: string;
+    alignTop: string;
+    alignLeft: string;
+    alignCenter: string;
+    alignRight: string;
+    alignJustify: string;
+    objectLeft: string;
+    objectCenter: string;
+    objectRight: string;
+    objectFullWidth: string;
+    objectInline: string;
+    objectBlockLeft: string;
+    objectBlockRight: string;
+    objectSizeFull: string;
+    objectSizeLarge: string;
+    objectSizeSmall: string;
+    objectSizeMedium: string;
+    pencil: string;
+    pilcrow: string;
+    quote: string;
+    threeVerticalDots: string;
+    dragIndicator: string;
+    redo: string;
+    undo: string;
+    bulletedList: string;
+    numberedList: string;
+    todoList: string;
+    codeBlock: string;
+    browseFiles: string;
+    heading1: string;
+    heading2: string;
+    heading3: string;
+    heading4: string;
+    heading5: string;
+    heading6: string;
+    horizontalLine: string;
+    html: string;
+    indent: string;
+    outdent: string;
+    table: string;
+};
+import './augmentation.js';

package/dist/types/multicommand.d.ts

@@ -0,0 +1,66 @@
+/**
+ * @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/multicommand
+ */
+import Command from './command.js';
+import { type PriorityString } from '@ckeditor/ckeditor5-utils';
+/**
+ * A CKEditor command that aggregates other commands.
+ *
+ * This command is used to proxy multiple commands. The multi-command is enabled when
+ * at least one of its registered child commands is enabled.
+ * When executing a multi-command, the first enabled command with highest priority will be executed.
+ *
+ * ```ts
+ * const multiCommand = new MultiCommand( editor );
+ *
+ * const commandFoo = new Command( editor );
+ * const commandBar = new Command( editor );
+ *
+ * // Register a child command.
+ * multiCommand.registerChildCommand( commandFoo );
+ * // Register a child command with a low priority.
+ * multiCommand.registerChildCommand( commandBar, { priority: 'low' } );
+ *
+ * // Enable one of the commands.
+ * commandBar.isEnabled = true;
+ *
+ * multiCommand.execute(); // Will execute commandBar.
+ * ```
+ */
+export default class MultiCommand extends Command {
+    /**
+     * Registered child commands definitions.
+     */
+    private _childCommandsDefinitions;
+    /**
+     * @inheritDoc
+     */
+    refresh(): void;
+    /**
+     * Executes the first enabled command which has the highest priority of all registered child commands.
+     *
+     * @returns The value returned by the {@link module:core/command~Command#execute `command.execute()`}.
+     */
+    execute(...args: Array<unknown>): unknown;
+    /**
+     * Registers a child command.
+     *
+     * @param options An object with configuration options.
+     * @param options.priority Priority of a command to register.
+     */
+    registerChildCommand(command: Command, options?: {
+        priority?: PriorityString;
+    }): void;
+    /**
+     * Checks if any of child commands is enabled.
+     */
+    private _checkEnabled;
+    /**
+     * Returns a first enabled command with the highest priority or `undefined` if none of them is enabled.
+     */
+    private _getFirstEnabledCommand;
+}

package/dist/types/pendingactions.d.ts

@@ -0,0 +1,117 @@
+/**
+ * @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/pendingactions
+ */
+import ContextPlugin from './contextplugin.js';
+import { type CollectionAddEvent, type CollectionRemoveEvent, type Observable } from '@ckeditor/ckeditor5-utils';
+/**
+ * The list of pending editor actions.
+ *
+ * This plugin should be used to synchronise plugins that execute long-lasting actions
+ * (e.g. file upload) with the editor integration. It gives the developer who integrates the editor
+ * an easy way to check if there are any actions pending whenever such information is needed.
+ * All plugins that register a pending action also provide a message about the action that is ongoing
+ * which can be displayed to the user. This lets them decide if they want to interrupt the action or wait.
+ *
+ * Adding and updating a pending action:
+ *
+ * ```ts
+ * const pendingActions = editor.plugins.get( 'PendingActions' );
+ * const action = pendingActions.add( 'Upload in progress: 0%.' );
+ *
+ * // You can update the message:
+ * action.message = 'Upload in progress: 10%.';
+ * ```
+ *
+ * Removing a pending action:
+ *
+ * ```ts
+ * const pendingActions = editor.plugins.get( 'PendingActions' );
+ * const action = pendingActions.add( 'Unsaved changes.' );
+ *
+ * pendingActions.remove( action );
+ * ```
+ *
+ * Getting pending actions:
+ *
+ * ```ts
+ * const pendingActions = editor.plugins.get( 'PendingActions' );
+ *
+ * const action1 = pendingActions.add( 'Action 1' );
+ * const action2 = pendingActions.add( 'Action 2' );
+ *
+ * pendingActions.first; // Returns action1
+ * Array.from( pendingActions ); // Returns [ action1, action2 ]
+ * ```
+ *
+ * This plugin is used by features like {@link module:upload/filerepository~FileRepository} to register their ongoing actions
+ * and by features like {@link module:autosave/autosave~Autosave} to detect whether there are any ongoing actions.
+ * Read more about saving the data in the {@glink installation/getting-started/getting-and-setting-data Saving and getting data} guide.
+ */
+export default class PendingActions extends ContextPlugin implements Iterable<PendingAction> {
+    /**
+     * Defines whether there is any registered pending action.
+     *
+     * @readonly
+     * @observable
+     */
+    hasAny: boolean;
+    /**
+     * A list of pending actions.
+     */
+    private _actions;
+    /**
+     * @inheritDoc
+     */
+    static get pluginName(): "PendingActions";
+    /**
+     * @inheritDoc
+     */
+    init(): void;
+    /**
+     * Adds an action to the list of pending actions.
+     *
+     * This method returns an action object with an observable message property.
+     * The action object can be later used in the {@link #remove} method. It also allows you to change the message.
+     *
+     * @param message The action message.
+     * @returns An observable object that represents a pending action.
+     */
+    add(message: string): PendingAction;
+    /**
+     * Removes an action from the list of pending actions.
+     *
+     * @param action An action object.
+     */
+    remove(action: PendingAction): void;
+    /**
+     * Returns the first action from the list or null if the list is empty
+     *
+     * @returns The pending action object.
+     */
+    get first(): PendingAction | null;
+    /**
+     * Iterable interface.
+     */
+    [Symbol.iterator](): Iterator<PendingAction>;
+}
+export interface PendingAction extends Observable {
+    message: string;
+}
+/**
+ * Fired when an action is added to the list.
+ *
+ * @eventName ~PendingActions#add
+ * @param action The added action.
+ */
+export type PendingActionsAddEvent = CollectionAddEvent<PendingAction>;
+/**
+ * Fired when an action is removed from the list.
+ *
+ * @eventName ~PendingActions#remove
+ * @param action The removed action.
+ */
+export type PendingActionsRemoveEvent = CollectionRemoveEvent<PendingAction>;

package/dist/types/plugin.d.ts

@@ -0,0 +1,274 @@
+/**
+ * @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';
+declare const Plugin_base: {
+    new (): import("@ckeditor/ckeditor5-utils").Observable;
+    prototype: import("@ckeditor/ckeditor5-utils").Observable;
+};
+/**
+ * The base class for CKEditor plugin classes.
+ */
+export default class Plugin extends Plugin_base implements PluginInterface {
+    /**
+     * The editor instance.
+     *
+     * Note that most editors implement the {@link module:core/editor/editor~Editor#ui} property.
+     * However, editors with an external UI (i.e. Bootstrap-based) or a headless editor may not have this property or
+     * throw an error when accessing it.
+     *
+     * Because of above, to make plugins more universal, it is recommended to split features into:
+     *  - The "editing" part that uses the {@link module:core/editor/editor~Editor} class without `ui` property.
+     *  - The "UI" part that uses the {@link module:core/editor/editor~Editor} class and accesses `ui` property.
+     */
+    readonly editor: Editor;
+    /**
+     * Flag indicating whether a plugin is enabled or disabled.
+     * A disabled plugin will not transform text.
+     *
+     * Plugin can be simply disabled like that:
+     *
+     * ```ts
+     * // Disable the plugin so that no toolbars are visible.
+     * editor.plugins.get( 'TextTransformation' ).isEnabled = false;
+     * ```
+     *
+     * You can also use {@link #forceDisabled} method.
+     *
+     * @observable
+     * @readonly
+     */
+    isEnabled: boolean;
+    /**
+     * Holds identifiers for {@link #forceDisabled} mechanism.
+     */
+    private _disableStack;
+    /**
+     * @inheritDoc
+     */
+    constructor(editor: Editor);
+    /**
+     * Disables the plugin.
+     *
+     * Plugin may be disabled by multiple features or algorithms (at once). When disabling a plugin, unique id should be passed
+     * (e.g. feature name). The same identifier should be used when {@link #clearForceDisabled enabling back} the plugin.
+     * The plugin becomes enabled only after all features {@link #clearForceDisabled enabled it back}.
+     *
+     * Disabling and enabling a plugin:
+     *
+     * ```ts
+     * plugin.isEnabled; // -> true
+     * plugin.forceDisabled( 'MyFeature' );
+     * plugin.isEnabled; // -> false
+     * plugin.clearForceDisabled( 'MyFeature' );
+     * plugin.isEnabled; // -> true
+     * ```
+     *
+     * Plugin disabled by multiple features:
+     *
+     * ```ts
+     * plugin.forceDisabled( 'MyFeature' );
+     * plugin.forceDisabled( 'OtherFeature' );
+     * plugin.clearForceDisabled( 'MyFeature' );
+     * plugin.isEnabled; // -> false
+     * plugin.clearForceDisabled( 'OtherFeature' );
+     * plugin.isEnabled; // -> true
+     * ```
+     *
+     * Multiple disabling with the same identifier is redundant:
+     *
+     * ```ts
+     * plugin.forceDisabled( 'MyFeature' );
+     * plugin.forceDisabled( 'MyFeature' );
+     * plugin.clearForceDisabled( 'MyFeature' );
+     * plugin.isEnabled; // -> true
+     * ```
+     *
+     * **Note:** some plugins or algorithms may have more complex logic when it comes to enabling or disabling certain plugins,
+     * so the plugin 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 plugin.
+     */
+    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;
+    /**
+     * @inheritDoc
+     */
+    destroy(): void;
+    /**
+     * @inheritDoc
+     */
+    static get isContextPlugin(): false;
+}
+/**
+ * The base interface for CKEditor plugins.
+ *
+ * In its minimal form a plugin can be a simple function that accepts {@link module:core/editor/editor~Editor the editor}
+ * as a parameter:
+ *
+ * ```ts
+ * // A simple plugin that enables a data processor.
+ * function MyPlugin( editor ) {
+ * 	editor.data.processor = new MyDataProcessor();
+ * }
+ * ```
+ *
+ * In most cases however, you will want to inherit from the {@link ~Plugin} class which implements the
+ * {@link module:utils/observablemixin~Observable} and is, therefore, more convenient:
+ *
+ * ```ts
+ * class MyPlugin extends Plugin {
+ * 	init() {
+ * 		// `listenTo()` and `editor` are available thanks to `Plugin`.
+ * 		// By using `listenTo()` you will ensure that the listener is removed when
+ * 		// the plugin is destroyed.
+ * 		this.listenTo( this.editor.data, 'ready', () => {
+ * 			// Do something when the data is ready.
+ * 		} );
+ * 	}
+ * }
+ * ```
+ *
+ * The plugin class can have `pluginName` and `requires` static members. See {@link ~PluginStaticMembers} for more details.
+ *
+ * The plugin can also implement methods (e.g. {@link ~PluginInterface#init `init()`} or
+ * {@link ~PluginInterface#destroy `destroy()`}) which, when present, will be used to properly
+ * initialize and destroy the plugin.
+ *
+ * **Note:** When defined as a plain function, the plugin acts as a constructor and will be
+ * called in parallel with other plugins' {@link ~PluginConstructor constructors}.
+ * This means the code of that plugin will be executed **before** {@link ~PluginInterface#init `init()`} and
+ * {@link ~PluginInterface#afterInit `afterInit()`} methods of other plugins and, for instance,
+ * you cannot use it to extend other plugins' {@glink framework/architecture/editing-engine#schema schema}
+ * rules as they are defined later on during the `init()` stage.
+ */
+export interface PluginInterface {
+    /**
+     * The second stage (after plugin constructor) of the plugin initialization.
+     * Unlike the plugin constructor this method can be asynchronous.
+     *
+     * A plugin's `init()` method is called after its {@link ~PluginStaticMembers#requires dependencies} are initialized,
+     * so in the same order as the constructors of these plugins.
+     *
+     * **Note:** This method is optional. A plugin instance does not need to have it defined.
+     */
+    init?(): Promise<unknown> | null | undefined | void;
+    /**
+     * The third (and last) stage of the plugin initialization. See also {@link ~PluginConstructor} and {@link ~PluginInterface#init}.
+     *
+     * **Note:** This method is optional. A plugin instance does not need to have it defined.
+     */
+    afterInit?(): Promise<unknown> | null | undefined | void;
+    /**
+     * Destroys the plugin.
+     *
+     * **Note:** This method is optional. A plugin instance does not need to have it defined.
+     */
+    destroy?(): Promise<unknown> | null | undefined | void;
+}
+/**
+ * Creates a new plugin instance. This is the first step of the plugin initialization.
+ * See also {@link ~PluginInterface#init} and {@link ~PluginInterface#afterInit}.
+ *
+ * The plugin static properties should conform to {@link ~PluginStaticMembers `PluginStaticMembers` interface}.
+ *
+ * A plugin is always instantiated after its {@link ~PluginStaticMembers#requires dependencies} and the
+ * {@link ~PluginInterface#init} and {@link ~PluginInterface#afterInit} methods are called in the same order.
+ *
+ * Usually, you will want to put your plugin's initialization code in the {@link ~PluginInterface#init} method.
+ * The constructor can be understood as "before init" and used in special cases, just like
+ * {@link ~PluginInterface#afterInit} serves the special "after init" scenarios (e.g.the code which depends on other
+ * plugins, but which does not {@link ~PluginStaticMembers#requires explicitly require} them).
+ */
+export type PluginConstructor<TContext = Editor> = (PluginClassConstructor<TContext> | PluginFunctionConstructor<TContext>) & PluginStaticMembers<TContext>;
+/**
+ * In most cases, you will want to inherit from the {@link ~Plugin} class which implements the
+ * {@link module:utils/observablemixin~Observable} and is, therefore, more convenient:
+ *
+ * ```ts
+ * class MyPlugin extends Plugin {
+ * 	init() {
+ * 		// `listenTo()` and `editor` are available thanks to `Plugin`.
+ * 		// By using `listenTo()` you will ensure that the listener is removed when
+ * 		// the plugin is destroyed.
+ * 		this.listenTo( this.editor.data, 'ready', () => {
+ * 			// Do something when the data is ready.
+ * 		} );
+ * 	}
+ * }
+ * ```
+ */
+export type PluginClassConstructor<TContext = Editor> = new (editor: TContext) => PluginInterface;
+/**
+ * In its minimal form a plugin can be a simple function that accepts {@link module:core/editor/editor~Editor the editor}
+ * as a parameter:
+ *
+ * ```ts
+ * // A simple plugin that enables a data processor.
+ * function MyPlugin( editor ) {
+ * 	editor.data.processor = new MyDataProcessor();
+ * }
+ * ```
+ */
+export type PluginFunctionConstructor<TContext = Editor> = (editor: TContext) => void;
+/**
+ * Static properties of a plugin.
+ */
+export interface PluginStaticMembers<TContext = Editor> {
+    /**
+     * An array of plugins required by this plugin.
+     *
+     * To keep the plugin class definition tight it is recommended to define this property as a static getter:
+     *
+     * ```ts
+     * import Image from './image.js';
+     *
+     * export default class ImageCaption {
+     * 	static get requires() {
+     * 		return [ Image ];
+     * 	}
+     * }
+     * ```
+     */
+    readonly requires?: PluginDependencies<TContext>;
+    /**
+     * An optional name of the plugin. If set, the plugin will be available in
+     * {@link module:core/plugincollection~PluginCollection#get} by its
+     * name and its constructor. If not, then only by its constructor.
+     *
+     * The name should reflect the constructor name.
+     *
+     * To keep the plugin class definition tight, it is recommended to define this property as a static getter:
+     *
+     * ```ts
+     * export default class ImageCaption {
+     * 	static get pluginName() {
+     * 		return 'ImageCaption';
+     * 	}
+     * }
+     * ```
+     *
+     * Note: The native `Function.name` property could not be used to keep the plugin name because
+     * it will be mangled during code minification.
+     *
+     * Naming a plugin is necessary to enable removing it through the
+     * {@link module:core/editor/editorconfig~EditorConfig#removePlugins `config.removePlugins`} option.
+     */
+    readonly pluginName?: string;
+    /**
+     * A flag which defines if a plugin is allowed or not allowed to be used directly by a {@link module:core/context~Context}.
+     */
+    readonly isContextPlugin?: boolean;
+}
+export type PluginDependencies<TContext = Editor> = ReadonlyArray<PluginConstructor<TContext> | string>;
+/**
+ * An array of loaded plugins.
+ */
+export type LoadedPlugins = Array<PluginInterface>;
+export {};