@malva-ui/editor 0.1.12 → 0.1.14

package/types/malva-ui-editor.d.ts

@@ -0,0 +1,2995 @@
+import * as _angular_core from '@angular/core';
+import { Signal, InjectionToken, ElementRef, WritableSignal, TemplateRef, AfterViewInit, OnChanges, SimpleChanges } from '@angular/core';
+import { Editor, Extensions, Extension } from '@tiptap/core';
+export { Editor, EditorOptions, Extension, Extensions } from '@tiptap/core';
+import { Transaction } from '@tiptap/pm/state';
+import { MlvEditorI18n } from '@malva-ui/i18n';
+import * as _malva_ui_core_menu from '@malva-ui/core/menu';
+import { MlvMenu, MlvMenuTrigger } from '@malva-ui/core/menu';
+import * as _malva_ui_editor from '@malva-ui/editor';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { MlvInput } from '@malva-ui/core/input';
+import { MlvPopup, MlvPopupTrigger } from '@malva-ui/core/popup';
+import { MlvSignalFormControlBase, MlvFormControl } from '@malva-ui/core/form-utils';
+import * as _tiptap_extension_file_handler from '@tiptap/extension-file-handler';
+import { MlvColorPickerPopup } from '@malva-ui/core/color-picker';
+import { MlvSelectOption } from '@malva-ui/core/dropdown';
+
+/**
+ * Supported external serialization formats for editor content.
+ *
+ * `'html'` and `'markdown'` carry text markup. `'json'` carries the Tiptap
+ * document itself as `JSON.stringify(editor.getJSON())`, so custom block nodes
+ * round-trip their typed attributes instead of being flattened into HTML
+ * attributes. The model type stays `string | null` in every format; a JSON
+ * host parses that string at its own boundary.
+ */
+type MlvEditorFormat = 'html' | 'markdown' | 'json';
+/**
+ * Width of the centred editor content column.
+ *
+ * `'default'` is a comfortable reading measure, `'wide'` suits dense or tabular
+ * documents, and `'full'` lets the column fill its host. A horizontal gutter is
+ * reserved at every value, so block affordances never overlap text.
+ */
+type MlvEditorContentWidth = 'default' | 'wide' | 'full';
+/** Origin of an image file supplied to the editor. */
+type MlvEditorImageUploadSource = 'button' | 'paste' | 'drop';
+/** Decides whether an uploaded image URL is safe to insert into the editor. */
+type MlvEditorImageUrlPolicy = (url: string) => boolean;
+/**
+ * Default image URL policy used by the editor upload coordinator.
+ *
+ * Only absolute HTTP(S) URLs with a hostname and without credentials are
+ * accepted. Leading and trailing whitespace is ignored, while whitespace or
+ * control characters inside the URL are rejected.
+ *
+ * @param url Candidate image URL returned by an uploader.
+ * @returns Whether the URL is safe to insert.
+ */
+declare function mlvEditorDefaultImageUrlPolicy(url: string): boolean;
+/** Details emitted when the Tiptap selection changes. */
+interface MlvEditorSelectionChange {
+    /** Editor that produced the selection transaction. */
+    readonly editor: Editor;
+    /** Tiptap transaction containing the updated selection. */
+    readonly transaction: Transaction;
+}
+/** Details emitted for every Tiptap transaction. */
+interface MlvEditorTransactionEvent {
+    /** Editor that produced the transaction. */
+    readonly editor: Editor;
+    /** Tiptap transaction emitted by the editor. */
+    readonly transaction: Transaction;
+}
+/** Details emitted when the editor receives or loses focus. */
+interface MlvEditorFocusEvent {
+    /** Editor associated with the native focus event. */
+    readonly editor: Editor;
+    /** Native browser focus event. */
+    readonly event: FocusEvent;
+}
+/** Context supplied to an image uploader for one upload operation. */
+interface MlvEditorImageUploadContext {
+    /** Origin of the image file. */
+    readonly source: MlvEditorImageUploadSource;
+    /** Signal that is aborted when the upload should stop. */
+    readonly signal: AbortSignal;
+    /** Reports upload progress as a percentage from 0 through 100. */
+    readonly reportProgress: (percentage: number) => void;
+}
+/** Image metadata returned by an image uploader after a successful upload. */
+interface MlvEditorImageUploadResult {
+    /** URL used in the inserted image node. */
+    readonly src: string;
+    /** Optional alternative text for the image. */
+    readonly alt?: string;
+    /** Optional image title. */
+    readonly title?: string;
+    /** Optional rendered image width. */
+    readonly width?: number;
+    /** Optional rendered image height. */
+    readonly height?: number;
+}
+/** Adapter used to transfer image files selected, pasted, or dropped in the editor. */
+interface MlvEditorImageUploader {
+    /**
+     * Uploads an image file and returns the metadata used to insert it.
+     *
+     * @param file Image file to upload.
+     * @param context Source, cancellation, and progress facilities for this upload.
+     * @returns Metadata for the successfully uploaded image.
+     */
+    upload(file: File, context: MlvEditorImageUploadContext): Promise<MlvEditorImageUploadResult>;
+}
+/** Constraints applied before images are sent to an uploader. */
+interface MlvEditorImageUploadOptions {
+    /** MIME types or patterns accepted by the editor. */
+    readonly accept: readonly string[];
+    /** Largest allowed file size in bytes. */
+    readonly maxSize: number;
+    /** Maximum number of files accepted in one upload action. */
+    readonly maxFiles: number;
+    /** Optional host policy replacing the default uploaded-image URL decision. */
+    readonly urlPolicy?: MlvEditorImageUrlPolicy;
+}
+/** One upload retained by the editor while it is active or retryable. */
+interface MlvEditorPendingUpload {
+    /** Stable identifier shared with the non-serializable placeholder. */
+    readonly id: string;
+    /** Image file supplied by the host interaction. */
+    readonly file: File;
+    /** Interaction that supplied the file. */
+    readonly source: MlvEditorImageUploadSource;
+    /** Current finite upload progress from zero through one hundred. */
+    readonly progress: number;
+    /** Whether the upload is active or retained after a recoverable failure. */
+    readonly status: 'uploading' | 'failed';
+    /** Recoverable failure retained while the upload can be retried or removed. */
+    readonly error?: MlvEditorError;
+}
+/**
+ * Editor-owned image-upload capability forwarded to standalone toolbars.
+ *
+ * The capability is intentionally one shared reference so toolbar controls
+ * never create a second uploader, request registry, or placeholder owner. Its
+ * private brand makes this a library-owned capability rather than a structural
+ * protocol for consumers to implement.
+ */
+declare abstract class MlvEditorImageUploadControl {
+    /** @private Nominal brand preventing structural implementations. */
+    private readonly _mlvEditorImageUploadControlBrand;
+    protected constructor();
+    /** Whether this editor can currently begin image uploads. */
+    abstract readonly available: Signal<boolean>;
+    /** Whether either the input or injected adapter resolves for this editor. */
+    abstract readonly adapterAvailable: Signal<boolean>;
+    /** Current editor-scoped validation options. */
+    abstract readonly options: Signal<MlvEditorImageUploadOptions>;
+    /** Active and retryable uploads owned by this editor. */
+    abstract readonly pending: Signal<readonly MlvEditorPendingUpload[]>;
+    /** Starts validated uploads in the owning editor. */
+    abstract start(files: readonly File[], source: MlvEditorImageUploadSource, metadata?: {
+        readonly position?: number;
+        readonly alt?: string;
+        readonly title?: string;
+    }): readonly string[];
+    /** Cancels one active request. */
+    abstract cancel(id: string): void;
+    /** Retries one recoverable request. */
+    abstract retry(id: string): void;
+    /** Removes one recoverable failure. */
+    abstract remove(id: string): void;
+}
+/** Details emitted after a successful image upload. */
+interface MlvEditorImageUploadSuccess {
+    /** Image file that was uploaded. */
+    readonly file: File;
+    /** Origin of the image file. */
+    readonly source: MlvEditorImageUploadSource;
+    /** Metadata returned by the image uploader. */
+    readonly result: MlvEditorImageUploadResult;
+}
+/** Details emitted when an image upload fails. */
+interface MlvEditorImageUploadFailure {
+    /** Image file whose upload failed. */
+    readonly file: File;
+    /** Origin of the image file. */
+    readonly source: MlvEditorImageUploadSource;
+    /** Recoverable error describing the failed upload. */
+    readonly error: MlvEditorError;
+}
+/** Details emitted when an image upload is cancelled. */
+interface MlvEditorImageUploadCancelled {
+    /** Image file whose upload was cancelled. */
+    readonly file: File;
+    /** Origin of the image file. */
+    readonly source: MlvEditorImageUploadSource;
+}
+/**
+ * Categories of recoverable errors emitted by the editor.
+ *
+ * `'ai-transport'` reports an AI provider that threw or whose stream failed;
+ * `'ai-result'` reports AI output that could not be used. Both restore the
+ * document to its pre-request checkpoint; cancellation is silent and never
+ * emits an error.
+ */
+type MlvEditorErrorCode = 'configuration' | 'parse' | 'serialize' | 'unsupported-command' | 'upload-validation' | 'upload-transport' | 'upload-result' | 'ai-transport' | 'ai-result';
+/** Structured error emitted instead of throwing through Angular change detection. */
+interface MlvEditorError {
+    /** Stable category that callers can use for error handling. */
+    readonly code: MlvEditorErrorCode;
+    /** Human-readable description of the failure. */
+    readonly message: string;
+    /** Whether the editor can continue operating after the failure. */
+    readonly recoverable: boolean;
+    /** Original failure when one is available. */
+    readonly cause?: unknown;
+}
+
+/** Optional dependency-injection token for a host-provided image uploader. */
+declare const MLV_EDITOR_IMAGE_UPLOADER: InjectionToken<MlvEditorImageUploader>;
+/** Default restrictions for image files inserted through the editor. */
+declare const MLV_EDITOR_DEFAULT_IMAGE_UPLOAD_OPTIONS: MlvEditorImageUploadOptions;
+
+/**
+ * Lifecycle of the per-editor AI surface.
+ *
+ * `'idle'` — no AI work is in flight. `'running'` — a transform is streaming
+ * into the document, or a `'review'` transform is collecting its result.
+ * `'reviewing'` — a collected result was applied as tracked suggestions that
+ * await per-change or bulk accept/reject; the state ends when the suggestion
+ * set empties.
+ */
+type MlvEditorAiStatus = 'idle' | 'running' | 'reviewing';
+/** Options accepted by {@link MlvEditorAiContext.runTransform}. */
+interface MlvEditorAiTransformOptions {
+    /**
+     * Free-form transform argument: the prompt for `'custom'`, the target tone
+     * for `'tone'`, or the target language for `'translate'`.
+     */
+    readonly instruction?: string;
+    /**
+     * Where the streamed result lands; defaults to `'replace-selection'`.
+     * `'review'` collects the complete result without touching the document
+     * and applies it as reviewable tracked suggestions on success.
+     */
+    readonly output?: MlvEditorAiOutputMode;
+}
+/**
+ * Per-editor AI command state provided by `mlv-editor`.
+ *
+ * The context owns provider resolution, request shaping, and the streaming
+ * and review session lifecycles; the framework-free engines
+ * ({@link runMlvEditorAiStream}, {@link applyMlvEditorAiSuggestions}) own
+ * document mutation. Every mutation is
+ * gated by the toolbar context's guard, so readonly and disabled editors
+ * refuse to start AI work — controls stay visible while a provider exists
+ * (presence) and disable with the editor (executability), matching the
+ * toolbar's presence-vs-executability rule.
+ *
+ * Failures never throw or reject: they surface as recoverable
+ * {@link MlvEditorError} emissions through the owning editor's `editorError`
+ * output. Cancellation stays silent.
+ */
+declare class MlvEditorAiContext {
+    /** @private Guarded command surface and error channel of the owning editor. */
+    private readonly _toolbar;
+    /** @private Application-level provider used when the input supplies none. */
+    private readonly _injectedProvider;
+    /** @private The owning editor's `aiProvider` input; wins over the token. */
+    private readonly _inputProvider;
+    /** @private Announces streaming lifecycle politely; decorations are aria-hidden. */
+    private readonly _liveAnnouncer;
+    /** @private Optional translated announcement strings. */
+    private readonly _i18n;
+    /** @private Resolves the ICU review-count announcement template. */
+    private readonly _resolver;
+    /** @private Writable lifecycle state behind the readonly public signal. */
+    private readonly _status;
+    /** @private Writable pending-suggestion projection behind the readonly signal. */
+    private readonly _suggestions;
+    /**
+     * @private Latest streaming session. Retained after settlement so
+     * {@link restoreCheckpoint} can undo a committed transform; replaced when
+     * the next transform starts.
+     */
+    private _session;
+    /** @private Abort control for the in-flight provider request, if any. */
+    private _abortController;
+    /**
+     * @private Active review wiring: the engine session plus the teardown that
+     * detaches the editor `transaction`/`destroy` listeners mirroring it into
+     * {@link suggestions}. `null` outside `'reviewing'`.
+     */
+    private _review;
+    /**
+     * @private Last suggestion id {@link revealSuggestion} announced. Repeated
+     * reveals of the same suggestion (the review bar re-runs its outline effect
+     * on unrelated signal updates) must not re-announce it.
+     */
+    private _revealedId;
+    /** Lifecycle of the AI surface for this editor. */
+    readonly status: Signal<MlvEditorAiStatus>;
+    /**
+     * Pending suggestions of the active review session, in document order.
+     * Empty outside `'reviewing'`. Refreshed after every editor transaction, so
+     * accept/reject calls, intersecting user edits, and an undo of the
+     * application are all reflected immediately. Document ranges deliberately
+     * stay internal — they remap on every transaction and would be stale the
+     * moment a consumer stored them.
+     */
+    readonly suggestions: Signal<readonly MlvEditorAiReviewSuggestion[]>;
+    /**
+     * Whether a review session with unresolved suggestions is active. Hosts
+     * gate saves on this: during `'reviewing'` the document serializes in its
+     * accepted-by-default shape (inserted text present, removed text absent).
+     */
+    readonly hasPendingSuggestions: Signal<boolean>;
+    /**
+     * Whether an AI provider is resolvable for this editor, either through the
+     * `aiProvider` input or `MLV_EDITOR_AI_PROVIDER`. AI UI modules hide
+     * entirely without a provider.
+     */
+    readonly hasProvider: Signal<boolean>;
+    /**
+     * Runs one selection transform through the resolved provider and lands the
+     * result according to the output mode: `'replace-selection'` and
+     * `'insert-below'` stream into the document, while `'review'` collects the
+     * complete result without writing and then applies it over the selection
+     * captured at start as reviewable tracked suggestions — status moves to
+     * `'reviewing'` and the suggestion surface
+     * ({@link suggestions}, {@link acceptSuggestion}, …) takes over. A review
+     * result identical to the region applies nothing: status returns straight
+     * to `'idle'` with a polite no-changes announcement and no error.
+     *
+     * The returned promise resolves after the session settles and never
+     * rejects; every failure is reported as a recoverable error through the
+     * editor's `editorError` output instead:
+     *
+     * - a transform already running, or a review still pending
+     *   (`configuration`) — concurrent calls are refused rather than queued,
+     *   so one editor never hosts two writers and pending suggestions are
+     *   never silently replaced;
+     * - a readonly, disabled, or absent editor (`configuration`) — the toolbar
+     *   guard refuses to start, and a `'review'` run re-checks the same guard
+     *   after collection: an editor that became readonly or disabled mid-run
+     *   refuses to apply the collected suggestions (checkpoint untouched — a
+     *   review collection never wrote);
+     * - no resolvable provider (`configuration`);
+     * - a provider that throws or whose stream fails (`'ai-transport'`) — the
+     *   checkpoint is restored;
+     * - unusable output (`'ai-result'`) — the checkpoint is restored. Both
+     *   restore paths are no-ops for `'review'`, which never wrote.
+     *
+     * Start, successful finish, and cancellation are announced through the CDK
+     * `LiveAnnouncer` at `'polite'`; a successful `'review'` run announces the
+     * pending suggestion count instead of the generic finish. A failure
+     * announces nothing because the error channel already reports it.
+     *
+     * @param kind Transform requested from the provider.
+     * @param options Optional instruction and output mode.
+     */
+    runTransform(kind: MlvEditorAiTransformKind, options?: MlvEditorAiTransformOptions): Promise<void>;
+    /**
+     * Aborts the in-flight request and rolls the document back to the
+     * checkpoint captured when the transform started.
+     *
+     * The provider's `AbortSignal` aborts, the streaming session restores the
+     * checkpoint, and the transform resolves silently — no error is emitted
+     * and only the cancellation announcement is made. A no-op while idle.
+     */
+    cancel(): void;
+    /**
+     * Restores the document to the checkpoint of the most recent transform.
+     *
+     * While a transform is running this behaves exactly like {@link cancel}.
+     * After a committed transform it reverts the commit in one history-visible
+     * step, so the restore is itself undoable. While `'reviewing'`, restoring
+     * reverts the applied suggestions wholesale, which drops the suggestion
+     * set and ends the review. The restore is a document mutation and
+     * therefore passes the toolbar guard: readonly and disabled editors refuse
+     * it. A no-op when no transform has run.
+     */
+    restoreCheckpoint(): void;
+    /**
+     * Accepts one pending suggestion: the applied change stays in the document
+     * and its decorations drop. Delegates to the review engine — a pure
+     * plugin-state update that creates no history entry. Announces the
+     * acceptance politely; when the last suggestion resolves the review ends
+     * and {@link status} returns to `'idle'`.
+     *
+     * Refused silently — decorations stay visible, nothing changes — while no
+     * review is active, the id is unknown, or the editor is readonly or
+     * disabled (the same guard rule that blocks every other AI mutation).
+     *
+     * @param id Identifier from {@link suggestions}.
+     */
+    acceptSuggestion(id: string): void;
+    /**
+     * Rejects one pending suggestion: the original content is restored over
+     * the suggestion's range in exactly one history-visible step and its
+     * decorations drop. Announces the rejection politely; when the last
+     * suggestion resolves the review ends and {@link status} returns to
+     * `'idle'`.
+     *
+     * Refused silently while no review is active, the id is unknown, or the
+     * editor is readonly or disabled — the restore is a document mutation and
+     * runs through the toolbar guard.
+     *
+     * @param id Identifier from {@link suggestions}.
+     */
+    rejectSuggestion(id: string): void;
+    /**
+     * Accepts every pending suggestion in one plugin-state update — no
+     * document step, no history entry — then ends the review and returns
+     * {@link status} to `'idle'`. Announced politely. Refused silently while
+     * no review is active or the editor is readonly or disabled.
+     */
+    acceptAll(): void;
+    /**
+     * Rejects every pending suggestion in exactly one history-visible step,
+     * restoring the original content of the whole reviewed region, then ends
+     * the review and returns {@link status} to `'idle'`. Announced politely.
+     * Refused silently while no review is active or the editor is readonly or
+     * disabled — the restore is a document mutation and runs through the
+     * toolbar guard.
+     */
+    rejectAll(): void;
+    /**
+     * Outlines one pending suggestion as the current one under review and
+     * scrolls its document range into view; `null` clears the outline (review
+     * surfaces call that on teardown so no marker strands).
+     *
+     * The outline decorations are `aria-hidden`, so revealing a suggestion also
+     * announces its {@link describeSuggestion} description politely — index,
+     * count, and the removed/added text — the non-visual equivalent the spec
+     * requires. Each suggestion is announced once per reveal: repeating the
+     * current id moves nothing and re-announces nothing.
+     *
+     * Otherwise a pure view affordance: the outline is a decoration-only
+     * plugin-state update, so no document step and no history entry is created
+     * — which is why, unlike accept/reject, it stays available in readonly
+     * editors, whose pending reviews remain visible and navigable. Refused
+     * silently while no review is active or the id is unknown. The review bar
+     * drives this from its navigation cursor.
+     *
+     * @param id Identifier from {@link suggestions}, or `null` to clear.
+     */
+    revealSuggestion(id: string | null): void;
+    /**
+     * Human-readable description of one pending suggestion — its one-based
+     * position in the pending list plus what it replaces, inserts, or removes —
+     * resolved through the `aiCurrentSuggestionReplace`/`-Insert`/`-Delete`
+     * ICU templates.
+     *
+     * This is the non-visual equivalent of the `aria-hidden` suggestion
+     * decorations: {@link revealSuggestion} announces it, and the review bar
+     * additionally exposes it to its accept/reject controls through
+     * `aria-describedby`, so the change under decision is inspectable without
+     * sight of the decorations. Returns `null` while no review is active or
+     * for an unknown id.
+     *
+     * @param id Identifier from {@link suggestions}.
+     */
+    describeSuggestion(id: string): string | null;
+    /**
+     * @private Scrolls the rendered element at one document position into view.
+     * Best effort: position resolution can fail transiently mid-transaction and
+     * jsdom offers no `scrollIntoView`, so failure never fails the reveal.
+     */
+    private _scrollPositionIntoView;
+    /**
+     * @private Routes a committed review collection through the suggestion
+     * engine. An engine refusal — the replacement is identical to the region,
+     * or otherwise nothing reviewable results — is the no-changes case: status
+     * returns to `'idle'` with a polite announcement, no error, and no
+     * document change. Otherwise the context enters `'reviewing'`, mirrors the
+     * engine's suggestion set into {@link suggestions} after every editor
+     * transaction (the session has no change notification of its own), and
+     * announces the pending count.
+     */
+    private _startReview;
+    /**
+     * @private Ends the review session exactly once: detaches the editor
+     * listeners, clears the suggestion projection, and returns to `'idle'`.
+     * Runs when the suggestion set empties — accept/reject calls, intersecting
+     * edits dropping the last suggestion, or an undo of the application — and
+     * when the editor is destroyed.
+     */
+    private _endReview;
+    /** @private Projects engine suggestions into the range-free public shape. */
+    private _projectSuggestions;
+    /** @private Announces the pending review count politely through the ICU template. */
+    private _announceReviewStarted;
+    /** @private Resolves the active provider; the input wins over the token. */
+    private _resolveProvider;
+    /** @private Reports a recoverable configuration refusal through the editor. */
+    private _reportConfiguration;
+    /** @private Announces one localized AI lifecycle message politely. */
+    private _announce;
+    /**
+     * @private Serializes the current selection as Markdown, or `null` when the
+     * selection is empty. Uses the editor's Markdown manager — the same
+     * serialization path as `getMarkdown()` — over the selection sliced into
+     * its own document; a replacement extension set without Markdown falls back
+     * to plain text so providers still receive usable context.
+     */
+    private _serializeSelection;
+    /**
+     * @private Serializes the whole document as Markdown, or `null` when the
+     * document is semantically empty. The document window is currently the full
+     * document; a bounded window is a later refinement. Falls back to plain
+     * text when the extension set carries no Markdown manager.
+     */
+    private _serializeDocument;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvEditorAiContext, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MlvEditorAiContext>;
+}
+/** Injects the AI command state belonging to the nearest `mlv-editor`. */
+declare const MLV_EDITOR_AI_CONTEXT: InjectionToken<MlvEditorAiContext>;
+
+/**
+ * CSS class of the inline decoration highlighting text a pending suggestion
+ * inserted into the document.
+ *
+ * The class is applied through a ProseMirror decoration held in plugin state,
+ * never through document content, so it can appear in no HTML, Markdown, or
+ * JSON serialization.
+ */
+declare const MLV_EDITOR_AI_SUGGESTION_INSERT_CLASS = "mlv-editor__ai-suggestion-insert";
+/**
+ * CSS class of the widget decoration rendering text a pending suggestion
+ * removed from the document.
+ *
+ * The removed text lives only inside the widget element — a strikethrough,
+ * `aria-hidden` affordance — so it is absent from the document and from every
+ * serialization the moment the suggestion is applied.
+ */
+declare const MLV_EDITOR_AI_SUGGESTION_DELETE_CLASS = "mlv-editor__ai-suggestion-delete";
+/**
+ * CSS class added on top of the insert and delete decorations of the one
+ * suggestion a review surface currently navigates
+ * ({@link MlvEditorAiSuggestionsSession.setCurrent}).
+ *
+ * A decoration-only outline affordance: it never enters document content or
+ * any serialization, and marking a suggestion current dispatches no document
+ * step, so it can never create a history entry.
+ */
+declare const MLV_EDITOR_AI_SUGGESTION_CURRENT_CLASS = "mlv-editor__ai-suggestion-current";
+/**
+ * Shape of one reviewable change.
+ *
+ * `'insert'` — new text was added; reject removes it. `'delete'` — text was
+ * removed; reject restores it. `'replace'` — text was swapped; reject
+ * restores the original.
+ */
+type MlvEditorAiSuggestionKind = 'insert' | 'delete' | 'replace';
+/** Document range a suggestion currently occupies. */
+interface MlvEditorAiSuggestionRange {
+    /** Start position of the suggestion's inserted content. */
+    readonly from: number;
+    /**
+     * End position of the suggestion's inserted content. Equals {@link from}
+     * for `'delete'` suggestions, whose removed text exists only in the widget
+     * decoration anchored at this collapsed position.
+     */
+    readonly to: number;
+}
+/** One pending, reviewable AI change. */
+interface MlvEditorAiSuggestion {
+    /** Stable identifier, unique across sessions within this runtime. */
+    readonly id: string;
+    /** Shape of the change. */
+    readonly kind: MlvEditorAiSuggestionKind;
+    /**
+     * Current document range of the inserted content, remapped through every
+     * concurrent transaction. Collapsed for `'delete'` suggestions.
+     */
+    readonly range: MlvEditorAiSuggestionRange;
+    /** Plain text the change removed; empty for `'insert'`. */
+    readonly oldText: string;
+    /** Plain text the change added; empty for `'delete'`. */
+    readonly newText: string;
+}
+/** Options accepted by {@link applyMlvEditorAiSuggestions}. */
+interface MlvEditorAiSuggestionsOptions {
+    /** Start of the document region the replacement rewrites. */
+    readonly from: number;
+    /** End of the document region the replacement rewrites. */
+    readonly to: number;
+    /**
+     * AI-produced replacement for the region, as Markdown. Parsed through the
+     * editor's Markdown manager when one is registered; treated as plain text
+     * otherwise — the same fallback the streaming engine uses for its commit.
+     */
+    readonly replacementMarkdown: string;
+}
+/**
+ * Handle over one review session created by {@link applyMlvEditorAiSuggestions}.
+ *
+ * Undo semantics — a deliberate refinement of the spec sentence "each
+ * accept/reject = one undo step": in the applied-edits storage model the
+ * document already carries every change, so **accepting changes no document
+ * content**. Accept operations (including {@link acceptAll}) are pure
+ * plugin-state updates that drop decorations and entries without dispatching
+ * a single step, and therefore create **no** history entry — an "accept undo
+ * step" would necessarily be an empty one. Rejects mutate the document:
+ * {@link reject} is exactly one history-visible step per call, and
+ * {@link rejectAll} is exactly one step total.
+ *
+ * Every method returns `false` once the session has ended — all suggestions
+ * resolved, the application undone, a newer session started, or the editor
+ * destroyed.
+ */
+interface MlvEditorAiSuggestionsSession {
+    /**
+     * Current pending suggestions in document order, with ranges remapped
+     * through every transaction dispatched since application. Empty once the
+     * session has ended.
+     */
+    suggestions(): readonly MlvEditorAiSuggestion[];
+    /**
+     * Accepts one suggestion: the applied change stays in the document and its
+     * decorations are dropped. A pure plugin-state update — no document step,
+     * no history entry. Returns whether the suggestion existed.
+     */
+    accept(id: string): boolean;
+    /**
+     * Rejects one suggestion: the original content is restored over the
+     * suggestion's current range in exactly one history-visible step, and the
+     * suggestion's decorations are dropped. Returns whether the suggestion
+     * existed and the restore succeeded.
+     *
+     * Restored is the reviewed region, not the editor's own schema-maintenance
+     * reactions to the suggested state: for example, the default preset's
+     * `trailingNode` paragraph appended while a structural suggestion was the
+     * last block stays behind — the same residue an ordinary user edit leaves.
+     */
+    reject(id: string): boolean;
+    /**
+     * Accepts every pending suggestion in one plugin-state update. Like
+     * {@link accept}, dispatches no document step and creates no history
+     * entry. Returns whether any suggestion was pending.
+     */
+    acceptAll(): boolean;
+    /**
+     * Rejects every pending suggestion in exactly one history-visible step,
+     * restoring the original content of the whole reviewed region. Returns
+     * whether any suggestion was pending and the restore succeeded.
+     */
+    rejectAll(): boolean;
+    /**
+     * Marks one suggestion as the current one under review: its decorations
+     * gain {@link MLV_EDITOR_AI_SUGGESTION_CURRENT_CLASS} and the previous
+     * current suggestion loses it. `null` clears the marker. Like
+     * {@link accept}, a pure plugin-state update — no document step, no
+     * history entry. The marker clears itself when its suggestion resolves or
+     * is dropped by a concurrent edit. Returns `false` once the session has
+     * ended or for an unknown id.
+     */
+    setCurrent(id: string | null): boolean;
+}
+/**
+ * Applies an AI replacement for `[from, to]` as reviewable tracked changes —
+ * the Phase 2 suggestion engine (storage option B of the design spec).
+ *
+ * Framework-free: only the editor instance and the replacement Markdown are
+ * needed — no Angular, no provider token, no network.
+ *
+ * Diff granularity (pragmatic, documented rule): when the original region is
+ * a single textblock of plain, unmarked text **and** the parsed replacement
+ * is a single paragraph of plain text, the two are diffed token-by-token
+ * (tokens are whitespace or word runs) over a longest common subsequence,
+ * producing individual insert/delete/replace suggestions. Any structural or
+ * formatted content on either side falls back to **one** whole-region
+ * replace suggestion.
+ *
+ * Representation: inserted text enters the document immediately and is
+ * highlighted by an inline decoration
+ * ({@link MLV_EDITOR_AI_SUGGESTION_INSERT_CLASS}); deleted text is removed
+ * from the document and re-rendered at its position by a strikethrough
+ * `aria-hidden` widget decoration
+ * ({@link MLV_EDITOR_AI_SUGGESTION_DELETE_CLASS}). Because both are
+ * decorations, `getHTML`/`getMarkdown`/`getJSON` during review serialize the
+ * document as-is — inserted text present, removed text absent — the spec's
+ * accepted-by-default rule. Hosts gate saves on pending suggestions.
+ *
+ * The whole application is exactly **one** history-visible transaction:
+ * one undo removes every suggested change at once — and, because the undo
+ * intersects every suggestion range, it also drops the whole session.
+ *
+ * Concurrent edits: user transactions remap all suggestion ranges through
+ * their step maps; an edit that intersects a suggestion's range drops that
+ * one suggestion (decorations removed, the current document text stands,
+ * nothing is restored). The session ends when every suggestion is resolved
+ * or dropped, and editor destruction cleans up listeners and plugin state.
+ * Starting a new session on an editor first ends the previous one, leaving
+ * its remaining suggestions applied (accepted-by-default).
+ *
+ * Undo-step semantics of the returned session are documented on
+ * {@link MlvEditorAiSuggestionsSession}.
+ *
+ * @param editor Live Tiptap editor the suggestions are applied to.
+ * @param options Region to rewrite and the replacement Markdown.
+ * @returns The review session, or `null` when nothing reviewable results —
+ * destroyed editor, out-of-range positions, unusable replacement, or a
+ * replacement identical to the region.
+ */
+declare function applyMlvEditorAiSuggestions(editor: Editor, options: MlvEditorAiSuggestionsOptions): MlvEditorAiSuggestionsSession | null;
+
+/**
+ * The transform kinds the library itself ships menu entries and i18n copy for.
+ *
+ * `'improve'`, `'fix-grammar'`, `'shorten'`, `'extend'`, and `'summarize'`
+ * rewrite the selection without further arguments. `'tone'` and `'translate'`
+ * carry their target tone or language in
+ * {@link MlvEditorAiRequest.instruction}. `'custom'` carries a free-form host
+ * or user prompt in the same field.
+ */
+type MlvEditorAiBuiltInTransformKind = 'improve' | 'fix-grammar' | 'shorten' | 'extend' | 'summarize' | 'tone' | 'translate' | 'custom';
+/**
+ * Selection transform requested from an AI provider: one of the
+ * {@link MlvEditorAiBuiltInTransformKind} values, or any host-authored string.
+ *
+ * The provider owns prompting, so a kind is a name the *provider* understands
+ * and is fully opaque to the editor: nothing in the library branches on it,
+ * and it is forwarded verbatim on {@link MlvEditorAiRequest.kind}. A host that
+ * supplies its own {@link MlvEditorAiAction} list can therefore name kinds the
+ * library has never heard of (`'legal-review'`, `'to-bullets'`, …) and answer
+ * them in its own provider.
+ *
+ * The union with `string` deliberately keeps the built-in literals in
+ * autocomplete — `(string & {})` is not reduced to `string` by the compiler,
+ * so editors still suggest `'improve'` while any other string remains
+ * assignable. The corollary for providers: `request.kind` is not exhaustively
+ * checkable, so a `switch` over it needs a `default` branch that tolerates
+ * kinds it does not know.
+ */
+type MlvEditorAiTransformKind = MlvEditorAiBuiltInTransformKind | (string & {});
+/**
+ * One entry of the AI menu's action list.
+ *
+ * Hosts pass an array of these to `MlvEditorAiMenu.actions` to replace the
+ * built-in list literally — see `mlvEditorAiDefaultActions()` to start from
+ * the built-ins instead of retyping them.
+ */
+interface MlvEditorAiAction {
+    /**
+     * Transform kind forwarded verbatim to the provider through
+     * {@link MlvEditorAiContext.runTransform}. Any string is valid; see
+     * {@link MlvEditorAiTransformKind}. Ignored when {@link run} is present.
+     *
+     * Kinds are not required to be unique within one list: two entries may run
+     * the same kind with different instructions.
+     */
+    readonly kind: MlvEditorAiTransformKind;
+    /**
+     * Display text of the menu item, already resolved. The menu renders it as
+     * given and never translates it — a localized list is built by resolving
+     * the copy before constructing the actions.
+     */
+    readonly label: string;
+    /**
+     * Free-form transform argument passed through as
+     * {@link MlvEditorAiRequest.instruction}: a fixed tone for `'tone'`, a fixed
+     * target language for `'translate'`, or a canned prompt for `'custom'`.
+     * Omitted from the request when absent. Ignored when {@link run} is present.
+     */
+    readonly instruction?: string;
+    /**
+     * Where the result lands; defaults to `'replace-selection'`. Ignored when
+     * {@link run} is present.
+     */
+    readonly output?: MlvEditorAiOutputMode;
+    /**
+     * Escape hatch replacing the menu's own behaviour for this entry.
+     *
+     * When present the menu calls this instead of `runTransform` and reads
+     * neither {@link kind}, {@link instruction}, nor {@link output} — they stay
+     * available to the callback itself, which owns the whole action. The
+     * argument is the live per-editor {@link MlvEditorAiContext}, so the
+     * callback can call `runTransform` with anything (including options this
+     * shape cannot express), chain several calls, inspect `status()` /
+     * `hasProvider()` / the review surface, or do something else entirely and
+     * never touch the AI context at all.
+     *
+     * It runs only when the item is enabled, so the readonly, disabled, and
+     * already-running guards still hold.
+     *
+     * @param context The AI context of the editor this menu belongs to.
+     */
+    readonly run?: (context: MlvEditorAiContext) => void;
+}
+/**
+ * Where the streamed result of a transform lands in the document.
+ *
+ * `'replace-selection'` overwrites the selected fragment in place.
+ * `'insert-below'` keeps the selection and streams the result into a new
+ * block after it. `'review'` collects the complete result without touching
+ * the document, then lands it as reviewable tracked suggestions the user
+ * accepts or rejects through the context's suggestion surface.
+ */
+type MlvEditorAiOutputMode = 'replace-selection' | 'insert-below' | 'review';
+/**
+ * One pending AI change as the Angular context exposes it to review UIs.
+ *
+ * A projection of the engine-level `MlvEditorAiSuggestion`: the live document
+ * range stays internal to the context — positions remap on every transaction
+ * and would be stale the moment a template read them. Review surfaces render
+ * identity, shape, and the two texts; accept/reject go back through the
+ * context by `id`.
+ */
+interface MlvEditorAiReviewSuggestion {
+    /** Stable identifier, unique across sessions within this runtime. */
+    readonly id: string;
+    /**
+     * Shape of the change: `'insert'` added text, `'delete'` removed text,
+     * `'replace'` swapped text.
+     */
+    readonly kind: MlvEditorAiSuggestionKind;
+    /** Plain text the change removed; empty for `'insert'`. */
+    readonly oldText: string;
+    /** Plain text the change added; empty for `'delete'`. */
+    readonly newText: string;
+}
+/**
+ * One structured request handed to an {@link MlvEditorAiProvider}.
+ *
+ * The editor never builds a prompt: the provider receives the transform kind,
+ * the optional instruction, and Markdown context, and owns prompting, model
+ * choice, and server-side policy itself.
+ */
+interface MlvEditorAiRequest {
+    /**
+     * Requested capability. Either a selection transform or `'autocomplete'`
+     * for ghost-text completion at the caret.
+     *
+     * Not a closed union: a host-supplied action list can name any kind, so a
+     * provider that branches on this field must tolerate kinds it does not
+     * recognize rather than assume exhaustiveness.
+     */
+    readonly kind: MlvEditorAiTransformKind | 'autocomplete';
+    /**
+     * Free-form argument for the transform: the custom prompt for `'custom'`,
+     * the target tone for `'tone'`, or the target language for `'translate'`.
+     * Absent for transforms that need no argument.
+     */
+    readonly instruction?: string;
+    /** Markdown context captured from the editor when the request started. */
+    readonly context: {
+        /** Selected fragment as Markdown, or `null` when nothing is selected. */
+        readonly selection: string | null;
+        /** Optional surrounding document window as Markdown, or `null`. */
+        readonly document: string | null;
+    };
+    /**
+     * Aborted when the user cancels, presses Escape, or edits the document
+     * mid-stream. Providers should stop producing chunks once aborted.
+     */
+    readonly signal: AbortSignal;
+    /** Host-defined passthrough metadata; the editor never reads it. */
+    readonly meta?: Record<string, unknown>;
+}
+/**
+ * Host-supplied transport for AI transforms.
+ *
+ * The library performs no network requests itself. Hosts provide an
+ * implementation through the `aiProvider` input on `mlv-editor` or the
+ * `MLV_EDITOR_AI_PROVIDER` injection token; the input wins, mirroring the
+ * image-uploader precedence rule.
+ */
+interface MlvEditorAiProvider {
+    /**
+     * Streams the result of one request as plain Markdown/text chunks.
+     *
+     * Non-streaming transports may return a single-chunk iterable. A thrown
+     * error or rejected iteration surfaces as a recoverable `'ai-transport'`
+     * editor error; unusable output surfaces as `'ai-result'`.
+     *
+     * @param request Structured transform or autocomplete request.
+     * @returns Async iterable of Markdown/text chunks in document order.
+     */
+    stream(request: MlvEditorAiRequest): AsyncIterable<string>;
+}
+
+/**
+ * Builds the seven built-in AI menu actions, labelled from the supplied
+ * editor copy.
+ *
+ * This is the exact list `MlvEditorAiMenu` renders when its `actions` input is
+ * omitted, so a host that wants to *extend* rather than replace the built-ins
+ * spreads the result instead of retyping it:
+ *
+ * ```ts
+ * private readonly _copy = inject(MLV_EDITOR_I18N, { optional: true });
+ *
+ * readonly actions = computed<readonly MlvEditorAiAction[]>(() => [
+ *   ...mlvEditorAiDefaultActions(this._copy?.()),
+ *   { kind: 'legal-review', label: 'Legal review', output: 'review' },
+ * ]);
+ * ```
+ *
+ * The custom-prompt entry is not part of this list: the menu renders it
+ * separately and it is dropped with `showCustomPrompt="false"`.
+ *
+ * @param copy Resolved editor copy, typically `inject(MLV_EDITOR_I18N)()`.
+ *   `null`/`undefined`, or any missing key, falls back to the English label.
+ * @returns A fresh array of the seven built-in actions, in menu order.
+ */
+declare function mlvEditorAiDefaultActions(copy: MlvEditorI18n | null | undefined): readonly MlvEditorAiAction[];
+
+/**
+ * Toolbar command group for the editor's AI transforms.
+ *
+ * A sparkles trigger opens a Malva menu with one item per action; an action
+ * runs its kind through the context with `output: 'replace-selection'` unless
+ * it says otherwise, while the custom-prompt item opens a Malva popup with an
+ * instruction field and an output-mode choice (replace selection, insert
+ * below, or land as reviewable suggestions). While a transform is running the
+ * same trigger becomes a stop affordance that cancels the in-flight request,
+ * so the control stays one roving tab stop throughout.
+ *
+ * The action list is a thin layer over {@link MlvEditorAiContext.runTransform}:
+ * the seven built-in kinds are only the default. `actions` replaces them
+ * literally with a host-authored list — any kind string, a fixed instruction,
+ * a per-action output mode, or an own `run` callback — and
+ * `showCustomPrompt="false"` drops the custom-prompt item and its popup.
+ *
+ * The group hides entirely when the nearest {@link MLV_EDITOR_AI_CONTEXT}
+ * resolves no provider (presence), and its actions disable — without hiding —
+ * while the editor is readonly or disabled or a transform is already running
+ * (executability), matching the toolbar's presence-vs-executability rule.
+ */
+declare class MlvEditorAiMenu {
+    /**
+     * The menu's action list, replacing the built-in kinds literally — the
+     * house rule for list-shaped inputs (`extensions`, the toolbar definitions):
+     * a supplied array is never merged with the defaults.
+     *
+     * Omitted (the default), the menu renders the seven built-in transforms
+     * labelled from `MLV_EDITOR_I18N`. To keep them and add to them, spread
+     * `mlvEditorAiDefaultActions(copy)` — the very list this component uses.
+     * The custom-prompt item is independent of this input; drop it with
+     * {@link showCustomPrompt}.
+     */
+    readonly actions: _angular_core.InputSignal<readonly MlvEditorAiAction[] | undefined>;
+    /**
+     * Whether the built-in custom-prompt item and its popup exist at all.
+     *
+     * `false` removes the menu item and never renders the prompt popup, for
+     * hosts whose action list already covers everything they want offered.
+     */
+    readonly showCustomPrompt: _angular_core.InputSignalWithTransform<BooleanInput, string | boolean>;
+    /** @protected AI command state of the nearest editor, if provided. */
+    protected readonly _ai: _malva_ui_editor.MlvEditorAiContext | null;
+    /** @protected Editor-scoped form state gating executability. */
+    protected readonly _context: _malva_ui_editor.MlvEditorToolbarContext;
+    /** @private Detached panel ownership for composite focus. */
+    private readonly _overlays;
+    /** @private Document used to resolve the public menu panel id. */
+    private readonly _document;
+    /** @private Cleans an active menu-overlay registration. */
+    private readonly _destroyRef;
+    /** @private Optional localized editor copy. */
+    private readonly _i18n;
+    /** @protected Rendered Malva transforms menu. */
+    protected readonly _menu: Signal<MlvMenu<_malva_ui_core_menu.MlvMenuItemData<unknown>>>;
+    /** @protected Trigger owning the menu overlay. */
+    protected readonly _menuTrigger: Signal<MlvMenuTrigger>;
+    /**
+     * @protected Custom-prompt popup opened programmatically. Optional because
+     * `showCustomPrompt="false"` removes it from the template entirely.
+     */
+    protected readonly _popup: Signal<MlvPopup | undefined>;
+    /** @protected Native trigger restored after popup teardown. */
+    protected readonly _triggerElement: Signal<ElementRef<HTMLButtonElement>>;
+    /** @protected Instruction field focused when the prompt opens. */
+    protected readonly _instructionInput: Signal<MlvInput>;
+    /** @private Detached prompt panel queried through Angular rather than selectors. */
+    private readonly _panel;
+    /** @protected Custom-prompt instruction draft, retained across opens. */
+    protected readonly _instruction: _angular_core.WritableSignal<string>;
+    /** @protected Output mode applied to the custom transform. */
+    protected readonly _output: _angular_core.WritableSignal<MlvEditorAiOutputMode>;
+    /** @private Menu-overlay registration teardown. */
+    private _unregisterMenu;
+    /** @private Guards queued menu registration after a quick close or destroy. */
+    private _menuOpen;
+    /**
+     * @protected Action entries rendered before the custom-prompt item: the
+     * host's list when supplied, otherwise the localized built-ins. The factory
+     * is the single source of the built-in label table.
+     */
+    protected readonly _actions: Signal<readonly MlvEditorAiAction[]>;
+    /** @protected Reactive localized copy for the trigger and prompt. */
+    protected readonly _copy: Signal<{
+        aiMenu: string;
+        aiCustom: string;
+        aiPromptPlaceholder: string;
+        aiOutputMode: string;
+        aiReplaceSelection: string;
+        aiInsertBelow: string;
+        aiReviewChanges: string;
+        aiApply: string;
+        aiCancel: string;
+    }>;
+    /** @protected Whether an AI provider is resolvable; the group hides without one. */
+    protected readonly _hasProvider: Signal<boolean>;
+    /** @protected Whether a transform is streaming, swapping the trigger to stop. */
+    protected readonly _running: Signal<boolean>;
+    /** @protected Whether readonly/disabled state blocks every AI mutation. */
+    protected readonly _disabled: Signal<boolean>;
+    /** @protected Whether menu items cannot currently start a transform. */
+    protected readonly _itemsDisabled: Signal<boolean>;
+    /** @protected Whether the apply action cannot submit the custom prompt. */
+    protected readonly _applyDisabled: Signal<boolean>;
+    constructor();
+    /** @protected Stops the running transform; the menu trigger opens otherwise. */
+    protected _onTriggerClick(): void;
+    /**
+     * @protected Runs one action: its own `run` callback when it has one,
+     * otherwise its kind through the context with the action's instruction and
+     * output mode. The executability guard is re-checked here so a host `run`
+     * callback cannot fire on a readonly, disabled, or busy editor either.
+     */
+    protected _runAction(action: MlvEditorAiAction): void;
+    /** @protected Opens the custom-prompt popup from its menu item. */
+    protected _openPrompt(): void;
+    /** @protected Closes the custom-prompt popup without running a transform. */
+    protected _closePrompt(): void;
+    /** @protected Runs the custom transform with the drafted instruction and mode. */
+    protected _apply(): void;
+    /** @protected Focuses and selects the instruction draft once the prompt opens. */
+    protected _onPromptOpened(): void;
+    /** @protected Restores the connected toolbar trigger after final teardown. */
+    protected _onPromptClosed(): void;
+    /** @protected Narrows the radio group's untyped value to an output mode. */
+    protected _onOutputChange(value: unknown): void;
+    /** @protected Registers the portaled menu panel with the editor composite. */
+    protected _registerMenuOverlay(): void;
+    /** @protected Removes menu panel focus ownership after close. */
+    protected _unregisterMenuOverlay(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvEditorAiMenu, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MlvEditorAiMenu, "mlv-editor-ai-menu", never, { "actions": { "alias": "actions"; "required": false; "isSignal": true; }; "showCustomPrompt": { "alias": "showCustomPrompt"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Review surface for pending AI suggestions.
+ *
+ * Rendered inside the editor composite — hosts project it into the status
+ * region (`<mlv-editor-ai-review-bar mlvEditorStatus />`), following the
+ * `MlvEditorStatus` placement. Hidden while the nearest
+ * {@link MLV_EDITOR_AI_CONTEXT} is `'idle'` (or absent); while `'running'` it
+ * shows a stop affordance that cancels the in-flight request, and while
+ * `'reviewing'` it shows the pending-suggestion count, previous/next
+ * navigation, accept/reject for the current suggestion, and accept-all/
+ * reject-all.
+ *
+ * Navigation keeps an internal cursor over the context's suggestion list;
+ * moving it outlines the current suggestion in the document
+ * (`MLV_EDITOR_AI_SUGGESTION_CURRENT_CLASS` decoration) and scrolls its range
+ * into view through {@link MlvEditorAiContext.revealSuggestion}. Accepting or
+ * rejecting the current suggestion advances to the next remaining one (the
+ * list shrinks under a clamped cursor); when the set empties the context
+ * returns to `'idle'` and the bar disappears.
+ *
+ * Announcement choice: the count region is deliberately **not** an
+ * `aria-live` region. The AI context already announces the review lifecycle —
+ * `aiReviewStarted` with the count, and every accept/reject outcome — through
+ * the CDK `LiveAnnouncer`; a live count would double-announce each change.
+ *
+ * The host element registers with the editor's composite-overlay registry, so
+ * interacting with the bar never emits a false editor blur wherever a host
+ * renders it. All controls are plain tab stops inside the composite. Accept,
+ * reject, and navigation disable while the editor is readonly or disabled
+ * (mutations are refused by the context anyway; the disabled state makes the
+ * refusal visible), and the whole bar disables with the editor.
+ */
+declare class MlvEditorAiReviewBar {
+    /** @protected AI command state of the nearest editor, if provided. */
+    protected readonly _ai: _malva_ui_editor.MlvEditorAiContext | null;
+    /** @protected Editor-scoped form state gating executability. */
+    protected readonly _context: _malva_ui_editor.MlvEditorToolbarContext;
+    /** @private Composite focus ownership for the bar's host element. */
+    private readonly _overlays;
+    /** @private Host element registered with the composite-overlay registry. */
+    private readonly _host;
+    /** @private Clears the current-suggestion outline on teardown. */
+    private readonly _destroyRef;
+    /** @private Optional localized editor copy. */
+    private readonly _i18n;
+    /** @private Resolves the ICU pending-count template. */
+    private readonly _resolver;
+    /**
+     * @private Navigation cursor over the suggestion list. Reset for every new
+     * review; reads clamp through {@link _index}, so a cursor left beyond the
+     * end after the list shrinks points at the last remaining suggestion.
+     */
+    private readonly _cursor;
+    /** @protected Reactive localized copy for every control and the count. */
+    protected readonly _copy: _angular_core.Signal<{
+        aiReviewBar: string;
+        aiReviewCount: string;
+        aiPreviousSuggestion: string;
+        aiNextSuggestion: string;
+        aiAcceptSuggestion: string;
+        aiRejectSuggestion: string;
+        aiAcceptAll: string;
+        aiRejectAll: string;
+        aiStopGeneration: string;
+    }>;
+    /** @protected Whether a transform is streaming, showing the stop affordance. */
+    protected readonly _running: _angular_core.Signal<boolean>;
+    /** @protected Whether a review with pending suggestions is active. */
+    protected readonly _reviewing: _angular_core.Signal<boolean>;
+    /** @protected The bar renders only while AI work is running or under review. */
+    protected readonly _visible: _angular_core.Signal<boolean>;
+    /** @protected Whether readonly/disabled state blocks every AI action. */
+    protected readonly _disabled: _angular_core.Signal<boolean>;
+    /** @protected Pending suggestions mirrored from the AI context. */
+    protected readonly _suggestions: _angular_core.Signal<readonly _malva_ui_editor.MlvEditorAiReviewSuggestion[]>;
+    /** @protected Pending-suggestion count shown in the bar. */
+    protected readonly _count: _angular_core.Signal<number>;
+    /** @protected Clamped cursor index of the current suggestion. */
+    protected readonly _index: _angular_core.Signal<number>;
+    /** @private Identifier of the current suggestion, if any is pending. */
+    private readonly _currentId;
+    /**
+     * @protected Id of the visually hidden current-suggestion description
+     * element the accept/reject buttons reference through `aria-describedby`.
+     * Unique per bar instance so multiple editors on one page cannot collide.
+     */
+    protected readonly _descriptionId: string;
+    /**
+     * @protected Non-visual description of the current suggestion — index,
+     * count, and the removed/added text — from
+     * {@link MlvEditorAiContext.describeSuggestion}. The removed text otherwise
+     * exists only inside the `aria-hidden` strikethrough widget, so this is
+     * what makes the accept/reject decision inspectable without sight.
+     */
+    protected readonly _currentDescription: _angular_core.Signal<string>;
+    /** @protected Localized pending count resolved through the ICU template. */
+    protected readonly _countText: _angular_core.Signal<string>;
+    constructor();
+    /** @protected Cancels the in-flight AI request from the stop affordance. */
+    protected _stop(): void;
+    /** @protected Moves the cursor to the previous suggestion, wrapping at the start. */
+    protected _previous(): void;
+    /** @protected Moves the cursor to the next suggestion, wrapping at the end. */
+    protected _next(): void;
+    /** @protected Accepts the current suggestion; the clamped cursor advances. */
+    protected _acceptCurrent(): void;
+    /** @protected Rejects the current suggestion; the clamped cursor advances. */
+    protected _rejectCurrent(): void;
+    /** @protected Accepts every pending suggestion. */
+    protected _acceptAll(): void;
+    /** @protected Rejects every pending suggestion. */
+    protected _rejectAll(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvEditorAiReviewBar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MlvEditorAiReviewBar, "mlv-editor-ai-review-bar", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * CSS class of the inline decoration marking the active streaming region.
+ *
+ * The class is applied through a ProseMirror decoration held in plugin state,
+ * never through document content, so it can appear in no HTML, Markdown, or
+ * JSON serialization.
+ */
+declare const MLV_EDITOR_AI_STREAMING_CLASS = "mlv-editor__ai-streaming";
+/**
+ * CSS class of the one-shot inline decoration over each flush's newly
+ * revealed slice of the streaming region.
+ *
+ * Created exactly once per revealed delta and only mapped afterwards — never
+ * rebuilt for old ranges — so a one-shot CSS entrance animation runs once per
+ * chunk and earlier text never re-animates. Removed with the region
+ * decoration on commit, cancel, and abandonment, and excluded from every
+ * serialization the same way.
+ */
+declare const MLV_EDITOR_AI_STREAMING_CHUNK_CLASS = "mlv-editor__ai-streaming-chunk";
+/**
+ * CSS class of the `aria-hidden` widget decoration the streaming engine
+ * keeps at the current insertion tip while a writing session is active.
+ *
+ * View-layer only: it exists in no HTML, Markdown, or JSON serialization and
+ * is removed when the session settles (commit, cancel, abandonment, failure).
+ * Collect-only `'review'` sessions never render it — they never write.
+ */
+declare const MLV_EDITOR_AI_CARET_CLASS = "mlv-editor__ai-caret";
+/**
+ * Output modes a streaming session supports.
+ *
+ * `'replace-selection'` and `'insert-below'` write into the document while
+ * streaming. `'review'` is collect-only: the session runs the full lifecycle
+ * — Escape cancellation, external-transaction abandonment, transport/result
+ * error detection — but never writes; the caller routes the accumulated text
+ * through the suggestion engine after commit.
+ */
+type MlvEditorAiStreamOutputMode = MlvEditorAiOutputMode;
+/**
+ * Error categories a streaming session can report.
+ *
+ * `'ai-transport'` — the chunk iterable threw or rejected mid-stream.
+ * `'ai-result'` — the completed stream produced no usable content (empty or
+ * whitespace-only total output), or the target region rejected the write.
+ * Both are narrowed from {@link MlvEditorErrorCode} so hosts can forward them
+ * to `editorError` unchanged.
+ */
+type MlvEditorAiStreamErrorCode = Extract<MlvEditorErrorCode, 'ai-transport' | 'ai-result'>;
+/**
+ * Terminal state of one streaming session.
+ *
+ * `'committed'` — the stream completed and the final content landed as exactly
+ * one history-visible step. `'cancelled'` — {@link MlvEditorAiStreamHandle.cancel}
+ * aborted the session and the checkpoint was restored silently. `'abandoned'`
+ * — an external document change ended the session without any restore.
+ * `'failed'` — the session ended with an {@link MlvEditorAiStreamErrorCode}
+ * and the checkpoint was restored.
+ */
+type MlvEditorAiStreamStatus = 'committed' | 'cancelled' | 'abandoned' | 'failed';
+/**
+ * Schedules one buffered-chunk flush for the next animation frame.
+ *
+ * Receives the flush callback and returns a cancel function. The default
+ * implementation uses `requestAnimationFrame` and falls back to a short
+ * `setTimeout` where no frame API exists (server rendering, test DOMs).
+ * Tests inject a manual scheduler to control flush timing deterministically.
+ */
+type MlvEditorAiFrameScheduler = (flush: () => void) => () => void;
+/** Options accepted by {@link runMlvEditorAiStream}. */
+interface MlvEditorAiStreamOptions {
+    /**
+     * Markdown/text chunks in document order, typically produced by an
+     * `MlvEditorAiProvider`. A non-streaming source may yield a single chunk.
+     */
+    readonly chunks: AsyncIterable<string>;
+    /**
+     * Where the streamed content lands: `'replace-selection'` replaces the
+     * selection captured when the session started, `'insert-below'` streams
+     * into a new paragraph after the selection's top-level block, and
+     * `'review'` collects the complete stream without touching the document —
+     * the result is read from {@link MlvEditorAiStreamResult.text}.
+     */
+    readonly output: MlvEditorAiStreamOutputMode;
+    /** Frame scheduler override; defaults to `requestAnimationFrame`. */
+    readonly scheduler?: MlvEditorAiFrameScheduler;
+    /**
+     * Maximum characters one frame flush reveals into the document. Buffered
+     * text beyond the cap carries over: the session keeps scheduling follow-up
+     * frames until the buffer drains, so bursty provider chunks render at an
+     * even typing cadence instead of appearing in per-chunk lumps. Defaults to
+     * 4; `Infinity` restores the uncapped write-everything-per-frame behavior.
+     * Non-finite values other than `Infinity` and values below 1 fall back to
+     * the default; fractions are floored. The cap never delays settlement —
+     * commit, cancellation, and abandonment still apply the complete
+     * accumulated text immediately. Collect-only `'review'` sessions ignore it
+     * entirely (they never flush).
+     */
+    readonly revealCharsPerFrame?: number;
+}
+/** Terminal result every streaming session resolves with; it never rejects. */
+interface MlvEditorAiStreamResult {
+    /** Terminal state of the session. */
+    readonly status: MlvEditorAiStreamStatus;
+    /** Error category for `'failed'` sessions, `null` for every other status. */
+    readonly error: MlvEditorAiStreamErrorCode | null;
+    /**
+     * Whether the session was stopped before completing: `true` for
+     * `'cancelled'` and `'abandoned'`, `false` for `'committed'` and
+     * `'failed'`. Cancellation and abandonment are silent — neither carries an
+     * error code.
+     */
+    readonly aborted: boolean;
+    /** Complete text accumulated from the stream, including unwritten chunks. */
+    readonly text: string;
+}
+/** Handle controlling one in-flight or finished streaming session. */
+interface MlvEditorAiStreamHandle {
+    /** Resolves with the terminal {@link MlvEditorAiStreamResult}; never rejects. */
+    readonly done: Promise<MlvEditorAiStreamResult>;
+    /**
+     * Aborts an in-flight session: stops consuming chunks, restores the
+     * checkpoint through a history-invisible step, and resolves {@link done}
+     * with `'cancelled'` and no error. A no-op once the session has settled.
+     */
+    cancel(): void;
+    /**
+     * Restores the checkpoint captured when the session started.
+     *
+     * While the session is running this behaves exactly like {@link cancel}.
+     * After the session has settled it replaces the whole document with the
+     * checkpoint in one history-visible step — so a post-commit restore is
+     * itself undoable. Returns whether the document changed; `false` when the
+     * document already matches the checkpoint or the editor was destroyed.
+     * After an `'abandoned'` session this overwrites the external edit too —
+     * callers own that decision.
+     */
+    restoreCheckpoint(): boolean;
+}
+/**
+ * Runs one AI streaming session against a live Tiptap editor.
+ *
+ * Framework-free: the runner needs only the editor instance and an async
+ * iterable of Markdown/text chunks — no Angular, no provider token, no
+ * network. Interim writes render the chunks as plain text inside the target
+ * region; the final commit parses the accumulated Markdown through the
+ * editor's Markdown manager, so the committed document carries real
+ * structure rather than literal Markdown syntax. An editor without a
+ * Markdown manager commits plain text — the same fallback the Angular
+ * context uses for request serialization. The `'review'` output mode is
+ * collect-only: no interim write, no decoration, and no final commit ever
+ * touches the document — a `'committed'` result just carries the complete
+ * text for the caller to route through the suggestion engine. Every other
+ * lifecycle rule below (Escape, cancellation, abandonment, transport and
+ * result errors) applies to it unchanged.
+ *
+ * Lifecycle:
+ *
+ * - A checkpoint (document JSON) and the target coordinates are captured when
+ *   the session starts, before the first mutating step.
+ * - Chunks are buffered and written at most once per animation frame, and
+ *   each flush reveals at most {@link MlvEditorAiStreamOptions.revealCharsPerFrame}
+ *   characters — the remainder carries over to self-scheduled follow-up
+ *   frames, smoothing bursty providers into a steady typing cadence. Every
+ *   interim write dispatches with `addToHistory: false`, so no partial state
+ *   ever becomes an undo step.
+ * - Each flush's newly revealed slice carries a one-shot
+ *   {@link MLV_EDITOR_AI_STREAMING_CHUNK_CLASS} entrance decoration (created
+ *   once, then only mapped), and an `aria-hidden`
+ *   {@link MLV_EDITOR_AI_CARET_CLASS} widget marks the insertion tip while
+ *   the session writes. Both are view-layer decorations: removed when the
+ *   session settles and excluded from every serialization, exactly like the
+ *   region tint.
+ * - On successful completion the session silently reverts to the checkpoint
+ *   and commits the complete content as exactly one history-visible step
+ *   (closed against the previous history group): one undo restores the
+ *   pre-session document.
+ * - {@link MlvEditorAiStreamHandle.cancel} restores the checkpoint and
+ *   resolves with `'cancelled'` — silently, with no error code. Pressing
+ *   Escape inside the content region triggers the same cancellation through
+ *   the session plugin's key handler.
+ * - A thrown or rejected chunk iteration restores the checkpoint and resolves
+ *   `'failed'` with `'ai-transport'`. Empty or whitespace-only total output
+ *   restores the checkpoint and resolves `'failed'` with `'ai-result'`.
+ * - **Abandonment**: any external transaction — one whose root carries no
+ *   session metadata but changes the document (directly or through appended
+ *   transactions) — ends the session immediately following the drag-lifecycle
+ *   precedent. The session stops consuming and writing, removes its
+ *   decoration, and resolves `'abandoned'` with `error: null` and
+ *   `aborted: true`. **Nothing is restored**: inverting the checkpoint
+ *   through foreign steps is unsafe, so the document is left exactly as the
+ *   external edit made it, including any interim session writes (which were
+ *   history-invisible and therefore cannot be undone individually).
+ * - Destroying the editor mid-session settles it as `'abandoned'` without
+ *   touching the DOM.
+ *
+ * The session never throws and {@link MlvEditorAiStreamHandle.done} never
+ * rejects. Starting a new session on an editor cancels the session already
+ * running there.
+ *
+ * @param editor Live Tiptap editor the session writes into.
+ * @param options Chunk source, output mode, and optional frame scheduler.
+ * @returns Handle exposing completion, cancellation, and checkpoint restore.
+ */
+/**
+ * Document region a replacing AI transform writes over.
+ *
+ * A non-empty selection is the region. A **collapsed** selection means the user
+ * asked for the transform without choosing a target — and the provider was
+ * handed the whole document rather than a region (`context.selection` is `null`
+ * exactly when the selection is empty) — so the result lands over the whole
+ * document body: the first text position through the last, never the raw caret.
+ *
+ * Only replacing outputs (`'replace-selection'` streaming, `'review'` applying
+ * its collected result) resolve through here. `'insert-below'` adds a block
+ * after the caret's own top-level block and is unaffected.
+ */
+declare function mlvEditorAiReplaceRange(editor: Editor): {
+    readonly from: number;
+    readonly to: number;
+};
+declare function runMlvEditorAiStream(editor: Editor, options: MlvEditorAiStreamOptions): MlvEditorAiStreamHandle;
+
+/**
+ * Optional dependency-injection token for a host-provided AI transport.
+ *
+ * The per-editor `aiProvider` input wins over this token, mirroring
+ * `MLV_EDITOR_IMAGE_UPLOADER` precedence. Without either, AI UI modules hide
+ * and AI commands are unavailable.
+ */
+declare const MLV_EDITOR_AI_PROVIDER: InjectionToken<MlvEditorAiProvider>;
+
+/**
+ * Editor-scoped command state made available to toolbar and projected controls.
+ *
+ * Commands are deliberately supplied as callbacks so Malva does not conceal
+ * Tiptap's API or constrain third-party extensions.
+ */
+interface MlvEditorToolbarContext {
+    /** The editor instance owned by the nearest editor shell. */
+    readonly editor: Signal<Editor | null>;
+    /** Whether every interactive command surface is disabled. */
+    readonly disabled: Signal<boolean>;
+    /** Whether document mutation commands are unavailable. */
+    readonly readonly: Signal<boolean>;
+    /** Whether focus is currently inside the editor composite. */
+    readonly focused: Signal<boolean>;
+    /** Whether the owner has an editor and permits document mutation. */
+    readonly editable: Signal<boolean>;
+    /** The current serialization format. */
+    readonly format: Signal<MlvEditorFormat>;
+    /** View-only editor zoom percentage. */
+    readonly zoom: WritableSignal<number>;
+    /** Optional editor-owned image upload capability for standalone toolbars. */
+    readonly imageUpload?: MlvEditorImageUploadControl;
+    /** Runs a mutation command without allowing unavailable commands to throw. */
+    run(command: (editor: Editor) => boolean): boolean;
+    /** Checks a command without allowing unavailable commands to throw. */
+    can(command: (editor: Editor) => boolean): boolean;
+    /** Safely reads a Tiptap active state. */
+    isActive(name: string, attributes?: Record<string, unknown>): boolean;
+    /** Reports a typed recoverable error through the owning editor. */
+    reportError(error: MlvEditorError): void;
+}
+/** Injects the command state belonging to the nearest `mlv-editor`. */
+declare const MLV_EDITOR_TOOLBAR_CONTEXT: InjectionToken<MlvEditorToolbarContext>;
+
+/** @internal Template context supplied to replaceable toolbar definitions. */
+interface MlvEditorToolbarTemplateContext {
+    readonly $implicit: MlvEditorToolbarContext;
+}
+/** Complete replacement template for an editor's built-in toolbar. */
+declare class MlvEditorToolbarDef {
+    /** The projected template, whose implicit context is `MlvEditorToolbarContext`. */
+    readonly templateRef: TemplateRef<MlvEditorToolbarTemplateContext> | null;
+    /** Narrows `let-context` to the editor toolbar context. */
+    static ngTemplateContextGuard(_dir: MlvEditorToolbarDef, _context: unknown): _context is MlvEditorToolbarTemplateContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvEditorToolbarDef, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MlvEditorToolbarDef, "[mlvEditorToolbar]", never, {}, {}, never, never, true, never>;
+}
+/** Template rendered before the built-in toolbar groups. */
+declare class MlvEditorToolbarStartDef {
+    /** The projected template, whose implicit context is `MlvEditorToolbarContext`. */
+    readonly templateRef: TemplateRef<MlvEditorToolbarTemplateContext> | null;
+    /** Narrows `let-context` to the editor toolbar context. */
+    static ngTemplateContextGuard(_dir: MlvEditorToolbarStartDef, _context: unknown): _context is MlvEditorToolbarTemplateContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvEditorToolbarStartDef, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MlvEditorToolbarStartDef, "[mlvEditorToolbarStart]", never, {}, {}, never, never, true, never>;
+}
+/** Template rendered after the built-in toolbar groups. */
+declare class MlvEditorToolbarEndDef {
+    /** The projected template, whose implicit context is `MlvEditorToolbarContext`. */
+    readonly templateRef: TemplateRef<MlvEditorToolbarTemplateContext> | null;
+    /** Narrows `let-context` to the editor toolbar context. */
+    static ngTemplateContextGuard(_dir: MlvEditorToolbarEndDef, _context: unknown): _context is MlvEditorToolbarTemplateContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvEditorToolbarEndDef, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MlvEditorToolbarEndDef, "[mlvEditorToolbarEnd]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Browser-only Tiptap form control with nullable HTML, Markdown, or JSON
+ * values.
+ *
+ * The component is a pure Angular `FormValueControl`; it deliberately does
+ * not implement a `ControlValueAccessor` or provide `NG_VALUE_ACCESSOR`.
+ */
+declare class MlvEditor extends MlvSignalFormControlBase<string | null> implements MlvFormControl, AfterViewInit, MlvEditorToolbarContext {
+    /** @private Tiptap instance owned exclusively by this component. */
+    private readonly _editor;
+    /** Nullable editor model used by direct, reactive, template, and signal forms. */
+    readonly value: _angular_core.ModelSignal<string | null>;
+    /** Serialization format for the visual editor. */
+    readonly format: _angular_core.InputSignal<MlvEditorFormat>;
+    /** Width of the centred content column; a gutter is reserved at every value. */
+    readonly contentWidth: _angular_core.InputSignal<MlvEditorContentWidth>;
+    /** Complete Tiptap extension replacement; omit it for Malva's fresh preset. */
+    readonly extensions: _angular_core.InputSignal<Extensions | undefined>;
+    /** Placeholder displayed by the default extension preset. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Maximum character count for Malva's default extension preset. */
+    readonly characterLimit: _angular_core.InputSignal<number | null>;
+    /** IDREF(s) naming the editable content region. */
+    readonly ariaLabelledBy: _angular_core.InputSignal<string | undefined>;
+    /** IDREF(s) describing the editable content region. */
+    readonly ariaDescribedBy: _angular_core.InputSignal<string | undefined>;
+    /** Per-editor image upload adapter, taking precedence over an injected adapter. */
+    readonly imageUploader: _angular_core.InputSignal<MlvEditorImageUploader | undefined>;
+    /** Image upload restrictions used by the later upload controls. */
+    readonly imageUploadOptions: _angular_core.InputSignal<MlvEditorImageUploadOptions>;
+    /**
+     * Per-editor AI transport, taking precedence over an injected
+     * `MLV_EDITOR_AI_PROVIDER`. Without either, AI UI modules hide and AI
+     * commands report a recoverable `configuration` error.
+     */
+    readonly aiProvider: _angular_core.InputSignal<MlvEditorAiProvider | undefined>;
+    /** Read-only signal exposing the one Tiptap editor instance after browser mount. */
+    readonly editor: _angular_core.Signal<Editor | null>;
+    /** Exact editor-owned image upload capability forwarded to public toolbars. */
+    get imageUpload(): MlvEditorImageUploadControl;
+    /** View-only zoom percentage shared with the nearest toolbar. */
+    readonly zoom: _angular_core.WritableSignal<number>;
+    /** Whether the mounted editor currently accepts document mutations. */
+    readonly editable: _angular_core.Signal<boolean>;
+    /** Emits after the browser-only Tiptap editor has been created. */
+    readonly editorReady: _angular_core.OutputEmitterRef<Editor>;
+    /** Emits when focus enters the editable Tiptap content. */
+    readonly focus: _angular_core.OutputEmitterRef<MlvEditorFocusEvent>;
+    /** Emits when focus leaves the editor composite. */
+    readonly blur: _angular_core.OutputEmitterRef<MlvEditorFocusEvent>;
+    /** Emits Tiptap selection updates. */
+    readonly selectionChange: _angular_core.OutputEmitterRef<MlvEditorSelectionChange>;
+    /** Emits every Tiptap transaction. */
+    readonly transaction: _angular_core.OutputEmitterRef<MlvEditorTransactionEvent>;
+    /** Emits recoverable construction, parsing, and serialization errors. */
+    readonly editorError: _angular_core.OutputEmitterRef<MlvEditorError>;
+    /** Emits after an image upload succeeds. */
+    readonly imageUploadSuccess: _angular_core.OutputEmitterRef<MlvEditorImageUploadSuccess>;
+    /** Emits after an image upload fails. */
+    readonly imageUploadFailure: _angular_core.OutputEmitterRef<MlvEditorImageUploadFailure>;
+    /** Emits after an image upload is cancelled. */
+    readonly imageUploadCancelled: _angular_core.OutputEmitterRef<MlvEditorImageUploadCancelled>;
+    /** Whether the nullable model contains meaningful serialized content. */
+    readonly hasValue: _angular_core.Signal<boolean>;
+    /** @private Browser-only mount element for Tiptap's ProseMirror DOM. */
+    private readonly _content;
+    /**
+     * @private Zoom-transformed layer the floating block handle is mounted into.
+     *
+     * Deliberately optional rather than `viewChild.required`: the block-handle
+     * `mount` capability is typed `() => HTMLElement | null`, and the extension
+     * may call it from a ProseMirror plugin view during a user interaction. A
+     * required query throws `NG0951` while unresolved, which would surface as an
+     * uncaught error rather than the absent mount the contract already allows.
+     */
+    private readonly _view;
+    /** @protected Complete projected toolbar replacement, if the consumer provides one. */
+    protected readonly _toolbarDefs: _angular_core.Signal<readonly MlvEditorToolbarDef[]>;
+    /** @protected Projected controls displayed before the built-in toolbar groups. */
+    protected readonly _toolbarStartDefs: _angular_core.Signal<readonly MlvEditorToolbarStartDef[]>;
+    /** @protected Projected controls displayed after the built-in toolbar groups. */
+    protected readonly _toolbarEndDefs: _angular_core.Signal<readonly MlvEditorToolbarEndDef[]>;
+    /** @protected Whether a consumer declared a complete toolbar replacement. */
+    protected readonly _hasToolbarDef: _angular_core.Signal<boolean>;
+    /** @protected Context supplied as the implicit value of projected toolbar templates. */
+    protected readonly _toolbarContext: MlvEditorToolbarContext;
+    /** @private Platform marker used to keep all editor construction out of SSR. */
+    private readonly _isBrowser;
+    /** @private Teardown registration for the browser editor instance. */
+    private readonly _destroyRef;
+    /** @private Registry for overlay roots logically owned by this composite control. */
+    private readonly _overlayRegistry;
+    /** @private Injector used after construction to resolve the editor coordinator safely. */
+    private readonly _injector;
+    /** @private Invalidates built-in command state after Tiptap state changes. */
+    private readonly _toolbarRevision;
+    /** @private Registry of in-flight upload abort callbacks. */
+    private readonly _uploadAbortRegistry;
+    /** @private Physical host used to determine the composite focus boundary. */
+    private readonly _host;
+    /** @private Optional translated accessible defaults. */
+    private readonly _i18n;
+    /** @private Announces block moves politely; the editor content itself is not a live region. */
+    private readonly _liveAnnouncer;
+    /** @private Last external value applied to Tiptap without an update event. */
+    private _lastAppliedValue;
+    /** @private Last value emitted from a user transaction or format conversion. */
+    private _lastEmittedValue;
+    /** @private Active serialization mode for the current editor document. */
+    private _activeFormat;
+    /** @private Guards against duplicate Tiptap teardown. */
+    private _destroyed;
+    /** @private Suppresses document-transaction serialization while applying an external value. */
+    private _applyingExternalValue;
+    /** @private Tracks the disabled edge so overlays/uploads close once per transition. */
+    private _wasDisabled;
+    /** @private Tracks the readonly edge so uploads stop before they can mutate content. */
+    private _wasReadonly;
+    /** @private Text selection retained while ProseMirror is made non-editable. */
+    private _disabledSelection;
+    /** @private Stored marks retained with a collapsed selection while disabled. */
+    private _disabledStoredMarks;
+    /** @private Avoids duplicate queued focus-leave checks. */
+    private _blurCheckQueued;
+    /** @private The last boundary event, retained until the microtask resolves focus ownership. */
+    private _pendingBlurEvent;
+    /** @private Stable capture listener for focus entering the physical host. */
+    private readonly _onHostFocusIn;
+    /** @private Stable capture listener for focus leaving the physical host. */
+    private readonly _onHostFocusOut;
+    /** @private Stable capture listener that blocks disabled projected controls. */
+    private readonly _onDisabledPointerOrClick;
+    /** @private Stable capture listener that blocks disabled keyboard activation. */
+    private readonly _onDisabledKeydown;
+    /** @protected Fallback-accessible name when no visible label is supplied. */
+    protected readonly _resolvedAriaLabel: _angular_core.Signal<string>;
+    /** @protected Descriptions supplied explicitly or by the inherited validation message. */
+    protected readonly _resolvedAriaDescribedBy: _angular_core.Signal<string | undefined>;
+    /** @protected ID used to connect a visible inherited label to ProseMirror. */
+    protected readonly _labelId: _angular_core.Signal<string>;
+    /** @protected Accessible label for the projected toolbar region. */
+    protected readonly _toolbarAriaLabel: _angular_core.Signal<string>;
+    constructor();
+    /** Creates the one Tiptap editor after Angular has rendered the mount element. */
+    ngAfterViewInit(): void;
+    /** Clears the document through Tiptap when the shared form wrapper is clearable. */
+    clearValue(): void;
+    /** @private Formats a completed block move and announces it politely. */
+    private _announceBlockMove;
+    /** @private Whether a browser MIME type matches the current coordinator options. */
+    private _acceptsImageMimeType;
+    /** Runs a Tiptap mutation command when the editor is available and editable. */
+    run(command: (editor: Editor) => boolean): boolean;
+    /** Checks a Tiptap command when the editor is available and editable. */
+    can(command: (editor: Editor) => boolean): boolean;
+    /** Safely reads a Tiptap active state without requiring a particular extension. */
+    isActive(name: string, attributes?: Record<string, unknown>): boolean;
+    /** Reports a typed recoverable error through the owning editor output. */
+    reportError(error: MlvEditorError): void;
+    /** @private Applies the current inputs to the already-created editor instance. */
+    private _synchronizeEditor;
+    /** @private Applies an external value without reflecting it back through `onUpdate`. */
+    private _applyExternalValue;
+    /**
+     * @private Converts one nonempty external value into Tiptap content and
+     * options.
+     *
+     * The branch is exhaustive over every format rather than special-casing one:
+     * HTML is parsed from its own markup, Markdown declares its content type so
+     * the Markdown manager parses it, and JSON is handed over as an
+     * already-parsed document node because Tiptap reads any string argument as
+     * HTML. A rejected JSON value carries its cause instead of a document.
+     */
+    private _prepareContent;
+    /**
+     * @private Construction options mounting an empty document for one format.
+     *
+     * Tiptap is always constructed against an empty document so every real
+     * value travels the same strict parsing path. Markdown still declares its
+     * content type here because the Markdown manager validates that declaration
+     * against the supplied content before the first document is published. HTML
+     * needs no declaration, and JSON never reaches Tiptap as a string at all.
+     */
+    private _emptyDocumentOptions;
+    /** @private Restores the last valid value and reports a recoverable parse failure. */
+    private _recoverFromInvalidValue;
+    /**
+     * @private Serializes an editor transaction and writes only valid distinct
+     * values.
+     *
+     * The distinctness check runs in the serialized format, so a JSON document
+     * that differs from the model only by key order or whitespace is not
+     * re-emitted. An emission therefore follows only a real user transaction or
+     * an explicit format conversion.
+     */
+    private _serializeAndWrite;
+    /**
+     * @private Applies the initial model through the same strict parsing path as
+     * later updates.
+     *
+     * Only Markdown has a capability requirement; HTML and JSON mount against
+     * any valid extension set.
+     */
+    private _applyInitialValue;
+    /** @private Whether the runtime editor exposes Tiptap Markdown serialization. */
+    private _supportsMarkdown;
+    /** @private Emits the stable unsupported-Markdown error without throwing through Angular. */
+    private _emitUnsupportedMarkdownError;
+    /** @private Builds the exact accessible attributes assigned to Tiptap's contenteditable root. */
+    private _editorAttributes;
+    /** @internal Capture handler for focus entering the host or an owned overlay root. */
+    _handleCompositeFocusIn(event: FocusEvent): void;
+    /** @internal Capture handler for focus leaving the host or an owned overlay root. */
+    _handleCompositeFocusOut(event: FocusEvent): void;
+    /** @private Whether the browser's current focus remains in the host or an owned overlay. */
+    private _isFocusInsideComposite;
+    /** @private Whether a node belongs to the physical shell or an owned overlay. */
+    private _isOwnedFocusNode;
+    /** @private Installs native capture listeners because overlay focus is outside Angular's view tree. */
+    private _bindCompositeFocusEvents;
+    /** @private Stops all pointer/click/activation-key command surfaces while disabled. */
+    private _blockDisabledInteraction;
+    /** @private Removes browser focus when the composite becomes disabled without marking it touched. */
+    private _removeCompositeFocusForDisabledState;
+    /** @private Keeps the real ProseMirror root in sync with dynamic ARIA/tabindex state. */
+    private _synchronizeContentSurfaceState;
+    /** @private Aborts registered upload work while preserving the document/editor instance. */
+    private _abortInFlightUploads;
+    /** @private Destroys the owned Tiptap editor exactly once. */
+    private _destroyEditor;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvEditor, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MlvEditor, "mlv-editor", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "contentWidth": { "alias": "contentWidth"; "required": false; "isSignal": true; }; "extensions": { "alias": "extensions"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "characterLimit": { "alias": "characterLimit"; "required": false; "isSignal": true; }; "ariaLabelledBy": { "alias": "ariaLabelledBy"; "required": false; "isSignal": true; }; "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; "isSignal": true; }; "imageUploader": { "alias": "imageUploader"; "required": false; "isSignal": true; }; "imageUploadOptions": { "alias": "imageUploadOptions"; "required": false; "isSignal": true; }; "aiProvider": { "alias": "aiProvider"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "editorReady": "editorReady"; "focus": "focus"; "blur": "blur"; "selectionChange": "selectionChange"; "transaction": "transaction"; "editorError": "editorError"; "imageUploadSuccess": "imageUploadSuccess"; "imageUploadFailure": "imageUploadFailure"; "imageUploadCancelled": "imageUploadCancelled"; }, ["_toolbarDefs", "_toolbarStartDefs", "_toolbarEndDefs"], ["[mlvEditorToolbar]", "[mlvEditorToolbarStart]", "[mlvEditorToolbarEnd]", "[mlvEditorStatus]"], true, never>;
+}
+
+/** A completed block move, reported so the host can announce it. */
+interface MlvEditorBlockMove {
+    /** ProseMirror node type name of the moved block, untranslated. */
+    readonly type: string;
+    /** One-based position the block now occupies among the blocks counted by `total`. */
+    readonly position: number;
+    /**
+     * Top-level block count of the document the move was computed against, i.e.
+     * **before** the move — the same snapshot `position` is derived from. Reading
+     * it after the move instead would announce schema-maintained artifacts the
+     * user never authored: `trailingNode` appends an empty paragraph whenever the
+     * last block is not a textblock, so moving a horizontal rule to the end would
+     * otherwise report "3 of 4".
+     */
+    readonly total: number;
+}
+/** Host-supplied capabilities for the block drag handle. */
+interface MlvEditorBlockHandleOptions {
+    /**
+     * Container the floating handle is appended to. Must be the layer carrying the
+     * editor zoom transform so the handle shares its coordinate space.
+     */
+    readonly mount: () => HTMLElement | null;
+    /** Accessible label for the handle, read live so locale changes apply. */
+    readonly label: () => string;
+    /** Receives every completed move; the host formats and announces it. */
+    readonly announceMove: (move: MlvEditorBlockMove) => void;
+    /** Whether block moving is currently permitted; false while readonly or disabled. */
+    readonly enabled: () => boolean;
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        mlvEditorBlockHandle: {
+            /**
+             * Moves one top-level block. Both indices address the document as it stands
+             * **before** the move, so moving index 0 to index 2 of three blocks yields
+             * the order `[1, 2, 0]`.
+             */
+            moveBlock: (options: {
+                from: number;
+                to: number;
+            }) => ReturnType;
+            /** Moves the top-level block containing the selection one position earlier. */
+            moveBlockUp: () => ReturnType;
+            /** Moves the top-level block containing the selection one position later. */
+            moveBlockDown: () => ReturnType;
+        };
+    }
+}
+/**
+ * Tiptap extension supplying top-level block reordering.
+ *
+ * The pointer handle and the keyboard shortcuts both route through `moveBlock`,
+ * so the two paths cannot drift apart. The handle itself is rendered by this
+ * extension's ProseMirror plugin into the host-supplied mount container and is
+ * never part of the document, so no serialized representation can contain it.
+ */
+declare const MlvEditorBlockHandle: Extension<MlvEditorBlockHandleOptions, any>;
+
+/** A rendered, temporary image-upload placeholder tracked by its stable identifier. */
+interface MlvEditorUploadPlaceholderItem {
+    /** Identifier that associates this placeholder with one upload operation. */
+    readonly id: string;
+    /** Current document position of the placeholder decoration. */
+    readonly position: number;
+    /** Upload progress percentage from 0 through 100. */
+    readonly progress: number;
+}
+/** Options accepted when a temporary upload placeholder is inserted. */
+interface MlvEditorInsertUploadPlaceholderOptions {
+    /** Unique caller-owned identifier for the upload operation. */
+    readonly id: string;
+    /** Optional document position; the current selection is used when omitted. */
+    readonly position?: number;
+    /** Initial upload progress percentage. Defaults to zero. */
+    readonly progress?: number;
+}
+/** Options accepted when an existing upload placeholder is updated. */
+interface MlvEditorUpdateUploadPlaceholderOptions {
+    /** Identifier of the placeholder to update. */
+    readonly id: string;
+    /** New upload progress percentage, clamped to the inclusive 0–100 range. */
+    readonly progress: number;
+}
+/** Options accepted when a temporary upload placeholder is removed. */
+interface MlvEditorRemoveUploadPlaceholderOptions {
+    /** Identifier of the placeholder to remove. */
+    readonly id: string;
+}
+/** Image attributes inserted while atomically removing an upload placeholder. */
+interface MlvEditorReplaceUploadPlaceholderOptions {
+    /** Identifier of the placeholder to replace. */
+    readonly id: string;
+    /** Validated image attributes used to create the final schema node. */
+    readonly attributes: {
+        /** Trimmed image URL. */
+        readonly src: string;
+        /** Optional alternative text. */
+        readonly alt?: string;
+        /** Optional image title. */
+        readonly title?: string;
+        /** Optional finite positive rendered width. */
+        readonly width?: number;
+        /** Optional finite positive rendered height. */
+        readonly height?: number;
+    };
+}
+/** Read-only upload-placeholder state exposed through Tiptap extension storage. */
+interface MlvEditorUploadPlaceholderStorage {
+    /** Current temporary placeholders; decorations, never serializable document nodes. */
+    readonly placeholders: readonly MlvEditorUploadPlaceholderItem[];
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        mlvEditorUploadPlaceholder: {
+            /** Inserts an upload decoration without changing persisted editor content. */
+            insertUploadPlaceholder: (options: MlvEditorInsertUploadPlaceholderOptions) => ReturnType;
+            /** Updates the progress decoration for one pending image upload. */
+            updateUploadPlaceholder: (options: MlvEditorUpdateUploadPlaceholderOptions) => ReturnType;
+            /** Removes the decoration for one completed, failed, or cancelled image upload. */
+            removeUploadPlaceholder: (options: MlvEditorRemoveUploadPlaceholderOptions) => ReturnType;
+            /** Atomically inserts an image at the mapped placeholder and removes it. */
+            replaceUploadPlaceholder: (options: MlvEditorReplaceUploadPlaceholderOptions) => ReturnType;
+        };
+    }
+}
+/**
+ * Tiptap extension that renders image-upload progress outside the document model.
+ *
+ * Its widget decorations are intentionally excluded from HTML and Markdown output,
+ * so a pending upload can never become persisted editor content.
+ */
+declare const MlvEditorUploadPlaceholder: Extension<Record<string, never>, MlvEditorUploadPlaceholderStorage>;
+
+/**
+ * Public Malva wrapper around Tiptap's official free file handling extension.
+ *
+ * The upstream plugin intentionally consumes accepted file-only paste/drop
+ * events. This companion plugin inserts a simultaneous `text/plain` payload
+ * first, then delegates the file interaction exactly once to the upstream
+ * `FileHandlePlugin`. It remains inert for either interaction when the
+ * corresponding callback is not configured, so custom presets can safely
+ * include it before they opt into file handling.
+ */
+declare const MlvEditorFileHandler: Extension<Omit<_tiptap_extension_file_handler.FileHandlePluginOptions, "key" | "editor">, any>;
+/** Options used to configure formatting extensions in a Malva editor preset. */
+interface MlvEditorFormattingExtensionOptions {
+    /** Node types that accept text alignment. Defaults to headings and paragraphs. */
+    readonly textAlignTypes?: readonly string[];
+}
+/** Options used to configure task-list support. */
+interface MlvEditorListExtensionOptions {
+    /** Whether task-list items may be nested. Defaults to false. */
+    readonly nestedTaskItems?: boolean;
+}
+/** Options used to configure table support. */
+interface MlvEditorTableExtensionOptions {
+    /** Whether users can resize table columns. Defaults to true. */
+    readonly resizable?: boolean;
+}
+/** A pasted or dropped file event passed from Tiptap to the editor upload coordinator. */
+interface MlvEditorFileHandlerEvent {
+    /** Editor that received the file event. */
+    readonly editor: Editor;
+    /** Files selected by the browser paste or drop event. */
+    readonly files: readonly File[];
+    /** Origin of the image files. */
+    readonly source: Exclude<MlvEditorImageUploadSource, 'button'>;
+    /** Document position at which files were dropped, when applicable. */
+    readonly position?: number;
+    /** HTML clipboard content accompanying pasted files, when available. */
+    readonly pasteContent?: string;
+}
+/** Options used to configure the image and file-handler extensions. */
+interface MlvEditorImageExtensionOptions {
+    /** Whether image node resizing is enabled. Defaults to true. */
+    readonly resizable?: boolean;
+    /**
+     * Smallest width, in CSS pixels, a resized image may be dragged to.
+     * Defaults to 8. Must be a finite number: an undefined minimum leaves
+     * Tiptap's resize arithmetic producing `NaN` and silently disables resizing.
+     */
+    readonly minWidth?: number;
+    /** Smallest height, in CSS pixels, a resized image may be dragged to. Defaults to 8. */
+    readonly minHeight?: number;
+    /** MIME types forwarded to Tiptap's file handler. */
+    readonly allowedMimeTypes?: readonly string[];
+    /** Runtime guard applied before Tiptap consumes a matching file event. */
+    readonly fileHandlingEnabled?: () => boolean;
+    /** Optional runtime MIME decision used for editor-scoped upload options. */
+    readonly acceptsMimeType?: (mimeType: string) => boolean;
+    /** Callback invoked for pasted and dropped files. */
+    readonly onFiles?: (event: MlvEditorFileHandlerEvent) => void;
+}
+/** Options used to configure editor utility extensions. */
+interface MlvEditorUtilityExtensionOptions {
+    /** Placeholder text shown for an empty editor. */
+    readonly placeholder?: string;
+    /** Maximum character count, or null for no limit. */
+    readonly characterLimit?: number | null;
+}
+/**
+ * Counts words using every Unicode whitespace separator as a boundary.
+ *
+ * @param text Plain editor text.
+ * @returns The deterministic number of non-empty words.
+ */
+declare function countMlvEditorWords(text: string): number;
+/**
+ * Normalizes a character limit to a positive finite integer.
+ *
+ * @param limit Candidate limit.
+ * @returns The usable limit, or `null` for unlimited content.
+ */
+declare function normalizeMlvEditorCharacterLimit(limit: number | null | undefined): number | null;
+/** Options used to configure the beta Markdown extension. */
+interface MlvEditorMarkdownExtensionOptions {
+    /** Indentation used by Markdown lists and code blocks. */
+    readonly indentation?: {
+        /** Use spaces or tabs for indentation. */
+        readonly style?: 'space' | 'tab';
+        /** Number of indentation characters per nesting level. */
+        readonly size?: number;
+    };
+}
+/** Aggregate options accepted by the standard Malva editor extension preset. */
+interface MlvEditorDefaultExtensionOptions extends MlvEditorFormattingExtensionOptions, MlvEditorListExtensionOptions, MlvEditorTableExtensionOptions, MlvEditorImageExtensionOptions, MlvEditorUtilityExtensionOptions, MlvEditorMarkdownExtensionOptions {
+    /** Serialization format; Markdown support is added only for `markdown`. */
+    readonly format?: MlvEditorFormat;
+    /** Host capabilities for the block drag handle. */
+    readonly blockHandle?: Partial<MlvEditorBlockHandleOptions>;
+}
+/**
+ * Creates the core formatting extensions used by the default Malva preset.
+ *
+ * @param options Optional text-alignment configuration.
+ * @returns Fresh Tiptap extension instances safe to compose into one editor.
+ */
+declare function mlvEditorFormattingExtensions(options?: MlvEditorFormattingExtensionOptions): Extensions;
+/**
+ * Creates task-list extensions. Bullet and ordered lists remain supplied by StarterKit.
+ *
+ * @param options Optional task-item nesting configuration.
+ * @returns Fresh task-list extension instances.
+ */
+declare function mlvEditorListExtensions(options?: MlvEditorListExtensionOptions): Extensions;
+/**
+ * Creates the free Tiptap table kit.
+ *
+ * @param options Optional table resize configuration.
+ * @returns A fresh configured table-kit extension.
+ */
+declare function mlvEditorTableExtensions(options?: MlvEditorTableExtensionOptions): Extensions;
+/**
+ * Creates the image and paste/drop file-handler extensions.
+ *
+ * @param options Optional image resize, MIME-type, and file callback configuration.
+ * @returns Fresh image and file-handler extension instances.
+ */
+declare function mlvEditorImageExtensions(options?: MlvEditorImageExtensionOptions): Extensions;
+/**
+ * Creates placeholder and character-count utility extensions.
+ *
+ * @param options Optional placeholder text and character limit.
+ * @returns Fresh utility extension instances.
+ */
+declare function mlvEditorUtilityExtensions(options?: MlvEditorUtilityExtensionOptions): Extensions;
+/**
+ * Creates the block drag-handle extension.
+ *
+ * Every option is host-supplied. Omitting them yields an inert handle that never
+ * mounts, which is what a bare `mlvEditorDefaultExtensions()` call outside the
+ * `MlvEditor` shell should produce.
+ *
+ * @param options Optional host capabilities for mounting, labelling, and announcing.
+ * @returns A fresh configured block-handle extension.
+ */
+declare function mlvEditorBlockHandleExtensions(options?: Partial<MlvEditorBlockHandleOptions>): Extensions;
+/**
+ * Creates the official beta Tiptap Markdown extension.
+ *
+ * @param options Optional Markdown indentation configuration.
+ * @returns A fresh Markdown extension instance.
+ */
+declare function mlvEditorMarkdownExtensions(options?: MlvEditorMarkdownExtensionOptions): Extensions;
+/**
+ * Creates Malva's complete default extension preset.
+ *
+ * Every call creates new arrays and extension instances. Passing a custom extension
+ * list to the editor shell intentionally replaces this preset instead of extending it.
+ *
+ * @param options Optional preset configuration.
+ * @returns A duplicate-free extension set for one new Tiptap editor instance.
+ */
+declare function mlvEditorDefaultExtensions(options?: MlvEditorDefaultExtensionOptions): Extensions;
+
+/** Public character and word summary for the nearest editor context. */
+declare class MlvEditorStatus {
+    /** Optional maximum character count; invalid values mean unlimited. */
+    readonly characterLimit: _angular_core.InputSignal<number | null>;
+    /** Current character count, or zero when CharacterCount is unavailable. */
+    readonly characters: _angular_core.Signal<number>;
+    /** Current Unicode-whitespace-aware word count. */
+    readonly words: _angular_core.Signal<number>;
+    /** Whether the active extension set exposes CharacterCount storage. */
+    readonly available: _angular_core.Signal<boolean>;
+    /** @protected Normalized limit displayed by the summary. */
+    protected readonly _limit: _angular_core.Signal<number | null>;
+    /** @protected Accessible count and remaining-limit description. */
+    protected readonly _ariaLabel: _angular_core.Signal<string>;
+    /** @private Nearest public editor command context. */
+    private readonly _context;
+    /** @private Invalidates storage reads after transactions and selections. */
+    private readonly _revision;
+    /** @private Safely resolves optional Tiptap CharacterCount storage. */
+    private readonly _storage;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvEditorStatus, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MlvEditorStatus, "mlv-editor-status", never, { "characterLimit": { "alias": "characterLimit"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Left, center, right, and justified paragraph alignment commands in a menu. */
+declare class MlvEditorAlignment {
+    /** @protected Editor command state. */
+    protected readonly _context: _malva_ui_editor.MlvEditorToolbarContext;
+    /** @private Per-editor state invalidation signal. */
+    private readonly _revision;
+    /** @private The editor-owned overlay registry. */
+    private readonly _overlays;
+    /** @private Document used to resolve the public menu panel id. */
+    private readonly _document;
+    /** @private Removes a pending or active overlay registration. */
+    private readonly _destroyRef;
+    /** @private Optional localized editor copy. */
+    private readonly _i18n;
+    /** @protected Rendered Malva menu. */
+    protected readonly _menu: _angular_core.Signal<MlvMenu<_malva_ui_core_menu.MlvMenuItemData<unknown>>>;
+    /** @protected Trigger owning the menu overlay. */
+    protected readonly _trigger: _angular_core.Signal<MlvMenuTrigger>;
+    /** @private Tears down the active panel registration. */
+    private _unregister;
+    /** @private Guards queued registration after a quick close or destroy. */
+    private _menuOpen;
+    /** @protected Supported alignments in visual order. */
+    protected readonly _alignments: readonly ["left", "center", "right", "justify"];
+    /** @protected Resolved localized copy. */
+    protected _copy(): {
+        alignment: string;
+        left: string;
+        center: string;
+        right: string;
+        justify: string;
+    };
+    constructor();
+    /** @protected Resolves a translated alignment label. */
+    protected _label(alignment: (typeof this._alignments)[number]): string;
+    /** @protected Current alignment, with left as the semantic default. */
+    protected _activeAlignment(): (typeof this._alignments)[number];
+    /** @protected Whether the current selection has this alignment. */
+    protected _isActive(alignment: (typeof this._alignments)[number]): boolean;
+    /** @protected Whether alignment is registered by the active extension set. */
+    protected _supported(): boolean;
+    /** @protected Whether the menu trigger cannot be opened. */
+    protected _triggerDisabled(): boolean;
+    /** @protected Whether an alignment cannot be applied at the current selection. */
+    protected _disabled(alignment: (typeof this._alignments)[number]): boolean;
+    /** @private Checks whether alignment can be applied without changing focus or selection. */
+    private _canAlign;
+    /** @protected Alignment command factory. */
+    protected _align(alignment: (typeof this._alignments)[number]): (editor: Editor) => boolean;
+    /** @protected Runs a selection-restoring alignment command. */
+    protected _run(alignment: (typeof this._alignments)[number]): void;
+    /** @protected Registers the portaled panel as editor-owned focus. */
+    protected _registerOverlay(): void;
+    /** @protected Removes menu-panel focus ownership after close. */
+    protected _unregisterOverlay(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvEditorAlignment, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MlvEditorAlignment, "mlv-editor-alignment", never, {}, {}, never, never, true, never>;
+}
+
+/** Blockquote and code-block toggles plus horizontal-rule insertion. */
+declare class MlvEditorBlockInsert {
+    /** @protected Editor command state. */ protected readonly _context: _malva_ui_editor.MlvEditorToolbarContext;
+    /** @private Triggers active-state refreshes after editor events. */ private readonly _revision;
+    /** @private Optional localized copy. */ private readonly _i18n;
+    /** @protected Resolved labels. */ protected readonly _copy: _angular_core.Signal<{
+        blockquote: string;
+        codeBlock: string;
+        horizontalRule: string;
+    }>;
+    /** @protected Registered blockquote command. */ protected readonly _canBlockquote: (editor: Editor) => boolean;
+    /** @protected Current blockquote command availability. */ protected readonly _canBlockquoteNow: (editor: Editor) => boolean;
+    /** @protected Registered code-block command. */ protected readonly _canCodeBlock: (editor: Editor) => boolean;
+    /** @protected Current code-block command availability. */ protected readonly _canCodeBlockNow: (editor: Editor) => boolean;
+    /** @protected Registered horizontal-rule command. */ protected readonly _canHorizontalRule: (editor: Editor) => boolean;
+    /** @protected Current horizontal-rule command availability. */ protected readonly _canHorizontalRuleNow: (editor: Editor) => boolean;
+    /** @protected Blockquote command. */ protected readonly _blockquote: (editor: Editor) => boolean;
+    /** @protected Code-block command. */ protected readonly _codeBlock: (editor: Editor) => boolean;
+    /** @protected Horizontal-rule command. */ protected readonly _horizontalRule: (editor: Editor) => boolean;
+    /** @protected Reads command state after the toolbar receives an editor update. */
+    protected readonly _isActive: (name: "blockquote" | "codeBlock") => boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvEditorBlockInsert, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MlvEditorBlockInsert, "mlv-editor-block-insert", never, {}, {}, never, never, true, never>;
+}
+
+/** Heading levels supported by Tiptap's standard heading node. */
+type MlvEditorHeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+/** Paragraph and heading-level dropdown commands. */
+declare class MlvEditorHeading {
+    /** Heading levels displayed in the menu; paragraph is always retained. */
+    readonly levels: _angular_core.InputSignal<readonly MlvEditorHeadingLevel[]>;
+    /** @protected Editor command state. */
+    protected readonly _context: _malva_ui_editor.MlvEditorToolbarContext;
+    /** @private Per-editor state invalidation signal. */
+    private readonly _revision;
+    /** @private The editor-owned overlay registry. */
+    private readonly _overlays;
+    /** @private Document used to resolve the public menu panel id. */
+    private readonly _document;
+    /** @private Cleans an active overlay registration. */
+    private readonly _destroyRef;
+    /** @private Optional localized editor copy. */
+    private readonly _i18n;
+    /** @protected Rendered Malva menu. */
+    protected readonly _menu: _angular_core.Signal<MlvMenu<_malva_ui_core_menu.MlvMenuItemData<unknown>>>;
+    /** @protected Trigger owning the menu overlay. */
+    protected readonly _trigger: _angular_core.Signal<MlvMenuTrigger>;
+    /** @private Overlay-registration teardown. */
+    private _unregister;
+    /** @private Guards queued registration after a quick close or destroy. */
+    private _menuOpen;
+    /** @protected Normalized levels supported by the active heading extension. */
+    protected readonly _levels: _angular_core.Signal<readonly MlvEditorHeadingLevel[]>;
+    /** @protected Localized labels. */
+    protected readonly _copy: _angular_core.Signal<{
+        paragraph: string;
+        headingLevel: string;
+    }>;
+    /** @protected Paragraph command availability at the current selection. */
+    protected readonly _canParagraph: (editor: Editor) => boolean;
+    constructor();
+    /**
+     * @protected Heading level under the caret, or `null` on a paragraph. Probes
+     * every level the node supports rather than {@link _levels}: the caret can
+     * land in a heading the menu deliberately omits, and the trigger still has to
+     * report what the block actually is.
+     *
+     * Drives both the trigger glyph and its selected paint. The paint is a class,
+     * not `aria-pressed` — this is a menu button, and its state semantics are
+     * `aria-haspopup`/`aria-expanded` plus the level-bearing accessible name.
+     */
+    protected _activeLevel(): MlvEditorHeadingLevel | null;
+    /** @protected Label describing the active block type. */
+    protected _label(): string;
+    /** @protected Localized heading label. */
+    protected _headingLabel(level: number): string;
+    /** @protected Whether a heading command is registered by the extension set. */
+    protected _supported(): boolean;
+    /** @protected Whether the paragraph command is registered. */
+    protected _hasParagraph(): boolean;
+    /** @protected Whether heading commands are registered. */
+    protected _hasHeading(): boolean;
+    /** @protected Whether the trigger cannot be opened. */
+    protected _triggerDisabled(): boolean;
+    /** @protected Whether one menu action currently cannot mutate the editor. */
+    protected _disabled(command: (editor: Editor) => boolean): boolean;
+    /** @protected Paragraph command. */
+    protected readonly _paragraph: (editor: Editor) => boolean;
+    /** @protected Heading command factory. */
+    protected _heading(level: MlvEditorHeadingLevel): (editor: Editor) => boolean;
+    /** @protected Heading command availability factory. */
+    protected _canHeading(level: MlvEditorHeadingLevel): (editor: Editor) => boolean;
+    /** @protected Runs a selection-restoring command. */
+    protected _run(command: (editor: Editor) => boolean): void;
+    /** @protected Registers the portaled panel with the editor composite. */
+    protected _registerOverlay(): void;
+    /** @protected Removes menu panel focus ownership after close. */
+    protected _unregisterOverlay(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvEditorHeading, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MlvEditorHeading, "mlv-editor-heading", never, { "levels": { "alias": "levels"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface EditorSelectionRange {
+    readonly from: number;
+    readonly to: number;
+}
+/** @internal Shared selection, roving, and overlay lifecycle for colour controls. */
+declare abstract class MlvEditorColorControl {
+    /** @protected Editor-scoped command and state boundary. */
+    protected readonly _context: _malva_ui_editor.MlvEditorToolbarContext;
+    /** @protected Reactive toolbar invalidation state. */
+    protected readonly _revision: _angular_core.Signal<number> | null;
+    /** @protected Public color-picker composition surface. */
+    protected readonly _picker: _angular_core.Signal<MlvColorPickerPopup>;
+    /** @private Editor toolbar roving-focus owner. */
+    private readonly _roving;
+    /** @private Editor composite detached-overlay owner. */
+    private readonly _overlays;
+    /** @private ProseMirror selection retained while focus is inside the picker. */
+    private _selection;
+    constructor();
+    /** @protected Snapshots the document selection at open intent. */
+    protected _onOpenedChange(opened: boolean): void;
+    /** @protected Restores the snapshot and delegates the distinct colour command. */
+    protected _apply(color: string): void;
+    /** @protected Distinct foreground/highlight command policy. */
+    protected abstract _run(editor: Editor, selection: EditorSelectionRange, color: string): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvEditorColorControl, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MlvEditorColorControl, never, never, {}, {}, never, never, true, never>;
+}
+
+/** Background-highlight toolbar control backed by the reusable swatch picker. */
+declare class MlvEditorHighlight extends MlvEditorColorControl {
+    /** @private Optional localized editor labels. */
+    private readonly _i18n;
+    /** @protected Localized accessible trigger and dialog label. */
+    protected readonly _label: _angular_core.Signal<string>;
+    /** @protected Exact command-presence capability without command execution. */
+    protected readonly _supported: _angular_core.Signal<boolean>;
+    /** @protected Active highlight colour rendered by the independent swatch. */
+    protected readonly _activeColor: _angular_core.Signal<string>;
+    /** @protected Applies or clears highlight colour without focusing Tiptap. */
+    protected _run(editor: Editor, selection: {
+        readonly from: number;
+        readonly to: number;
+    }, color: string): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvEditorHighlight, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MlvEditorHighlight, "mlv-editor-highlight", never, {}, {}, never, never, true, never>;
+}
+
+/** Inline bold, italic, strike-through, and underline toggles. */
+declare class MlvEditorInlineMarks {
+    /** @protected Editor command state. */ protected readonly _context: _malva_ui_editor.MlvEditorToolbarContext;
+    /** @private Per-editor state invalidation signal. */ private readonly _revision;
+    /** @private Optional localized copy. */ private readonly _i18n;
+    /** @protected Resolved labels. */ protected readonly _copy: _angular_core.Signal<{
+        bold: string;
+        italic: string;
+        strike: string;
+        underline: string;
+    }>;
+    /** @protected Bold availability. */ protected readonly _canBold: (editor: Editor) => boolean;
+    /** @protected Reads active state after the latest transaction or selection update. */
+    protected _isActive(name: string): boolean;
+    /** @protected Current bold command availability. */ protected readonly _canBoldNow: (editor: Editor) => boolean;
+    /** @protected Italic availability. */ protected readonly _canItalic: (editor: Editor) => boolean;
+    /** @protected Current italic command availability. */ protected readonly _canItalicNow: (editor: Editor) => boolean;
+    /** @protected Strike availability. */ protected readonly _canStrike: (editor: Editor) => boolean;
+    /** @protected Current strike command availability. */ protected readonly _canStrikeNow: (editor: Editor) => boolean;
+    /** @protected Underline availability. */ protected readonly _canUnderline: (editor: Editor) => boolean;
+    /** @protected Current underline command availability. */ protected readonly _canUnderlineNow: (editor: Editor) => boolean;
+    /** @protected Bold command. */ protected readonly _bold: (editor: Editor) => boolean;
+    /** @protected Italic command. */ protected readonly _italic: (editor: Editor) => boolean;
+    /** @protected Strike command. */ protected readonly _strike: (editor: Editor) => boolean;
+    /** @protected Underline command. */ protected readonly _underline: (editor: Editor) => boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvEditorInlineMarks, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MlvEditorInlineMarks, "mlv-editor-inline-marks", never, {}, {}, never, never, true, never>;
+}
+
+/** Bullet, ordered, and task-list toolbar commands in a compact menu. */
+declare class MlvEditorList {
+    /** @protected Editor command state. */
+    protected readonly _context: _malva_ui_editor.MlvEditorToolbarContext;
+    /** @private Per-editor state invalidation signal. */
+    private readonly _revision;
+    /** @private The editor-owned overlay registry. */
+    private readonly _overlays;
+    /** @private Document used to resolve the public menu panel id. */
+    private readonly _document;
+    /** @private Removes a pending or active overlay registration. */
+    private readonly _destroyRef;
+    /** @private Optional localized editor copy. */
+    private readonly _i18n;
+    /** @protected Rendered Malva menu. */
+    protected readonly _menu: _angular_core.Signal<MlvMenu<_malva_ui_core_menu.MlvMenuItemData<unknown>>>;
+    /** @protected Trigger owning the menu overlay. */
+    protected readonly _trigger: _angular_core.Signal<MlvMenuTrigger>;
+    /** @private Tears down the active panel registration. */
+    private _unregister;
+    /** @private Guards queued registration after a quick close or destroy. */
+    private _menuOpen;
+    /** @protected Resolved menu labels. */
+    protected readonly _copy: _angular_core.Signal<{
+        bullet: string;
+        ordered: string;
+        task: string;
+    }>;
+    /** @protected Bullet-list command availability at the current selection. */
+    protected readonly _canBullet: (editor: Editor) => boolean;
+    /** @protected Ordered-list command availability at the current selection. */
+    protected readonly _canOrdered: (editor: Editor) => boolean;
+    /** @protected Task-list command availability at the current selection. */
+    protected readonly _canTask: (editor: Editor) => boolean;
+    /** @protected Bullet-list command. */
+    protected readonly _bullet: (editor: Editor) => boolean;
+    /** @protected Ordered-list command. */
+    protected readonly _ordered: (editor: Editor) => boolean;
+    /** @protected Task-list command. */
+    protected readonly _task: (editor: Editor) => boolean;
+    constructor();
+    /** @protected The list style currently active at the selection. */
+    protected _label(): string;
+    /** @protected Whether one list command is registered by the active extension set. */
+    protected _supported(): boolean;
+    /** @protected Whether the bullet-list command is registered. */
+    protected _hasBullet(): boolean;
+    /** @protected Whether the ordered-list command is registered. */
+    protected _hasOrdered(): boolean;
+    /** @protected Whether the task-list command is registered. */
+    protected _hasTask(): boolean;
+    /** @protected Whether the menu trigger cannot be opened. */
+    protected _triggerDisabled(): boolean;
+    /** @protected Whether an available menu item currently cannot mutate. */
+    protected _disabled(command: (editor: Editor) => boolean): boolean;
+    /** @protected Runs a selection-restoring list command. */
+    protected _run(command: (editor: Editor) => boolean): void;
+    /** @protected Registers the portaled panel as editor-owned focus. */
+    protected _registerOverlay(): void;
+    /** @protected Removes menu-panel focus ownership after close. */
+    protected _unregisterOverlay(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvEditorList, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MlvEditorList, "mlv-editor-list", never, {}, {}, never, never, true, never>;
+}
+
+/** Safe URL and label editor for the active Tiptap link mark. */
+declare class MlvEditorLink {
+    /**
+     * URL schemes accepted by Malva before the active Tiptap Link extension
+     * applies its own configured protocol policy.
+     */
+    readonly allowedProtocols: _angular_core.InputSignal<readonly string[]>;
+    /** @protected Editor-scoped command and form state. */
+    protected readonly _context: _malva_ui_editor.MlvEditorToolbarContext;
+    /** @private Toolbar transaction/selection invalidation state. */
+    private readonly _revision;
+    /** @private Detached panel ownership for composite focus. */
+    private readonly _overlays;
+    /** @private Optional localized editor copy. */
+    private readonly _i18n;
+    /** @protected Popup controller owned by the trigger. */
+    protected readonly _popup: Signal<MlvPopup>;
+    /** @protected Connected trigger controller. */
+    protected readonly _trigger: Signal<MlvPopupTrigger>;
+    /** @protected Native trigger restored after popup teardown. */
+    protected readonly _triggerElement: Signal<ElementRef<HTMLButtonElement>>;
+    /** @protected URL field focused on open. */
+    protected readonly _urlInput: Signal<MlvInput>;
+    /** @private Detached panel queried through Angular rather than selectors. */
+    private readonly _panel;
+    /** @protected URL draft retained when validation fails. */
+    protected readonly _urlDraft: _angular_core.WritableSignal<string>;
+    /** @protected Linked/selected text draft. */
+    protected readonly _textDraft: _angular_core.WritableSignal<string>;
+    /** @protected Whether the link should open in a new browsing context. */
+    protected readonly _newTab: _angular_core.WritableSignal<boolean>;
+    /** @protected Whether the current URL draft failed strict policy. */
+    protected readonly _invalid: _angular_core.WritableSignal<boolean>;
+    /** @protected Whether the currently edited range already carries a link. */
+    protected readonly _canRemove: _angular_core.WritableSignal<boolean>;
+    /** @private Whole mark or selected range retained while focus is detached. */
+    private _selection;
+    /** @protected Reactive localized copy for trigger, fields, and actions. */
+    protected readonly _copy: Signal<{
+        link: string;
+        linkUrl: string;
+        linkText: string;
+        invalidLink: string;
+        openInNewTab: string;
+        applyLink: string;
+        removeLink: string;
+    }>;
+    /** @protected Exact command presence without dispatching a transaction. */
+    protected readonly _supported: Signal<boolean>;
+    /** @protected Link mark state at the retained editor selection. */
+    protected readonly _active: Signal<boolean>;
+    /** @protected Whether readonly/disabled state blocks the complete popup. */
+    protected readonly _disabled: Signal<boolean>;
+    constructor();
+    /** @protected Preloads the active whole-link range or current selection. */
+    protected _onOpened(): void;
+    /** @protected Restores the connected toolbar trigger after final teardown. */
+    protected _onClosed(): void;
+    /** @protected Clears stale validation as the user edits without closing. */
+    protected _onUrlChange(value: string): void;
+    /** @protected Applies an inserted or updated link after both policy checks. */
+    protected _apply(): void;
+    /** @protected Removes only the link mark while retaining its text. */
+    protected _remove(): void;
+    /** @private Preflights Link policy before replacing text and applying attributes. */
+    private _applyToEditor;
+    /** @private Strict scheme allowlist validation before Tiptap's own policy. */
+    private _validateUrl;
+    /** @private Trims, lowercases, and removes trailing colons from the API input. */
+    private _normalizedProtocols;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvEditorLink, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MlvEditorLink, "mlv-editor-link", never, { "allowedProtocols": { "alias": "allowedProtocols"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type MlvEditorImageUploadTerminalReason = 'success' | 'cancelled' | 'lifecycle-abort' | 'removed';
+interface MlvEditorImageUploadTerminalEvent {
+    readonly id: string;
+    readonly reason: MlvEditorImageUploadTerminalReason;
+}
+/** Internal upload coordinator shared by every editor image entry point. */
+interface MlvEditorImageUploadCoordinator extends MlvEditorImageUploadControl {
+    /** Observes explicit terminal transitions synchronously. */
+    onTerminal(listener: (event: MlvEditorImageUploadTerminalEvent) => void): () => void;
+    /** Claims live dialog ownership until the returned release is called. */
+    claimDialogOwnership(id: string): () => void;
+    /** Whether a live dialog owned this upload at the current terminal delivery. */
+    hasDialogOwner(id: string): boolean;
+}
+
+/** Public toolbar entry point for the editor image-upload dialog. */
+declare class MlvEditorImageUpload {
+    /** @protected Editor-scoped command/form state. */
+    protected readonly _context: _malva_ui_editor.MlvEditorToolbarContext;
+    /** @protected Shared upload coordinator for this editor instance. */
+    protected readonly _coordinator: Signal<MlvEditorImageUploadCoordinator | undefined>;
+    /** @private Transaction invalidation for runtime command support. */
+    private readonly _revision;
+    /** @private Malva dialog service used for the one modal surface. */
+    private readonly _dialogs;
+    /** @private Exact child injector passed through to the dialog portal. */
+    private readonly _injector;
+    /** @private Trigger restored by the shared dialog lifecycle. */
+    private readonly _trigger;
+    /** @private Current dialog, preventing duplicate opens. */
+    private _dialogRef;
+    /** @private Component teardown closes any owned dialog. */
+    private readonly _destroyRef;
+    /** @private Optional localized editor copy. */
+    private readonly _i18n;
+    /** @protected Reactive localized trigger copy. */
+    protected readonly _copy: Signal<string>;
+    /** @protected Whether the editor has both required upload commands. */
+    protected readonly _supported: Signal<boolean>;
+    /** @protected Whether the mutation entry point belongs in this toolbar. */
+    protected readonly _visible: Signal<boolean>;
+    /** @protected Whether the visible trigger is currently inert. */
+    protected readonly _disabled: Signal<boolean>;
+    constructor();
+    /** @protected Opens one editor-scoped Malva upload dialog. */
+    protected _open(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvEditorImageUpload, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MlvEditorImageUpload, "mlv-editor-image-upload", never, {}, {}, never, never, true, never>;
+}
+
+interface EditorTableSize {
+    readonly rows: number;
+    readonly cols: number;
+}
+/** Resizable table insertion and contextual command control. */
+declare class MlvEditorTable {
+    /** @protected Editor-scoped command and form state. */
+    protected readonly _context: _malva_ui_editor.MlvEditorToolbarContext;
+    /** @private Normalizes horizontal grid movement for RTL. */
+    private readonly _rtlService;
+    /** @private Transaction and selection invalidation bridge. */
+    private readonly _revision;
+    /** @private Detached popup ownership for composite editor focus. */
+    private readonly _overlays;
+    /** @private Optional localized editor copy. */
+    private readonly _i18n;
+    /** @protected Popup controller owned by the insertion-grid trigger. */
+    protected readonly _popup: Signal<MlvPopup | undefined>;
+    /** @protected Connected insertion-grid popup trigger. */
+    protected readonly _trigger: Signal<MlvPopupTrigger | undefined>;
+    /** @protected Menu holding the in-table commands. */
+    protected readonly _menu: Signal<MlvMenu<_malva_ui_core_menu.MlvMenuItemData<unknown>> | undefined>;
+    /** @protected Connected in-table menu trigger. */
+    protected readonly _menuTrigger: Signal<MlvMenuTrigger | undefined>;
+    /** @protected Native trigger restored after final popup teardown. */
+    protected readonly _triggerElement: Signal<ElementRef<HTMLButtonElement> | undefined>;
+    /** @private Detached popup panel used by the overlay focus registry. */
+    private readonly _panel;
+    /** @protected First contextual action focused when a table popup opens. */
+    protected readonly _firstAction: Signal<ElementRef<HTMLButtonElement> | undefined>;
+    /** @private Native insertion-grid buttons in row-major order. */
+    private readonly _gridCells;
+    /** @protected Fixed row and column choices exposed by the grid. */
+    protected readonly _gridRows: readonly (readonly EditorTableSize[])[];
+    /** @protected Currently selected insertion dimensions. */
+    protected readonly _selectedSize: _angular_core.WritableSignal<EditorTableSize>;
+    /** @protected Whether insertion creates a header first row. */
+    protected readonly _withHeaderRow: _angular_core.WritableSignal<boolean>;
+    /** @protected Reactive localized copy for the trigger and insertion panel. */
+    protected readonly _copy: Signal<{
+        table: string;
+        insertTable: string;
+        addRowBefore: string;
+        addRowAfter: string;
+        deleteRow: string;
+        addColumnBefore: string;
+        addColumnAfter: string;
+        deleteColumn: string;
+        mergeCells: string;
+        splitCell: string;
+        toggleHeaderRow: string;
+        toggleHeaderColumn: string;
+        toggleHeaderCell: string;
+        deleteTable: string;
+    }>;
+    /** @protected Whether the current editor registered table commands. */
+    protected readonly _supported: Signal<boolean>;
+    /** @protected Whether the retained selection is inside a table. */
+    protected readonly _active: Signal<boolean>;
+    /** @protected Whether editor form state blocks the complete control. */
+    protected readonly _disabled: Signal<boolean>;
+    /** @protected Adds a row before the selected cell. */
+    protected readonly _addRowBefore: (editor: Editor) => boolean;
+    /** @protected Adds a row after the selected cell. */
+    protected readonly _addRowAfter: (editor: Editor) => boolean;
+    /** @protected Deletes the selected row. */
+    protected readonly _deleteRow: (editor: Editor) => boolean;
+    /** @protected Adds a column before the selected cell. */
+    protected readonly _addColumnBefore: (editor: Editor) => boolean;
+    /** @protected Adds a column after the selected cell. */
+    protected readonly _addColumnAfter: (editor: Editor) => boolean;
+    /** @protected Deletes the selected column. */
+    protected readonly _deleteColumn: (editor: Editor) => boolean;
+    /** @protected Merges the selected rectangular cell range. */
+    protected readonly _mergeCells: (editor: Editor) => boolean;
+    /** @protected Splits the current merged cell. */
+    protected readonly _splitCell: (editor: Editor) => boolean;
+    /** @protected Toggles header nodes across the first row. */
+    protected readonly _toggleHeaderRow: (editor: Editor) => boolean;
+    /** @protected Toggles header nodes down the first column. */
+    protected readonly _toggleHeaderColumn: (editor: Editor) => boolean;
+    /** @protected Toggles the selected table cell's header node type. */
+    protected readonly _toggleHeaderCell: (editor: Editor) => boolean;
+    /** @protected Deletes the complete active table. */
+    protected readonly _deleteTable: (editor: Editor) => boolean;
+    /** @protected Non-dispatching add-row-before capability check. */
+    protected readonly _canAddRowBefore: (editor: Editor) => boolean;
+    /** @protected Non-dispatching add-row-after capability check. */
+    protected readonly _canAddRowAfter: (editor: Editor) => boolean;
+    /** @protected Non-dispatching delete-row capability check. */
+    protected readonly _canDeleteRow: (editor: Editor) => boolean;
+    /** @protected Non-dispatching add-column-before capability check. */
+    protected readonly _canAddColumnBefore: (editor: Editor) => boolean;
+    /** @protected Non-dispatching add-column-after capability check. */
+    protected readonly _canAddColumnAfter: (editor: Editor) => boolean;
+    /** @protected Non-dispatching delete-column capability check. */
+    protected readonly _canDeleteColumn: (editor: Editor) => boolean;
+    /** @protected Non-dispatching merge capability check. */
+    protected readonly _canMergeCells: (editor: Editor) => boolean;
+    /** @protected Non-dispatching split capability check. */
+    protected readonly _canSplitCell: (editor: Editor) => boolean;
+    /** @protected Non-dispatching header-row capability check. */
+    protected readonly _canToggleHeaderRow: (editor: Editor) => boolean;
+    /** @protected Non-dispatching header-column capability check. */
+    protected readonly _canToggleHeaderColumn: (editor: Editor) => boolean;
+    /** @protected Non-dispatching header-cell capability check. */
+    protected readonly _canToggleHeaderCell: (editor: Editor) => boolean;
+    /** @protected Non-dispatching table-deletion capability check. */
+    protected readonly _canDeleteTable: (editor: Editor) => boolean;
+    constructor();
+    /** @protected Initializes and focuses the default insertion-grid choice. */
+    protected _onOpened(): void;
+    /** @protected Restores the connected toolbar trigger after final teardown. */
+    protected _onClosed(): void;
+    /** @protected Names an exact insertion size from localized table copy. */
+    protected _sizeLabel(size: EditorTableSize): string;
+    /** @protected Whether a grid cell belongs to the selected dimensions. */
+    protected _sizeSelected(size: EditorTableSize): boolean;
+    /** @protected Updates the current pointer/focus-selected dimensions. */
+    protected _selectSize(size: EditorTableSize): void;
+    /** @protected Executes insertion for a selected pointer cell. */
+    protected _insertSize(size: EditorTableSize): void;
+    /**
+     * @protected Whether the caret's cell is already a header cell. Drives the
+     * `aria-current` marker on the header-cell row so the menu says what the
+     * table is, not only what it can become.
+     */
+    protected _isHeaderCell(): boolean;
+    /** @private Overlay-registration teardown for the open command menu. */
+    private _unregisterMenu;
+    /** @private Guards queued registration after a quick close or destroy. */
+    private _menuOpen;
+    /**
+     * @protected Keeps the portalled menu panel inside the editor's composite
+     * focus boundary. The panel exists only once the overlay has rendered, hence
+     * the microtask; `_menuOpen` guards a close that beats it.
+     */
+    protected _registerMenuOverlay(): void;
+    /** @protected Drops the menu's overlay registration. */
+    protected _unregisterMenuOverlay(): void;
+    /** @protected Whether current selection and form state block an action. */
+    protected _commandDisabled(command: (editor: Editor) => boolean): boolean;
+    /** @protected Executes one contextual mutation through the public guard. */
+    protected _run(command: (editor: Editor) => boolean, closeAfter?: boolean): void;
+    /** @protected Handles bounded grid navigation and keyboard insertion. */
+    protected _onGridKeydown(event: KeyboardEvent): void;
+    /** @private Focuses the single row-major button matching selected dimensions. */
+    private _focusSelectedCell;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvEditorTable, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MlvEditorTable, "mlv-editor-table", never, {}, {}, never, never, true, never>;
+}
+
+/** A box in the zoom layer's own unscaled coordinate space. */
+interface MlvEditorTableBox {
+    /** Distance from the layer's top edge, in unscaled pixels. */
+    readonly top: number;
+    /** Distance from the layer's start edge, in unscaled pixels. */
+    readonly left: number;
+    /** Unscaled width. */
+    readonly width: number;
+    /** Unscaled height. */
+    readonly height: number;
+}
+/** Placement of the three grips that address one hovered table cell. */
+interface MlvEditorTableGeometry {
+    /** Grip spanning the hovered row, sitting just outside the table's start edge. */
+    readonly row: MlvEditorTableBox;
+    /** Grip spanning the hovered column, sitting just above the table. */
+    readonly column: MlvEditorTableBox;
+    /** Square grip in the table's start-top corner, addressing the whole table. */
+    readonly corner: MlvEditorTableBox;
+}
+/** Measurements `mlvEditorTableGeometry` derives the grip boxes from. */
+interface MlvEditorTableGeometryInput {
+    /** Viewport rect of the hovered `td`/`th`. */
+    readonly cell: MlvEditorTableBox;
+    /** Viewport rect of the `table` the cell belongs to. */
+    readonly table: MlvEditorTableBox;
+    /** Viewport rect of the positioned zoom layer the grips are appended to. */
+    readonly layer: MlvEditorTableBox;
+    /**
+     * Live scale of that layer. Viewport rects are scaled; the grips are laid out
+     * inside the layer and scale with it, so every measurement is divided back
+     * out exactly once here rather than at each use site.
+     */
+    readonly scale: number;
+    /** Thickness of a grip, already in the layer's unscaled space. */
+    readonly gripSize: number;
+}
+/**
+ * Places the row, column and corner grips for one hovered cell.
+ *
+ * The grips live inside the zoom layer, so they inherit its scale: everything
+ * below is expressed in the layer's unscaled coordinates, and `gripSize` is
+ * subtracted **after** the conversion so a grip keeps the same rendered
+ * thickness at every zoom level.
+ *
+ * @param input Viewport rects for the cell, its table and the layer, plus the
+ * layer scale and the unscaled grip thickness.
+ * @returns Boxes ready to write onto `top` / `left` / `width` / `height`.
+ */
+declare function mlvEditorTableGeometry(input: MlvEditorTableGeometryInput): MlvEditorTableGeometry;
+
+/**
+ * Hover affordances for the table under the pointer: a grip beside the hovered
+ * row, one above the hovered column and one in the table's corner, each opening
+ * the commands scoped to what it points at.
+ *
+ * Pointer-only by design, matching `MlvEditorBlockHandle`: the grips are
+ * `aria-hidden` and never focusable, so the content region stays the single
+ * `role="textbox"` tab stop. Keyboard and assistive-technology users reach the
+ * same commands through `mlv-editor-table` in the toolbar, which acts on the
+ * cell the caret is already in.
+ */
+declare class MlvEditorTableControls {
+    /**
+     * The positioned, zoom-carrying layer the grips are laid out inside. Grips
+     * are placed in its unscaled coordinate space, so they follow the content at
+     * every zoom level without a second transform of their own.
+     */
+    readonly layer: _angular_core.InputSignal<HTMLElement>;
+    /** @protected Editor-scoped command and form state. */
+    protected readonly _context: _malva_ui_editor.MlvEditorToolbarContext;
+    /** @private Transaction and selection invalidation bridge. */
+    private readonly _revision;
+    /** @private Keeps grip menus inside the editor's composite focus boundary. */
+    private readonly _overlays;
+    /** @private Document used to resolve the public menu panel id. */
+    private readonly _document;
+    /** @private Reactive localized copy source. */
+    private readonly _i18n;
+    /**
+     * @private The cell the grips currently address. Held as an element rather
+     * than a document position so a re-measure after a scroll or a zoom change
+     * needs no second `posAtDOM` round trip.
+     */
+    private readonly _cell;
+    /** @protected Placement of the three grips, or null while none are shown. */
+    protected readonly _geometry: _angular_core.WritableSignal<MlvEditorTableGeometry | null>;
+    /**
+     * @private Set while a grip menu is open. The grips must survive the pointer
+     * leaving the table to reach the menu, which is portalled outside it.
+     */
+    private readonly _pinned;
+    /** @private Overlay-registration teardown for the open grip menu. */
+    private _unregister;
+    /** @private Guards queued registration after a quick close or destroy. */
+    private _menuOpen;
+    /** @protected Localized labels for the three grips. */
+    protected readonly _copy: _angular_core.Signal<{
+        rowActions: string;
+        columnActions: string;
+        tableActions: string;
+        addRowBefore: string;
+        addRowAfter: string;
+        deleteRow: string;
+        addColumnBefore: string;
+        addColumnAfter: string;
+        deleteColumn: string;
+        mergeCells: string;
+        splitCell: string;
+        toggleHeaderRow: string;
+        toggleHeaderColumn: string;
+        toggleHeaderCell: string;
+        deleteTable: string;
+    }>;
+    /** @protected Whether the grips may act at all. */
+    protected readonly _enabled: _angular_core.Signal<boolean>;
+    constructor();
+    /** @protected Inline placement for one grip box. */
+    protected _style(box: MlvEditorTableBox): Record<string, string>;
+    /**
+     * @protected Keeps the grips mounted while their menu is open and keeps the
+     * portalled panel inside the editor's composite focus boundary.
+     *
+     * The panel only exists once the overlay has rendered, hence the microtask;
+     * `_menuOpen` guards a close that beats it.
+     */
+    protected _openMenu(menu: MlvMenu): void;
+    /** @protected Releases the pin and re-measures against the current pointer. */
+    protected _closeMenu(): void;
+    /** @private Drops any active overlay registration. */
+    private _unregisterOverlay;
+    /**
+     * @protected Runs one table command against the cell the grip points at.
+     *
+     * The Tiptap table commands all act on the current selection, so the caret is
+     * moved into the grip's own cell first. That is also what makes the grips
+     * honest: the command a user picks from the row grip cannot land on whichever
+     * row the caret happened to be sitting in.
+     */
+    protected _run(command: (editor: Editor) => boolean): void;
+    /** @protected Whether a command is currently unavailable for the grip's cell. */
+    protected _disabled(command: (editor: Editor) => boolean): boolean;
+    /** @protected `addRowBefore` in dispatching form. */
+    protected readonly _addRowBefore: (editor: Editor) => boolean;
+    /** @protected Non-dispatching `addRowBefore` capability check. */
+    protected readonly _canAddRowBefore: (editor: Editor) => boolean;
+    /** @protected `addRowAfter` in dispatching form. */
+    protected readonly _addRowAfter: (editor: Editor) => boolean;
+    /** @protected Non-dispatching `addRowAfter` capability check. */
+    protected readonly _canAddRowAfter: (editor: Editor) => boolean;
+    /** @protected `deleteRow` in dispatching form. */
+    protected readonly _deleteRow: (editor: Editor) => boolean;
+    /** @protected Non-dispatching `deleteRow` capability check. */
+    protected readonly _canDeleteRow: (editor: Editor) => boolean;
+    /** @protected `addColumnBefore` in dispatching form. */
+    protected readonly _addColumnBefore: (editor: Editor) => boolean;
+    /** @protected Non-dispatching `addColumnBefore` capability check. */
+    protected readonly _canAddColumnBefore: (editor: Editor) => boolean;
+    /** @protected `addColumnAfter` in dispatching form. */
+    protected readonly _addColumnAfter: (editor: Editor) => boolean;
+    /** @protected Non-dispatching `addColumnAfter` capability check. */
+    protected readonly _canAddColumnAfter: (editor: Editor) => boolean;
+    /** @protected `deleteColumn` in dispatching form. */
+    protected readonly _deleteColumn: (editor: Editor) => boolean;
+    /** @protected Non-dispatching `deleteColumn` capability check. */
+    protected readonly _canDeleteColumn: (editor: Editor) => boolean;
+    /** @protected `mergeCells` in dispatching form. */
+    protected readonly _mergeCells: (editor: Editor) => boolean;
+    /** @protected Non-dispatching `mergeCells` capability check. */
+    protected readonly _canMergeCells: (editor: Editor) => boolean;
+    /** @protected `splitCell` in dispatching form. */
+    protected readonly _splitCell: (editor: Editor) => boolean;
+    /** @protected Non-dispatching `splitCell` capability check. */
+    protected readonly _canSplitCell: (editor: Editor) => boolean;
+    /** @protected `toggleHeaderRow` in dispatching form. */
+    protected readonly _toggleHeaderRow: (editor: Editor) => boolean;
+    /** @protected Non-dispatching `toggleHeaderRow` capability check. */
+    protected readonly _canToggleHeaderRow: (editor: Editor) => boolean;
+    /** @protected `toggleHeaderColumn` in dispatching form. */
+    protected readonly _toggleHeaderColumn: (editor: Editor) => boolean;
+    /** @protected Non-dispatching `toggleHeaderColumn` capability check. */
+    protected readonly _canToggleHeaderColumn: (editor: Editor) => boolean;
+    /** @protected `toggleHeaderCell` in dispatching form. */
+    protected readonly _toggleHeaderCell: (editor: Editor) => boolean;
+    /** @protected Non-dispatching `toggleHeaderCell` capability check. */
+    protected readonly _canToggleHeaderCell: (editor: Editor) => boolean;
+    /** @protected `deleteTable` in dispatching form. */
+    protected readonly _deleteTable: (editor: Editor) => boolean;
+    /** @protected Non-dispatching `deleteTable` capability check. */
+    protected readonly _canDeleteTable: (editor: Editor) => boolean;
+    /** @private Resolves the cell under the pointer and re-places the grips. */
+    private _track;
+    /** @private Drops the grips. */
+    private _release;
+    /** @private Re-measures the pinned cell against the live layout. */
+    private _measure;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvEditorTableControls, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MlvEditorTableControls, "mlv-editor-table-controls", never, { "layer": { "alias": "layer"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Public compatibility toolbar shell for standalone consumer use. */
+declare class MlvEditorToolbar {
+    /** Accessible toolbar name. */
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /** Whether all toolbar interactions are disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Optional content rendered before built-in groups. */
+    readonly startTemplate: _angular_core.InputSignal<TemplateRef<{
+        $implicit: MlvEditorToolbarContext;
+    }> | null>;
+    /** Optional content rendered after built-in groups. */
+    readonly endTemplate: _angular_core.InputSignal<TemplateRef<{
+        $implicit: MlvEditorToolbarContext;
+    }> | null>;
+    /** Context supplied to custom toolbar templates. */
+    readonly context: _angular_core.InputSignal<MlvEditorToolbarContext>;
+    /** @internal Invalidates built-in command state for the supplied standalone editor. */
+    private readonly _revision;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvEditorToolbar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MlvEditorToolbar, "mlv-editor-toolbar", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "startTemplate": { "alias": "startTemplate"; "required": false; "isSignal": true; }; "endTemplate": { "alias": "endTemplate"; "required": false; "isSignal": true; }; "context": { "alias": "context"; "required": true; "isSignal": true; }; }, {}, never, ["[mlvEditorToolbarStart]", "[mlvEditorToolbarEnd]", "*"], true, never>;
+}
+
+/** Marks a projected or built-in editor control as one editor-toolbar roving widget. */
+declare class MlvEditorToolbarWidget {
+    /** @internal Native widget registered with the enclosing toolbar. */
+    private readonly _element;
+    /** @internal Editor-scoped roving-focus coordinator. */
+    private readonly _registry;
+    /** @internal Widget lifecycle for deregistration. */
+    private readonly _destroyRef;
+    /** @internal Derived tab stop for roving keyboard navigation. */
+    protected readonly _tabIndex: _angular_core.Signal<0 | -1>;
+    constructor();
+    /** @internal Promotes this widget when it receives focus. */
+    protected _activate(): void;
+    /** @internal Promotes this widget before pointer activation. */
+    protected _activateOnPointerDown(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvEditorToolbarWidget, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MlvEditorToolbarWidget, "[mlvEditorToolbarWidget]", never, {}, {}, never, never, true, never>;
+}
+
+/** Undo and redo actions backed by Tiptap history commands. */
+declare class MlvEditorUndoRedo {
+    /** @private Optional localized editor copy. */
+    private readonly _i18n;
+    /** @protected Resolved copy with SSR-safe English fallbacks. */
+    protected readonly _copy: _angular_core.Signal<{
+        undo: string;
+        redo: string;
+    }>;
+    /** @protected Tiptap availability query for undo. */
+    protected readonly _canUndo: (editor: Editor) => boolean;
+    /** @protected Tiptap availability query for redo. */
+    protected readonly _canRedo: (editor: Editor) => boolean;
+    /** @protected Current history availability for undo. */
+    protected readonly _canExecuteUndo: (editor: Editor) => boolean;
+    /** @protected Current history availability for redo. */
+    protected readonly _canExecuteRedo: (editor: Editor) => boolean;
+    /** @protected Selection-restoring undo command. */
+    protected readonly _undo: (editor: Editor) => boolean;
+    /** @protected Selection-restoring redo command. */
+    protected readonly _redo: (editor: Editor) => boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvEditorUndoRedo, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MlvEditorUndoRedo, "mlv-editor-undo-redo", never, {}, {}, never, never, true, never>;
+}
+
+/** View-only editor zoom stepper and preset menu. */
+declare class MlvEditorZoom implements OnChanges {
+    /** Current view-only zoom percentage. */
+    readonly zoom: _angular_core.ModelSignal<number>;
+    /** Preset percentages displayed by the zoom menu. */
+    readonly zoomLevels: _angular_core.InputSignal<readonly number[]>;
+    /** Smallest permitted zoom percentage. */
+    readonly min: _angular_core.InputSignal<number>;
+    /** Largest permitted zoom percentage. */
+    readonly max: _angular_core.InputSignal<number>;
+    /** Recalculates the largest safe zoom whenever the content viewport resizes. */
+    readonly fitToContainer: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** @protected Editor-scoped view and command state. */
+    protected readonly _context: _malva_ui_editor.MlvEditorToolbarContext;
+    /** @private Shared observer abstraction for the editor viewport. */
+    private readonly _resizeObserver;
+    /** @private Component host used to retain a stable focus-restore target. */
+    private readonly _host;
+    /** @private Registry that keeps focus within the editor composite. */
+    private readonly _overlays;
+    /** @private Document used only after a browser menu opens. */
+    private readonly _document;
+    /** @private Component teardown scope. */
+    private readonly _destroyRef;
+    /** @private Prevents browser view access during server rendering. */
+    private readonly _isBrowser;
+    /** @private Optional reactive localized editor copy. */
+    private readonly _i18n;
+    /** @protected Rendered mixed-control popup. */
+    protected readonly _popup: _angular_core.Signal<MlvPopup>;
+    /** @protected Trigger that owns the detached popup. */
+    protected readonly _trigger: _angular_core.Signal<MlvPopupTrigger>;
+    /** @protected Percentage field focused when the popup opens. */
+    protected readonly _input: _angular_core.Signal<MlvInput>;
+    /** @protected Stable id used to resolve this component's detached panel. */
+    protected readonly _panelId: string;
+    /** @private Last synchronized model value. */
+    private _lastZoom;
+    /** @private Last synchronized editor-context value. */
+    private _lastContextZoom;
+    /** @private Distinguishes initial context adoption from later writes. */
+    private _initialized;
+    /** @private Whether Angular assigned the public model, including an explicit default. */
+    private _zoomWasSupplied;
+    /** @private Current detached-popup registration teardown. */
+    private _unregister;
+    /** @private Guards a queued popup registration after close or destroy. */
+    private _menuOpen;
+    /** @private Connected trigger retained while the popup is open. */
+    private _restoreFocusTarget;
+    /** @protected Numeric field draft kept separate until commit. */
+    protected readonly _draft: _angular_core.WritableSignal<string>;
+    /** @protected Normalized inclusive zoom bounds. */
+    protected readonly _bounds: _angular_core.Signal<{
+        min: number;
+        max: number;
+    }>;
+    /** @protected Finite, in-range, sorted menu presets. */
+    protected readonly _presetLevels: _angular_core.Signal<number[]>;
+    /**
+     * @protected Largest panel height in px. Nine presets plus the fit row scroll
+     * inside the panel's own scrollbar rather than growing the popup, so the
+     * percentage field above them stays pinned.
+     */
+    protected readonly _PANEL_MAX_HEIGHT = 240;
+    /** @protected Preset rows rendered by the dropdown panel, fit action last. */
+    protected readonly _levelOptions: _angular_core.Signal<MlvSelectOption<number>[]>;
+    /**
+     * @protected Selected preset, or nothing when the current percentage is a
+     * free-form value (typed in the field, or produced by a fit).
+     */
+    protected readonly _selectedLevels: _angular_core.Signal<number[]>;
+    /** @protected Whether the complete editor composite is disabled. */
+    protected readonly _disabled: _angular_core.Signal<boolean>;
+    /** @protected Reactive localized labels for every zoom surface. */
+    protected readonly _copy: _angular_core.Signal<{
+        zoom: string;
+        zoomOut: string;
+        zoomIn: string;
+        fitToContainer: string;
+    }>;
+    /** @protected Whether decrementing would exceed the lower bound. */
+    protected readonly _zoomOutDisabled: _angular_core.Signal<boolean>;
+    /** @protected Whether incrementing would exceed the upper bound. */
+    protected readonly _zoomInDisabled: _angular_core.Signal<boolean>;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    /** @protected Selects the previous preset or the exact minimum. */
+    protected _zoomOut(): void;
+    /** @protected Selects the next preset or the exact maximum. */
+    protected _zoomIn(): void;
+    /** @protected Applies a menu preset without dispatching an editor transaction. */
+    protected _select(level: number): void;
+    /**
+     * @protected Applies a dropdown row. The aria listbox also emits while it
+     * reconciles its value against the rendered options — which drops a
+     * free-form percentage to an empty array — so only a non-empty emission is a
+     * user pick.
+     */
+    protected _selectLevel(values: readonly number[]): void;
+    /** @protected Commits a finite numeric field value and restores the normalized display. */
+    protected _applyDraft(event?: Event): void;
+    /** @protected Fits against the viewport's latest synchronous width. */
+    protected _fitCurrentViewport(): void;
+    /** @protected Registers the detached dialog and moves focus to its field. */
+    protected _onPopupOpened(): void;
+    /** @protected Releases focus ownership and restores the visible trigger. */
+    protected _onPopupClosed(): void;
+    /** @private Removes detached popup focus ownership without moving focus. */
+    private _releaseOverlay;
+    /** @private Synchronizes the literal public model with the nearest toolbar context. */
+    private _synchronizeZoom;
+    /** @private Ordered stepping levels, including exact configured bounds. */
+    private _steps;
+    /** @private Applies a clamped visual-only percentage to model and context. */
+    private _setZoom;
+    /** @private Calculates the largest integer zoom whose natural content fits. */
+    private _fit;
+    /** @private Clamps a finite percentage to the configured inclusive bounds. */
+    private _clamp;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvEditorZoom, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MlvEditorZoom, "mlv-editor-zoom", never, { "zoom": { "alias": "zoom"; "required": false; "isSignal": true; }; "zoomLevels": { "alias": "zoomLevels"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "fitToContainer": { "alias": "fitToContainer"; "required": false; "isSignal": true; }; }, { "zoom": "zoomChange"; }, never, never, true, never>;
+}
+
+/** Foreground-colour toolbar control backed by the reusable swatch picker. */
+declare class MlvEditorTextColor extends MlvEditorColorControl {
+    /** @private Optional localized editor labels. */
+    private readonly _i18n;
+    /** @protected Localized accessible trigger and dialog label. */
+    protected readonly _label: _angular_core.Signal<string>;
+    /** @protected Exact command-presence capability without command execution. */
+    protected readonly _supported: _angular_core.Signal<boolean>;
+    /** @protected Active foreground colour rendered by the swatch. */
+    protected readonly _activeColor: _angular_core.Signal<string>;
+    /** @protected Applies or clears foreground colour without focusing Tiptap. */
+    protected _run(editor: Editor, selection: {
+        readonly from: number;
+        readonly to: number;
+    }, color: string): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvEditorTextColor, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MlvEditorTextColor, "mlv-editor-text-color", never, {}, {}, never, never, true, never>;
+}
+
+export { MLV_EDITOR_AI_CARET_CLASS, MLV_EDITOR_AI_CONTEXT, MLV_EDITOR_AI_PROVIDER, MLV_EDITOR_AI_STREAMING_CHUNK_CLASS, MLV_EDITOR_AI_STREAMING_CLASS, MLV_EDITOR_AI_SUGGESTION_CURRENT_CLASS, MLV_EDITOR_AI_SUGGESTION_DELETE_CLASS, MLV_EDITOR_AI_SUGGESTION_INSERT_CLASS, MLV_EDITOR_DEFAULT_IMAGE_UPLOAD_OPTIONS, MLV_EDITOR_IMAGE_UPLOADER, MLV_EDITOR_TOOLBAR_CONTEXT, MlvEditor, MlvEditorAiContext, MlvEditorAiMenu, MlvEditorAiReviewBar, MlvEditorAlignment, MlvEditorBlockHandle, MlvEditorBlockInsert, MlvEditorFileHandler, MlvEditorHeading, MlvEditorHighlight, MlvEditorImageUpload, MlvEditorImageUploadControl, MlvEditorInlineMarks, MlvEditorLink, MlvEditorList, MlvEditorStatus, MlvEditorTable, MlvEditorTableControls, MlvEditorTextColor, MlvEditorToolbar, MlvEditorToolbarDef, MlvEditorToolbarEndDef, MlvEditorToolbarStartDef, MlvEditorToolbarWidget, MlvEditorUndoRedo, MlvEditorUploadPlaceholder, MlvEditorZoom, applyMlvEditorAiSuggestions, countMlvEditorWords, mlvEditorAiDefaultActions, mlvEditorAiReplaceRange, mlvEditorBlockHandleExtensions, mlvEditorDefaultExtensions, mlvEditorDefaultImageUrlPolicy, mlvEditorFormattingExtensions, mlvEditorImageExtensions, mlvEditorListExtensions, mlvEditorMarkdownExtensions, mlvEditorTableExtensions, mlvEditorTableGeometry, mlvEditorUtilityExtensions, normalizeMlvEditorCharacterLimit, runMlvEditorAiStream };
+export type { MlvEditorAiAction, MlvEditorAiBuiltInTransformKind, MlvEditorAiFrameScheduler, MlvEditorAiOutputMode, MlvEditorAiProvider, MlvEditorAiRequest, MlvEditorAiReviewSuggestion, MlvEditorAiStatus, MlvEditorAiStreamErrorCode, MlvEditorAiStreamHandle, MlvEditorAiStreamOptions, MlvEditorAiStreamOutputMode, MlvEditorAiStreamResult, MlvEditorAiStreamStatus, MlvEditorAiSuggestion, MlvEditorAiSuggestionKind, MlvEditorAiSuggestionRange, MlvEditorAiSuggestionsOptions, MlvEditorAiSuggestionsSession, MlvEditorAiTransformKind, MlvEditorAiTransformOptions, MlvEditorBlockHandleOptions, MlvEditorBlockMove, MlvEditorContentWidth, MlvEditorDefaultExtensionOptions, MlvEditorError, MlvEditorErrorCode, MlvEditorFileHandlerEvent, MlvEditorFocusEvent, MlvEditorFormat, MlvEditorFormattingExtensionOptions, MlvEditorHeadingLevel, MlvEditorImageExtensionOptions, MlvEditorImageUploadCancelled, MlvEditorImageUploadContext, MlvEditorImageUploadFailure, MlvEditorImageUploadOptions, MlvEditorImageUploadResult, MlvEditorImageUploadSource, MlvEditorImageUploadSuccess, MlvEditorImageUploader, MlvEditorImageUrlPolicy, MlvEditorInsertUploadPlaceholderOptions, MlvEditorListExtensionOptions, MlvEditorMarkdownExtensionOptions, MlvEditorPendingUpload, MlvEditorRemoveUploadPlaceholderOptions, MlvEditorReplaceUploadPlaceholderOptions, MlvEditorSelectionChange, MlvEditorTableBox, MlvEditorTableExtensionOptions, MlvEditorTableGeometry, MlvEditorTableGeometryInput, MlvEditorToolbarContext, MlvEditorTransactionEvent, MlvEditorUpdateUploadPlaceholderOptions, MlvEditorUploadPlaceholderItem, MlvEditorUploadPlaceholderStorage, MlvEditorUtilityExtensionOptions };