@ckeditor/ckeditor5-ai 48.8.1-alpha.4 → 49.0.0-alpha.0

package/dist/aisdk/documentcompare.d.ts

@@ -0,0 +1,171 @@
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+/**
+* @module ai/aisdk/documentcompare
+* @publicApi
+*/
+import { Plugin, type PluginDependenciesOf } from "@ckeditor/ckeditor5-core";
+import { type Operation, type ModelRange } from "@ckeditor/ckeditor5-engine";
+import { DocumentChanges } from "./documentchanges.js";
+import { DocumentCompareUtils } from "./documentcompareutils.js";
+import { type DocumentCompareSnapshot } from "./documentsnapshot.js";
+/**
+* `DocumentCompare` provides a set of tools that allows you to process editor document data by custom external logic,
+* evaluate the differences between original and processed data, and apply them as granular changes or tracked
+* suggestions.
+*
+* Contrary to `editor.setData()`, this does not replace the whole editor
+* data. Instead, atomic changes are evaluated and a small set of changes is applied to the document. This is especially
+* useful when the editor also uses Track Changes, Revision History, and Real-Time Collaboration features.
+*
+* Use {@link #process `process()`}, to run the whole pipeline in one call - it takes document snapshot, processes the data,
+* and applies granular changes:
+*
+* ```ts
+* await documentCompare.process( async snapshot => callMyService( snapshot.content ) );
+*
+* // Or, to apply changes as suggestions:
+* await documentCompare.process( async snapshot => callMyService( snapshot.content ), { asSuggestions: true } );
+* ```
+*
+* Some integrations need to process the data in separate steps (e.g. backend processing, or when changes
+* are not applied immediately to the content). In this case, you can capture a snapshot first and apply the result later:
+*
+* ```ts
+* const snapshot = documentCompare.makeSnapshot();
+* const processed = await callMyService( snapshot.content );
+*
+* // ...
+*
+* const patch = documentCompare.diffSnapshot( snapshot, processed, { asSuggestions: true } );
+* documentCompare.applyPatch( patch );
+* ```
+*/
+export declare class DocumentCompare extends Plugin {
+	static get pluginName(): "DocumentCompare";
+	static get requires(): PluginDependenciesOf<[DocumentChanges, DocumentCompareUtils]>;
+	static override get isOfficialPlugin(): true;
+	static override get isPremiumPlugin(): true;
+	init(): void;
+	afterInit(): void;
+	/**
+	* Captures the current document state as a {@link module:ai/aisdk/documentsnapshot~DocumentCompareSnapshot}.
+	*
+	* The snapshot contains all data and metadata necessary to process the data and then be able to calculate differences between
+	* the original data and the processed data.
+	*
+	* Importantly, `snapshot.content` holds data for each root (excluding `$graveyard`) serialized to HTML. The data is stamped with
+	* `data-id` attributes, assigned to structural elements of the data. During processing, make sure that these `data-id`s are retained.
+	*
+	* See also {@link module:ai/aisdk/documentsnapshot~DocumentCompareSnapshot}.
+	*
+	* @param selection Ranges to capture with the snapshot as the user's selection. Must not intersect. By default no
+	* selection is captured.
+	* @returns The captured snapshot.
+	*/
+	makeSnapshot(selection?: Iterable<ModelRange>): DocumentCompareSnapshot;
+	/**
+	* Diffs the snapshot against processed data, returning a document patch - a set of granular differences between the two states.
+	*
+	* Use `options` to set whether the patch should be calculated and applied as tracked changes or as direct changes to the document.
+	*
+	* You can apply the patch using {@link #applyPatch}.
+	*
+	* @param snapshot The captured before-state to diff against.
+	* @param data The processed data. For multi-root editor, pass an object keyed by root name.
+	* @param options How the comparison is computed.
+	* @returns The patch bringing the document from the snapshot to the processed state.
+	*/
+	diffSnapshot(snapshot: DocumentCompareSnapshot, data: string | Record<string, string>, options?: DocumentCompareDiffOptions): DocumentComparePatch;
+	/**
+	* Applies a patch to the current state of the document.
+	*
+	* As a result, all changes described by the patch are reflected in the document. Note, that this converges with all
+	* changes that happened on the document after the snapshot was made, including both local and remote edits
+	* (if real-time collaboration is enabled).
+	*
+	* Note, that the patch can be only applied to the same document as the snapshot, and only during the same editing session.
+	* Otherwise, `documentcompare-apply-session-mismatch` error is thrown.
+	*
+	* The patch is first validated against a copy of the document before anything is committed.
+	* In case if any errors or conflict resolution problems surface during this dry-run, `documentcompare-invalid-patch`
+	* error is thrown, and the editor data is left intact.
+	*
+	* The changes can be applied directly to the content or as tracked suggestions (requires
+	* {@link module:track-changes/trackchanges~TrackChanges Track changes plugin}). See also {@link #diffSnapshot}.
+	*
+	* @param patch The patch to apply, as produced by {@link #diffSnapshot}.
+	*/
+	applyPatch(patch: DocumentComparePatch): void;
+	/**
+	* Runs the whole processing pipeline in one call: snapshots the document, hands the snapshot to `callback` for
+	* external processing (e.g. an AI service), then diffs returned data and applies granular changes to the document.
+	*
+	* If diffing or applying fails, the underlying error is rethrown and can be further handled,
+	* unless `options.overwriteOnError` is set, in which case the current document is instead
+	* fully replaced with the processed data, the same way as if `editor.setData()` was used.
+	* In this case, changes that happened to the document after the snapshot was taken will be overwritten.
+	*
+	* @param callback Receives the captured snapshot and returns the processed data keyed by root name.
+	* @param options Additional processing options.
+	* @returns `true` when the process finished successfully and changes were applied granularly,
+	* `false` when the full-replacement fallback was used.
+	*/
+	process(callback: (snapshot: DocumentCompareSnapshot) => Promise<string | Record<string, string>>, options?: DocumentCompareProcessOptions): Promise<boolean>;
+}
+/**
+* Describes how a comparison is computed and, once recorded on a {@link ~DocumentComparePatch patch}, how it is applied.
+*/
+export interface DocumentCompareDiffOptions {
+	/**
+	* Whether the operations carry track-changes suggestion markers.
+	*/
+	asSuggestions?: boolean;
+}
+/**
+* Options for {@link module:ai/aisdk/documentcompare~DocumentCompare#process}.
+*/
+export interface DocumentCompareProcessOptions extends DocumentCompareDiffOptions {
+	/**
+	* What to do when the processing fails.
+	*
+	* By default, the underlying error is rethrown.
+	*
+	* When the options is set to `true`, the whole document is instead overwritten with the processed data
+	* via `editor.setData()` and {@link module:ai/aisdk/documentcompare~DocumentCompare#process} returns `false`.
+	*
+	* Note, that the overwrite is also performed in real-time collaboration environment, and it may roll back some edits made by remote
+	* users while `callback` was processing. Opt in only when overwriting the whole document is acceptable.
+	*/
+	overwriteOnError?: boolean;
+}
+/**
+* The result of comparing a snapshot against processed data: the operations to bring the document to the new state,
+* together with the snapshot metadata.
+*
+* Can be applied via {@link module:ai/aisdk/documentcompare~DocumentCompare#applyPatch}.
+*/
+export interface DocumentComparePatch {
+	/**
+	* The channel of the document the snapshot was captured from, validated on apply.
+	*/
+	channelId: string;
+	/**
+	* The editing session the snapshot was captured in, validated on apply.
+	*/
+	sessionId: string;
+	/**
+	* The snapshot version the operations are anchored to (used to reconcile them on apply).
+	*/
+	version: number;
+	/**
+	* The options the patch was computed with, reused when applying it.
+	*/
+	options: DocumentCompareDiffOptions;
+	/**
+	* The operations to apply, keyed by root name (a root with no changes maps to an empty array).
+	*/
+	operations: Record<string, Array<Operation>>;
+}

