@ckeditor/ckeditor5-ui 41.3.1 → 41.4.0

package/dist/types/editableui/editableuiview.d.ts

@@ -0,0 +1,76 @@
+/**
+ * @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 ui/editableui/editableuiview
+ */
+import View from '../view.js';
+import type { EditingView } from '@ckeditor/ckeditor5-engine';
+import type { Locale } from '@ckeditor/ckeditor5-utils';
+/**
+ * The editable UI view class.
+ */
+export default class EditableUIView extends View {
+    /**
+     * The name of the editable UI view.
+     */
+    name: string | null;
+    /**
+     * Controls whether the editable is focused, i.e. the user is typing in it.
+     *
+     * @observable
+     */
+    isFocused: boolean;
+    /**
+     * The editing view instance the editable is related to. Editable uses the editing
+     * view to dynamically modify its certain DOM attributes after {@link #render rendering}.
+     *
+     * **Note**: The DOM attributes are performed by the editing view and not UI
+     * {@link module:ui/view~View#bindTemplate template bindings} because once rendered,
+     * the editable DOM element must remain under the full control of the engine to work properly.
+     */
+    protected _editingView: EditingView;
+    /**
+     * The element which is the main editable element (usually the one with `contentEditable="true"`).
+     */
+    private _editableElement;
+    /**
+     * Whether an external {@link #_editableElement} was passed into the constructor, which also means
+     * the view will not render its {@link #template}.
+     */
+    private _hasExternalElement;
+    /**
+     * Creates an instance of EditableUIView class.
+     *
+     * @param locale The locale instance.
+     * @param editingView The editing view instance the editable is related to.
+     * @param editableElement The editable element. If not specified, this view
+     * should create it. Otherwise, the existing element should be used.
+     */
+    constructor(locale: Locale, editingView: EditingView, editableElement?: HTMLElement);
+    /**
+     * Renders the view by either applying the {@link #template} to the existing
+     * {@link module:ui/editableui/editableuiview~EditableUIView#_editableElement} or assigning {@link #element}
+     * as {@link module:ui/editableui/editableuiview~EditableUIView#_editableElement}.
+     */
+    render(): void;
+    /**
+     * @inheritDoc
+     */
+    destroy(): void;
+    /**
+     * Whether an external {@link #_editableElement} was passed into the constructor, which also means
+     * the view will not render its {@link #template}.
+     */
+    get hasExternalElement(): boolean;
+    /**
+     * Updates the `ck-focused` and `ck-blurred` CSS classes on the {@link #element} according to
+     * the {@link #isFocused} property value using the {@link #_editingView editing view} API.
+     */
+    private _updateIsFocusedClasses;
+}

package/dist/types/editableui/inline/inlineeditableuiview.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @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 ui/editableui/inline/inlineeditableuiview
+ */
+import EditableUIView from '../editableuiview.js';
+import type { EditingView } from '@ckeditor/ckeditor5-engine';
+import type { Locale } from '@ckeditor/ckeditor5-utils';
+/**
+ * The inline editable UI class implementing an inline {@link module:ui/editableui/editableuiview~EditableUIView}.
+ */
+export default class InlineEditableUIView extends EditableUIView {
+    /**
+     * A function that gets called with the instance of this view as an argument and should return a string that
+     * represents the label of the editable for assistive technologies.
+     */
+    private readonly _generateLabel;
+    /**
+     * Creates an instance of the InlineEditableUIView class.
+     *
+     * @param locale The locale instance.
+     * @param editingView The editing view instance the editable is related to.
+     * @param editableElement The editable element. If not specified, the
+     * {@link module:ui/editableui/editableuiview~EditableUIView}
+     * will create it. Otherwise, the existing element will be used.
+     * @param options Additional configuration of the view.
+     * @param options.label A function that gets called with the instance of this view as an argument
+     * and should return a string that represents the label of the editable for assistive technologies. If not provided,
+     * a default label generator is used.
+     */
+    constructor(locale: Locale, editingView: EditingView, editableElement?: HTMLElement, options?: {
+        label?: (view: InlineEditableUIView) => string;
+    });
+    /**
+     * @inheritDoc
+     */
+    render(): void;
+}