package/dist/aisdk/documentcompareutils.d.ts

@@ -0,0 +1,16 @@
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+/**
+* @module ai/aisdk/documentcompareutils
+* @publicApi
+*/
+import { Plugin } from "@ckeditor/ckeditor5-core";
+export declare class DocumentCompareUtils extends Plugin {
+	static get pluginName(): "DocumentCompareUtils";
+	static override get isOfficialPlugin(): true;
+	static override get isPremiumPlugin(): true;
+	init(): void;
+	override destroy(): void;
+}

package/dist/aisdk/documentsnapshot.d.ts

@@ -0,0 +1,48 @@
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+/**
+* @module ai/aisdk/documentsnapshot
+* @publicApi
+*/
+import { type AIEditorConfig } from "../aicore/utils/geteditorconfig.js";
+/**
+* A captured selection range as character offsets into its root's serialized HTML.
+*/
+export interface DocumentCompareSnapshotRange {
+	start: number;
+	end: number;
+}
+/**
+* The captured before-state of a document plus the metadata to reconcile changes later.
+* The snapshot is a plain object and is safe to `JSON.stringify`, send between the frontend and backend, store, parse,
+* and later feed back into `DocumentCompare#diffSnapshot`.
+*/
+export interface DocumentCompareSnapshot {
+	/**
+	* The collaboration channel the snapshot was captured from.
+	*/
+	channelId: string;
+	/**
+	* The editing session the snapshot was captured in.
+	*/
+	sessionId: string;
+	/**
+	* The document version the snapshot was captured at.
+	*/
+	version: number;
+	/**
+	* Each root's content, serialized to HTML, keyed by root name (excluding `$graveyard`).
+	*/
+	content: Record<string, string>;
+	/**
+	* Each root's captured selection as character offsets into its HTML, keyed by root name (omitted if root has no selection).
+	*/
+	selection: Record<string, Array<DocumentCompareSnapshotRange>>;
+	/**
+	* The editor's feature configuration at capture time, so external processing can interpret the serialized HTML
+	* within the editor's capabilities.
+	*/
+	editorConfig: AIEditorConfig;
+}

package/dist/aisdk/extractselectionfromhtml.d.ts

@@ -0,0 +1,27 @@
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+/**
+* @module ai/aisdk/extractselectionfromhtml
+*/
+import { type DocumentCompareSnapshotRange } from "./documentsnapshot.js";
+/**
+* The marker group used to render a captured selection into serialized HTML. Each range is added as
+* `documentcompare-selection:<i>` and downcast (opt-in via the `includeDocumentCompareSelection` option) to the
+* boundary elements below.
+*/
+export declare const SELECTION_MARKER = "documentcompare-selection";
+/** The boundary element names the selection markers downcast to. */
+export declare const SELECTION_START = "documentcompare-selection-start";
+export declare const SELECTION_END = "documentcompare-selection-end";
+/**
+* Strips the selection boundary elements from HTML serialized with the `includeDocumentCompareSelection` option.
+*
+* @param html HTML serialized with the selection boundary elements included.
+* @returns The clean HTML together with the selection as character offsets into it.
+*/
+export declare function extractSelectionFromHtml(html: string): {
+	content: string;
+	selection: Array<DocumentCompareSnapshotRange>;
+};

package/dist/aisdk/validateoperations.d.ts

@@ -0,0 +1,43 @@
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+/**
+* @module ai/aisdk/validateoperations
+*/
+import { type Editor } from "@ckeditor/ckeditor5-core";
+import { type Operation } from "@ckeditor/ckeditor5-engine";
+/**
+* A failure found by {@link ~validateOperations} while trial-applying a patch's operations.
+*/
+export interface OperationValidationFailure {
+	/**
+	* What kind of failure occurred: `'unsupported'` for an operation the `DocumentCompare` API does not support,
+	* `'invalid'` for one that failed to trial-apply against a copy of the current document.
+	*/
+	reason: string;
+	/**
+	* The operation that failed.
+	*/
+	operation: Operation;
+	/**
+	* The underlying error thrown while trial-applying the operation, set when `reason` is `'invalid'`.
+	*/
+	cause?: Error;
+}
+/**
+* Trial-applies `operations` on temporary copies of the document's roots, to confirm they apply cleanly before they are
+* applied for real, so an unapplicable set is caught up front instead of failing mid-way, leaving the document corrupt.
+*
+* Each root (plus the graveyard, for remove/merge targets) is deep-cloned into a detached
+* {@link module:engine/model/documentfragment~ModelDocumentFragment}, and every operation is cloned and re-rooted onto
+* those copies and trial-applied there — `_validate()` then `_execute()`, as the real apply runs them. Marker
+* operations are skipped: they cannot fail structurally, so there is nothing to validate. Nothing is applied to the
+* live document.
+*
+* The function does not throw errors itself, instead it returns the first failure it finds (or `null` when the
+* operations all apply cleanly), and leaves it to the caller to throw the appropriate error.
+*
+* @returns The first operation failure, or `null` when all operations apply cleanly.
+*/
+export declare function validateOperations(editor: Editor, operations: Array<Operation>): OperationValidationFailure | null;