package/dist/types/editorui/accessibilityhelp/accessibilityhelp.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @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 ui/editorui/accessibilityhelp/accessibilityhelp
+ */
+import { Plugin } from '@ckeditor/ckeditor5-core';
+import { Dialog } from '../../index.js';
+import AccessibilityHelpContentView from './accessibilityhelpcontentview.js';
+import '../../../theme/components/editorui/accessibilityhelp.css';
+/**
+ * A plugin that brings the accessibility help dialog to the editor available under the <kbd>Alt</kbd>+<kbd>0</kbd>
+ * keystroke and via the "Accessibility help" toolbar button. The dialog displays a list of keystrokes that can be used
+ * by the user to perform various actions in the editor.
+ *
+ * Keystroke information is loaded from {@link module:core/accessibility~Accessibility#keystrokeInfos}. New entries can be
+ * added using the API provided by the {@link module:core/accessibility~Accessibility} class.
+ */
+export default class AccessibilityHelp extends Plugin {
+    /**
+     * The view that displays the dialog content (list of keystrokes).
+     * Created when the dialog is opened for the first time.
+     */
+    contentView: AccessibilityHelpContentView | null;
+    /**
+     * @inheritDoc
+     */
+    static get requires(): readonly [typeof Dialog];
+    /**
+     * @inheritDoc
+     */
+    static get pluginName(): "AccessibilityHelp";
+    /**
+     * @inheritDoc
+     */
+    init(): void;
+    /**
+     * Creates a button to show accessibility help dialog, for use either in toolbar or in menu bar.
+     */
+    private _createButton;
+    /**
+     * Injects a help text into each editing root's `aria-label` attribute allowing assistive technology users
+     * to discover the availability of the Accessibility help dialog.
+     */
+    private _setupRootLabels;
+    /**
+     * Shows the accessibility help dialog. Also, creates {@link #contentView} on demand.
+     */
+    private _showDialog;
+}

package/dist/types/editorui/accessibilityhelp/accessibilityhelpcontentview.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @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 ui/editorui/accessibilityhelp/accessibilityhelpcontentview
+ */
+import { type Locale } from '@ckeditor/ckeditor5-utils';
+import View from '../../view.js';
+import type { KeystrokeInfoDefinitions } from '@ckeditor/ckeditor5-core';
+/**
+ * The view displaying keystrokes in the Accessibility help dialog.
+ */
+export default class AccessibilityHelpContentView extends View<HTMLDivElement> {
+    /**
+     * @inheritDoc
+     */
+    constructor(locale: Locale, keystrokes: KeystrokeInfoDefinitions);
+    /**
+     * @inheritDoc
+     */
+    focus(): void;
+    /**
+     * Creates `<section><h3>Category label</h3>...</section>` elements for each category of keystrokes.
+     */
+    private _createCategories;
+    /**
+     * Creates `[<h4>Optional label</h4>]<dl>...</dl>` elements for each group of keystrokes in a category.
+     */
+    private _createGroup;
+    /**
+     * Creates `<dt>Keystroke label</dt><dd>Keystroke definition</dd>` elements for each keystroke in a group.
+     */
+    private _createGroupRow;
+}

package/dist/types/editorui/bodycollection.d.ts