package/dist/aitabs/aitabs.d.ts

@@ -1,95 +1,115 @@
 /**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
 /**
- * @module ai/aitabs/aitabs
- * @publicApi
- */
-import { type Context, ContextPlugin, Editor } from '@ckeditor/ckeditor5-core';
-import { AITabsMainView } from './aitabsmainview.js';
-import type { AIContainerSide, AIContainerType } from '../aiconfig.js';
+* @module ai/aitabs/aitabs
+* @publicApi
+*/
+import { type Context, ContextPlugin, Editor } from "@ckeditor/ckeditor5-core";
+import { type BodyCollection } from "@ckeditor/ckeditor5-ui";
+import { AITabsMainView } from "./aitabsmainview.js";
+import type { AIContainerSide, AIContainerType } from "../aiconfig.js";
 /**
- * The AI Tabs plugin. It delivers the tabs view that hosts AI-powered features in the editor
- * such as {@link module:ai/aichat/aichat~AIChat AI Chat}, {@link module:ai/aiquickactions/aiquickactions~AIQuickActions AI Quick Actions},
- * and {@link module:ai/aireviewmode/aireviewmode~AIReviewMode AI Review Mode}.
- *
- * The feature is configured via the {@link module:ai/aiconfig~AIConfig#container `config.ai.container`} property.
- *
- * Learn more about AI features in CKEditor in the {@glink features/ai/ckeditor-ai-overview AI Overview} documentation.
- *
- * @experimental **Experimental:** This is a production-ready API but may change in minor releases
- * without the standard deprecation policy. Check the changelog for migration guidance.
- */
+* The AI Tabs plugin. It delivers the tabs view that hosts AI-powered features in the editor
+* such as {@link module:ai/aichat/aichat~AIChat AI Chat}, {@link module:ai/aiquickactions/aiquickactions~AIQuickActions AI Quick Actions},
+* and {@link module:ai/aireviewmode/aireviewmode~AIReviewMode AI Review Mode}.
+*
+* The feature is configured via the {@link module:ai/aiconfig~AIConfig#container `config.ai.container`} property.
+*
+* Learn more about AI features in CKEditor in the {@glink features/ai/ckeditor-ai-overview AI Overview} documentation.
+*
+* @experimental **Experimental:** This is a production-ready API but may change in minor releases
+* without the standard deprecation policy. Check the changelog for migration guidance.
+*/
 export declare class AITabs extends ContextPlugin {
-    /**
-     * The view that allows for hosting AI-powered features in the editor.
-     */
-    view: AITabsMainView;
-    /**
-     * The container of the AI Tabs view.
-     */
-    container: HTMLElement | null;
-    /**
-     * Indicates whether the resize button should be displayed.
-     */
-    showResizeButton: boolean;
-    /**
-     * The type of the AI Tabs view as configured in {@link module:ai/aiconfig~AIConfig#container}
-     *
-     * See {@link #switchType} to learn how to switch between the UI types.
-     */
-    type: AIContainerType;
-    /**
-     * The position of the AI Tabs view.
-     *
-     * @default 'right'
-     */
-    side: AIContainerSide;
-    /**
-     * @inheritDoc
-     */
-    static get pluginName(): "AITabs";
-    /**
-     * @inheritDoc
-     */
-    static get isOfficialPlugin(): true;
-    /**
-     * @inheritDoc
-     */
-    static get isPremiumPlugin(): true;
-    /**
-     * @inheritDoc
-     */
-    constructor(context: Context | Editor);
-    /**
-     * Switches between the UI type of the tabs.
-     *
-     * See {@link module:ai/aiconfig~AIConfig#container} to learn more about possible types.
-     */
-    switchType(type: AIContainerType): void;
-    /**
-     * Switches between the side of the AI Tabs view.
-     *
-     * See {@link module:ai/aiconfig~AIConfig#container} to learn more about possible sides.
-     */
-    switchSide(side: AIContainerSide): void;
-    /**
-     * @inheritDoc
-     */
-    destroy(): void;
+	/**
+	* The view that allows for hosting AI-powered features in the editor.
+	*/
+	view: AITabsMainView;
+	/**
+	* The body collection holding the floating UI of the AI features – their balloons, dialogs and the
+	* tooltips inside them.
+	*
+	* Every AI feature that renders floating UI adds its views here instead of mounting a body collection of
+	* its own. A collection of their own would go into `document.body`, which is outside whatever shadow root
+	* the AI UI lives in: the views would render unstyled, and their tooltips would be hosted in an unrelated
+	* tree.
+	*/
+	get bodyCollection(): BodyCollection;
+	/**
+	* The container the AI Tabs view is mounted in.
+	*
+	* Observable, and the single source of truth for where the tabs are: setting it moves the view into the new
+	* container and re-mounts the floating UI of every AI feature in the DOM tree that container lives in.
+	*
+	* The `'custom'` type moves nothing – there the integrator places the tab buttons and panels themselves –
+	* so set it to the container they were placed in, which tells the floating UI which tree to join. Left
+	* unset, that UI falls back to `document.body`: right in the light DOM, but unstyled inside a shadow root.
+	*
+	* It may be a shadow root, which is what the `'overlay'` type resolves to when the editors live in one.
+	*/
+	container: HTMLElement | ShadowRoot | null;
+	/**
+	* Indicates whether the resize button should be displayed.
+	*/
+	showResizeButton: boolean;
+	/**
+	* The type of the AI Tabs view as configured in {@link module:ai/aiconfig~AIConfig#container}
+	*
+	* See {@link #switchType} to learn how to switch between the UI types.
+	*/
+	type: AIContainerType;
+	/**
+	* The position of the AI Tabs view.
+	*
+	* @default 'right'
+	*/
+	side: AIContainerSide;
+	/**
+	* @inheritDoc
+	*/
+	static get pluginName(): "AITabs";
+	/**
+	* @inheritDoc
+	*/
+	static override get isOfficialPlugin(): true;
+	/**
+	* @inheritDoc
+	*/
+	static override get isPremiumPlugin(): true;
+	/**
+	* @inheritDoc
+	*/
+	constructor(context: Context | Editor);
+	/**
+	* Switches between the UI type of the tabs.
+	*
+	* See {@link module:ai/aiconfig~AIConfig#container} to learn more about possible types.
+	*/
+	switchType(type: AIContainerType): void;
+	/**
+	* Switches between the side of the AI Tabs view.
+	*
+	* See {@link module:ai/aiconfig~AIConfig#container} to learn more about possible sides.
+	*/
+	switchSide(side: AIContainerSide): void;
+	/**
+	* @inheritDoc
+	*/
+	override destroy(): void;
 }
 /**
- * An event fired when the user wants to toggle the chat resizing.
- */
+* An event fired when the user wants to toggle the chat resizing.
+*/
 export type AIResizedTabsEvent = {
-    name: 'resizedTabs';
-    args: [isMaximized: boolean];
+	name: "resizedTabs";
+	args: [isMaximized: boolean];
 };
 /**
- * An event fired when the user wants to resize the chat.
- */
+* An event fired when the user wants to resize the chat.
+*/
 export type AIResizeTabsEvent = {
-    name: 'resizeTabs';
-    args: [];
+	name: "resizeTabs";
+	args: [];
 };

package/dist/aitabs/aitabsmainview.d.ts

@@ -1,58 +1,82 @@
 /**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
 /**
- * @module ai/aitabs/aitabsmainview
- * @publicApi
- */
-import type { Locale } from '@ckeditor/ckeditor5-utils';
-import { AITabsView, type AITabsViewOptions } from './tabs/aitabsview.js';
-import '../../theme/aitabs/aitabsview.css';
+* @module ai/aitabs/aitabsmainview
+* @publicApi
+*/
+import { type Locale } from "@ckeditor/ckeditor5-utils";
+import { AITabsView, type AITabsViewOptions } from "./tabs/aitabsview.js";
 /**
- * The supported types of the `AITabsView`.
- */
+* The supported types of the `AITabsView`.
+*/
 export declare const AI_TABS_VIEW_TYPES: readonly ["overlay", "sidebar", "custom"];
 /**
- * The supported sides of the `AITabsView`.
- */
+* The supported sides of the `AITabsView`.
+*/
 export declare const AI_TABS_VIEW_SIDES: readonly ["left", "right"];
 /**
- * The view that hosts AI-powered features in the editor.
- *
- * @experimental **Experimental:** This is a production-ready API but may change in minor releases
- * without the standard deprecation policy. Check the changelog for migration guidance.
- */
+* The view that hosts AI-powered features in the editor.
+*
+* @experimental **Experimental:** This is a production-ready API but may change in minor releases
+* without the standard deprecation policy. Check the changelog for migration guidance.
+*/
 export declare class AITabsMainView extends AITabsView {
-    /**
-     * The type of the view.
-     */
-    type: AITabsMainViewOptions['type'];
-    /**
-     * Whether the AI tabs view is visible.
-     *
-     * @observable
-     */
-    isVisible: boolean;
-    /**
-     * @inheritDoc
-     */
-    constructor(locale: Locale, options?: AITabsMainViewOptions);
+	/**
+	* The type of the view.
+	*/
+	type: AITabsMainViewOptions["type"];
+	/**
+	* Whether the AI tabs view is visible.
+	*
+	* @observable
+	*/
+	isVisible: boolean;
+	/**
+	* @inheritDoc
+	*/
+	constructor(locale: Locale, options?: AITabsMainViewOptions);
+	/**
+	* Activates a tab by its ID.
+	*
+	* Note: Use {@link #getTabIds} to learn how to get the IDs of all tabs.
+	*
+	* Note: If `null` is passed, the current active tab will be deactivated and its panel will be hidden.
+	*
+	* The call may be vetoed by a listener (for example a feature warning about unresolved changes before
+	* switching away), in which case this method is a no-op and returns `false`. Use
+	* `forceActivateTab()` to switch tabs unconditionally, bypassing any such veto, or
+	* `activateTabAwaitingConfirmation()` for callers that want to wait for the user's answer instead of
+	* treating a veto as a hard failure.
+	*
+	* `AITabsView#activateTab()` mutates state and only notifies listeners *after* the fact (via its own
+	* internal `activateTab:${id}` event), so it cannot be safely wrapped with `this.decorate()` — the
+	* decorated proxy would be re-entered by that internal event under the same base event name. Overriding
+	* the method to fire a distinctly-named event first, before delegating to `super.activateTab()`, gives
+	* listeners a genuine pre-mutation veto point instead.
+	*
+	* @experimental **Experimental:** This is a production-ready API but may change in minor releases
+	* without the standard deprecation policy. Check the changelog for migration guidance.
+	*
+	* @returns `true` if the tab was actually activated, `false` if a listener vetoed the switch.
+	*/
+	override activateTab(id: string | null): boolean;
 }
 /**
- * The options for the `AITabsView` class constructor.
- */
+* The options for the `AITabsView` class constructor.
+*/
 export type AITabsMainViewOptions = AITabsViewOptions & {
-    /**
-     * The type of the AI Tabs view. The possible values are:
-     *
-     * * `'overlay'` - the tabs are displayed as an overlay on top of the web page,
-     * * `'sidebar'` - the tabs are displayed in a user-defined container,
-     * * `'custom'` - the tabs are displayed as a custom UI, the integrator is responsible for the layout.
-     */
-    type?: (typeof AI_TABS_VIEW_TYPES)[number];
-    /**
-     * Whether the AI interface should be visible when created.
-     */
-    visibleByDefault?: boolean;
+	/**
+	* The type of the AI Tabs view. The possible values are:
+	*
+	* * `'overlay'` - the tabs are displayed as an overlay on top of the web page,
+	* * `'sidebar'` - the tabs are displayed in a user-defined container,
+	* * `'custom'` - the tabs are displayed as a custom UI, the integrator is responsible for the layout.
+	*/
+	type?: (typeof AI_TABS_VIEW_TYPES)[number];
+	/**
+	* Whether the AI interface should be visible when created.
+	*/
+	visibleByDefault?: boolean;
 };