@@ -0,0 +1,59 @@
+/**
+ * @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 ViewCollection from '../viewcollection.js';
+import type View from '../view.js';
+import { type Locale } from '@ckeditor/ckeditor5-utils';
+/**
+ * This is a special {@link module:ui/viewcollection~ViewCollection} dedicated to elements that are detached
+ * from the DOM structure of the editor, like panels, icons, etc.
+ *
+ * The body collection is available in the {@link module:ui/editorui/editoruiview~EditorUIView#body `editor.ui.view.body`} property.
+ * Any plugin can add a {@link module:ui/view~View view} to this collection.
+ * These views will render in a container placed directly in the `<body>` element.
+ * The editor will detach and destroy this collection when the editor will be {@link module:core/editor/editor~Editor#destroy destroyed}.
+ *
+ * If you need to control the life cycle of the body collection on your own, you can create your own instance of this class.
+ *
+ * A body collection will render itself automatically in the DOM body element as soon as you call {@link ~BodyCollection#attachToDom}.
+ * If you create multiple body collections, this class will create a special wrapper element in the DOM to limit the number of
+ * elements created directly in the body and remove it when the last body collection will be
+ * {@link ~BodyCollection#detachFromDom detached}.
+ */
+export default class BodyCollection extends ViewCollection {
+    /**
+     * The {@link module:core/editor/editor~Editor#locale editor's locale} instance.
+     * See the view {@link module:ui/view~View#locale locale} property.
+     */
+    readonly locale: Locale;
+    /**
+     * The element holding elements of the body region.
+     */
+    private _bodyCollectionContainer?;
+    /**
+     * Creates a new instance of the {@link module:ui/editorui/bodycollection~BodyCollection}.
+     *
+     * @param locale The {@link module:core/editor/editor~Editor editor's locale} instance.
+     * @param initialItems The initial items of the collection.
+     */
+    constructor(locale: Locale, initialItems?: Iterable<View>);
+    /**
+     * The element holding elements of the body region.
+     */
+    get bodyCollectionContainer(): HTMLElement | undefined;
+    /**
+     * Attaches the body collection to the DOM body element. You need to execute this method to render the content of
+     * the body collection.
+     */
+    attachToDom(): void;
+    /**
+     * Detaches the collection from the DOM structure. Use this method when you do not need to use the body collection
+     * anymore to clean-up the DOM structure.
+     */
+    detachFromDom(): void;
+}

package/dist/types/editorui/boxed/boxededitoruiview.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @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 ui/editorui/boxed/boxededitoruiview
+ */
+import EditorUIView from '../editoruiview.js';
+import type ViewCollection from '../../viewcollection.js';
+import type { Locale } from '@ckeditor/ckeditor5-utils';
+/**
+ * The boxed editor UI view class. This class represents an editor interface
+ * consisting of a toolbar and an editable area, enclosed within a box.
+ */
+export default abstract class BoxedEditorUIView extends EditorUIView {
+    /**
+     * Collection of the child views located in the top (`.ck-editor__top`)
+     * area of the UI.
+     */
+    readonly top: ViewCollection;
+    /**
+     * Collection of the child views located in the main (`.ck-editor__main`)
+     * area of the UI.
+     */
+    readonly main: ViewCollection;
+    /**
+     * Voice label of the UI.
+     */
+    private readonly _voiceLabelView;
+    /**
+     * Creates an instance of the boxed editor UI view class.
+     *
+     * @param locale The locale instance..
+     */
+    constructor(locale: Locale);
+    /**
+     * Creates a voice label view instance.
+     */
+    private _createVoiceLabel;
+}

package/dist/types/editorui/editorui.d.ts

@@ -0,0 +1,292 @@
+/**
+ * @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 ui/editorui/editorui
+ */
+import ComponentFactory from '../componentfactory.js';
+import TooltipManager from '../tooltipmanager.js';
+import PoweredBy from './poweredby.js';
+import AriaLiveAnnouncer from '../arialiveannouncer.js';
+import type EditorUIView from './editoruiview.js';
+import type ToolbarView from '../toolbar/toolbarview.js';
+import { FocusTracker } from '@ckeditor/ckeditor5-utils';
+import type { Editor } from '@ckeditor/ckeditor5-core';
+declare const EditorUI_base: {
+    new (): import("@ckeditor/ckeditor5-utils").Observable;
+    prototype: import("@ckeditor/ckeditor5-utils").Observable;
+};
+/**
+ * A class providing the minimal interface that is required to successfully bootstrap any editor UI.
+ */
+export default abstract class EditorUI extends EditorUI_base {
+    /**
+     * The editor that the UI belongs to.
+     */
+    readonly editor: Editor;
+    /**
+     * An instance of the {@link module:ui/componentfactory~ComponentFactory}, a registry used by plugins
+     * to register factories of specific UI components.
+     */
+    readonly componentFactory: ComponentFactory;
+    /**
+     * Stores the information about the editor UI focus and propagates it so various plugins and components
+     * are unified as a focus group.
+     */
+    readonly focusTracker: FocusTracker;
+    /**
+     * Manages the tooltips displayed on mouseover and focus across the UI.
+     */
+    readonly tooltipManager: TooltipManager;
+    /**
+     * A helper that enables the "powered by" feature in the editor and renders a link to the project's webpage.
+     */
+    readonly poweredBy: PoweredBy;
+    /**
+     * A helper that manages the content of an `aria-live` regions used by editor features to announce status changes
+     * to screen readers.
+     */
+    readonly ariaLiveAnnouncer: AriaLiveAnnouncer;
+    /**
+     * Indicates the UI is ready. Set `true` after {@link #event:ready} event is fired.
+     *
+     * @readonly
+     * @default false
+     */
+    isReady: boolean;
+    abstract get view(): EditorUIView;
+    /**
+     * Stores viewport offsets from every direction.
+     *
+     * Viewport offset can be used to constrain balloons or other UI elements into an element smaller than the viewport.
+     * This can be useful if there are any other absolutely positioned elements that may interfere with editor UI.
+     *
+     * Example `editor.ui.viewportOffset` returns:
+     *
+     * ```js
+     * {
+     * 	top: 50,
+     * 	right: 50,
+     * 	bottom: 50,
+     * 	left: 50
+     * }
+     * ```
+     *
+     * This property can be overriden after editor already being initialized:
+     *
+     * ```js
+     * editor.ui.viewportOffset = {
+     * 	top: 100,
+     * 	right: 0,
+     * 	bottom: 0,
+     * 	left: 0
+     * };
+     * ```
+     *
+     * @observable
+     */
+    viewportOffset: {
+        left?: number;
+        right?: number;
+        top?: number;
+        bottom?: number;
+    };
+    /**
+     * Stores all editable elements used by the editor instance.
+     */
+    private _editableElementsMap;
+    /**
+     * All available & focusable toolbars.
+     */
+    private _focusableToolbarDefinitions;
+    /**
+     * Creates an instance of the editor UI class.
+     *
+     * @param editor The editor instance.
+     */
+    constructor(editor: Editor);
+    /**
+     * The main (outermost) DOM element of the editor UI.
+     *
+     * For example, in {@link module:editor-classic/classiceditor~ClassicEditor} it is a `<div>` which
+     * wraps the editable element and the toolbar. In {@link module:editor-inline/inlineeditor~InlineEditor}
+     * it is the editable element itself (as there is no other wrapper). However, in
+     * {@link module:editor-decoupled/decouplededitor~DecoupledEditor} it is set to `null` because this editor does not
+     * come with a single "main" HTML element (its editable element and toolbar are separate).
+     *
+     * This property can be understood as a shorthand for retrieving the element that a specific editor integration
+     * considers to be its main DOM element.
+     */
+    get element(): HTMLElement | null;
+    /**
+     * Fires the {@link module:ui/editorui/editorui~EditorUI#event:update `update`} event.
+     *
+     * This method should be called when the editor UI (e.g. positions of its balloons) needs to be updated due to
+     * some environmental change which CKEditor 5 is not aware of (e.g. resize of a container in which it is used).
+     */
+    update(): void;
+    /**
+     * Destroys the UI.
+     */
+    destroy(): void;
+    /**
+     * Stores the native DOM editable element used by the editor under a unique name.
+     *
+     * Also, registers the element in the editor to maintain the accessibility of the UI. When the user is editing text in a focusable
+     * editable area, they can use the <kbd>Alt</kbd> + <kbd>F10</kbd> keystroke to navigate over editor toolbars. See {@link #addToolbar}.
+     *
+     * @param rootName The unique name of the editable element.
+     * @param domElement The native DOM editable element.
+     */
+    setEditableElement(rootName: string, domElement: HTMLElement): void;
+    /**
+     * Removes the editable from the editor UI. Removes all handlers added by {@link #setEditableElement}.
+     *
+     * @param rootName The name of the editable element to remove.
+     */
+    removeEditableElement(rootName: string): void;
+    /**
+     * Returns the editable editor element with the given name or null if editable does not exist.
+     *
+     * @param rootName The editable name.
+     */
+    getEditableElement(rootName?: string): HTMLElement | undefined;
+    /**
+     * Returns array of names of all editor editable elements.
+     */
+    getEditableElementsNames(): IterableIterator<string>;
+    /**
+     * Adds a toolbar to the editor UI. Used primarily to maintain the accessibility of the UI.
+     *
+     * Focusable toolbars can be accessed (focused) by users by pressing the <kbd>Alt</kbd> + <kbd>F10</kbd> keystroke.
+     * Successive keystroke presses navigate over available toolbars.
+     *
+     * @param toolbarView A instance of the toolbar to be registered.
+     */
+    addToolbar(toolbarView: ToolbarView, options?: FocusableToolbarOptions): void;
+    /**
+     * Stores all editable elements used by the editor instance.
+     *
+     * @deprecated
+     */
+    protected get _editableElements(): unknown;
+    /**
+     * Returns viewport offsets object:
+     *
+     * ```js
+     * {
+     * 	top: Number,
+     * 	right: Number,
+     * 	bottom: Number,
+     * 	left: Number
+     * }
+     * ```
+     *
+     * Only top property is currently supported.
+     */
+    private _readViewportOffsetFromConfig;
+    /**
+     * Starts listening for <kbd>Alt</kbd> + <kbd>F10</kbd> and <kbd>Esc</kbd> keystrokes in the context of focusable
+     * {@link #setEditableElement editable elements} and {@link #addToolbar toolbars}
+     * to allow users navigate across the UI.
+     */
+    private _initFocusTracking;
+    /**
+     * Returns definitions of toolbars that could potentially be focused, sorted by their importance for the user.
+     *
+     * Focusable toolbars candidates are either:
+     * * already visible,
+     * * have `beforeFocus()` set in their {@link module:ui/editorui/editorui~FocusableToolbarDefinition definition} that suggests that
+     * they might show up when called. Keep in mind that determining whether a toolbar will show up (and become focusable) is impossible
+     * at this stage because it depends on its implementation, that in turn depends on the editing context (selection).
+     *
+     * **Note**: Contextual toolbars take precedence over regular toolbars.
+     */
+    private _getFocusableCandidateToolbarDefinitions;
+    /**
+     * Returns a definition of the toolbar that is currently visible and focused (one of its children has focus).
+     *
+     * `null` is returned when no toolbar is currently focused.
+     */
+    private _getCurrentFocusedToolbarDefinition;
+    /**
+     * Focuses a focusable toolbar candidate using its definition.
+     *
+     * @param candidateToolbarDefinition A definition of the toolbar to focus.
+     * @returns `true` when the toolbar candidate was focused. `false` otherwise.
+     */
+    private _focusFocusableCandidateToolbar;
+    /**
+     * Provides an integration between {@link #viewportOffset} and {@link module:utils/dom/scroll~scrollViewportToShowTarget}.
+     * It allows the UI-agnostic engine method to consider user-configured viewport offsets specific for the integration.
+     *
+     * @param evt The `scrollToTheSelection` event info.
+     * @param data The payload carried by the `scrollToTheSelection` event.
+     */
+    private _handleScrollToTheSelection;
+}
+/**
+ * Fired when the editor UI is ready.
+ *
+ * Fired before {@link module:engine/controller/datacontroller~DataController#event:ready}.
+ *
+ * @eventName ~EditorUI#ready
+ */
+export type EditorUIReadyEvent = {
+    name: 'ready';
+    args: [];
+};
+/**
+ * Fired whenever the UI (all related components) should be refreshed.
+ *
+ * **Note:**: The event is fired after each {@link module:engine/view/document~Document#event:layoutChanged}.
+ * It can also be fired manually via the {@link module:ui/editorui/editorui~EditorUI#update} method.
+ *
+ * @eventName ~EditorUI#update
+ */
+export type EditorUIUpdateEvent = {
+    name: 'update';
+    args: [];
+};
+/**
+ * A definition of a focusable toolbar. Used by {@link module:ui/editorui/editorui~EditorUI#addToolbar}.
+ */
+export interface FocusableToolbarDefinition {
+    /**
+     * An instance of a focusable toolbar view.
+     */
+    toolbarView: ToolbarView;
+    /**
+     * Options of a focusable toolbar view:
+     *
+     * * `isContextual`: Marks the higher priority toolbar. For example when there are 2 visible toolbars,
+     * it allows to distinguish which toolbar should be focused first after the `alt+f10` keystroke
+     * * `beforeFocus`: A callback executed before the `ToolbarView` gains focus upon the `Alt+F10` keystroke.
+     * * `afterBlur`: A callback executed after `ToolbarView` loses focus upon `Esc` keystroke but before
+     * the focus goes back to the `origin`.
+     */
+    options: FocusableToolbarOptions;
+}
+export interface FocusableToolbarOptions {
+    /**
+     * Set `true` if the toolbar is attached to the content of the editor. Such toolbar takes
+     * a precedence over other toolbars when a user pressed <kbd>Alt</kbd> + <kbd>F10</kbd>.
+     */
+    isContextual?: boolean;
+    /**
+     * Specify a callback executed before the toolbar instance DOM element gains focus
+     * upon the <kbd>Alt</kbd> + <kbd>F10</kbd> keystroke.
+     */
+    beforeFocus?: () => void;
+    /**
+     * Specify a callback executed after the toolbar instance DOM element loses focus upon
+     * <kbd>Esc</kbd> keystroke but before the focus goes back to the {@link ~EditorUI#setEditableElement editable element}.
+     */
+    afterBlur?: () => void;
+}
+export {};

package/dist/types/editorui/editoruiview.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @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 ui/editorui/editoruiview
+ */
+import View from '../view.js';
+import BodyCollection from './bodycollection.js';
+import type EditableUIView from '../editableui/editableuiview.js';
+import type { Locale, LocaleTranslate } from '@ckeditor/ckeditor5-utils';
+import '../../theme/components/editorui/editorui.css';
+/**
+ * The editor UI view class. Base class for the editor main views.
+ */
+export default abstract class EditorUIView extends View {
+    /**
+     * Collection of the child views, detached from the DOM
+     * structure of the editor, like panels, icons etc.
+     */
+    readonly body: BodyCollection;
+    locale: Locale;
+    t: LocaleTranslate;
+    abstract get editable(): EditableUIView;
+    /**
+     * Creates an instance of the editor UI view class.
+     *
+     * @param locale The locale instance.
+     */
+    constructor(locale: Locale);
+    /**
+     * @inheritDoc
+     */
+    render(): void;
+    /**
+     * @inheritDoc
+     */
+    destroy(): void;
+}