@seyamali/aurelia-editor 0.1.0

package/dist/plugins/advanced/asset-link-node.d.ts

@@ -0,0 +1,18 @@
+import { DecoratorNode, NodeKey, SerializedLexicalNode, Spread, DOMConversionMap, DOMExportOutput } from 'lexical';
+export type SerializedAssetLinkNode = Spread<{
+    attributes: Record<string, string>;
+}, SerializedLexicalNode>;
+export declare class AssetLinkNode extends DecoratorNode<HTMLElement> {
+    __attributes: Record<string, string>;
+    static getType(): string;
+    static clone(node: AssetLinkNode): AssetLinkNode;
+    constructor(attributes: Record<string, string>, key?: NodeKey);
+    static importJSON(serializedNode: SerializedAssetLinkNode): AssetLinkNode;
+    exportJSON(): SerializedAssetLinkNode;
+    createDOM(): HTMLElement;
+    updateDOM(): false;
+    decorate(): HTMLElement;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(): DOMExportOutput;
+}
+export declare function $createAssetLinkNode(attributes: Record<string, string>): AssetLinkNode;

package/dist/plugins/advanced/code-block-node.d.ts

@@ -0,0 +1,33 @@
+import { DOMConversionMap, DOMExportOutput, EditorConfig, LexicalNode, NodeKey, SerializedElementNode, Spread } from 'lexical';
+import { CodeNode } from '@lexical/code';
+export type SerializedCodeBlockNode = Spread<{
+    language: string | null;
+    showLineNumbers: boolean;
+}, SerializedElementNode>;
+/**
+ * Enhanced CodeBlockNode with language support, line numbers, and copy functionality
+ */
+export declare class CodeBlockNode extends CodeNode {
+    __language: string | null;
+    __showLineNumbers: boolean;
+    constructor(language?: string | null, showLineNumbers?: boolean, key?: NodeKey);
+    static getType(): string;
+    static clone(node: CodeBlockNode): CodeBlockNode;
+    static importJSON(serializedNode: SerializedCodeBlockNode): CodeBlockNode;
+    exportJSON(): SerializedCodeBlockNode;
+    createDOM(_config: EditorConfig): HTMLElement;
+    updateDOM(prevNode: CodeBlockNode, dom: HTMLElement): boolean;
+    private _ensureDecorations;
+    exportDOM(): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
+    getLanguage(): string | null;
+    setLanguage(language: string | null): this;
+    getShowLineNumbers(): boolean;
+    setShowLineNumbers(show: boolean): void;
+    canInsertTab(): boolean;
+    canIndent(): false;
+    collapseAtStart(): boolean;
+    private copyCode;
+}
+export declare function $createCodeBlockNode(language?: string | null, showLineNumbers?: boolean): CodeBlockNode;
+export declare function $isCodeBlockNode(node: LexicalNode | null | undefined): node is CodeBlockNode;

package/dist/plugins/advanced/code-blocks.d.ts

@@ -0,0 +1,13 @@
+import { LexicalCommand } from 'lexical';
+import { EditorPlugin } from '../../core/registry';
+export declare const INSERT_CODE_BLOCK_COMMAND: LexicalCommand<string | null>;
+export declare const SET_CODE_LANGUAGE_COMMAND: LexicalCommand<{
+    nodeKey: string;
+    language: string;
+}>;
+export declare const TOGGLE_LINE_NUMBERS_COMMAND: LexicalCommand<string>;
+export declare const SUPPORTED_LANGUAGES: {
+    value: string;
+    label: string;
+}[];
+export declare const CodeBlockPlugin: EditorPlugin;

package/dist/plugins/advanced/footnote-node.d.ts

@@ -0,0 +1,59 @@
+import { DecoratorNode, EditorConfig, LexicalNode, NodeKey, SerializedLexicalNode, Spread } from 'lexical';
+export type SerializedFootnoteRefNode = Spread<{
+    footnoteId: string;
+    type: 'footnote-ref';
+    version: 1;
+}, SerializedLexicalNode>;
+export declare class FootnoteRefNode extends DecoratorNode<HTMLElement> {
+    __footnoteId: string;
+    static getType(): string;
+    static clone(node: FootnoteRefNode): FootnoteRefNode;
+    static importJSON(serializedNode: SerializedFootnoteRefNode): FootnoteRefNode;
+    constructor(footnoteId: string, key?: NodeKey);
+    exportJSON(): SerializedFootnoteRefNode;
+    getFootnoteId(): string;
+    createDOM(_config: EditorConfig): HTMLElement;
+    updateDOM(prevNode: FootnoteRefNode, dom: HTMLElement): boolean;
+    decorate(): HTMLElement;
+    isInline(): boolean;
+}
+export declare function $createFootnoteRefNode(footnoteId: string): FootnoteRefNode;
+export declare function $isFootnoteRefNode(node: LexicalNode | null | undefined): node is FootnoteRefNode;
+export type SerializedFootnoteContentNode = Spread<{
+    footnoteId: string;
+    content: string;
+    type: 'footnote-content';
+    version: 1;
+}, SerializedLexicalNode>;
+export declare class FootnoteContentNode extends DecoratorNode<HTMLElement> {
+    __footnoteId: string;
+    __content: string;
+    static getType(): string;
+    static clone(node: FootnoteContentNode): FootnoteContentNode;
+    static importJSON(serializedNode: SerializedFootnoteContentNode): FootnoteContentNode;
+    constructor(footnoteId: string, content: string, key?: NodeKey);
+    exportJSON(): SerializedFootnoteContentNode;
+    getFootnoteId(): string;
+    getContent(): string;
+    setContent(content: string): void;
+    createDOM(_config: EditorConfig): HTMLElement;
+    updateDOM(prevNode: FootnoteContentNode, dom: HTMLElement): boolean;
+    decorate(): HTMLElement;
+}
+export declare function $createFootnoteContentNode(footnoteId: string, content: string): FootnoteContentNode;
+export declare function $isFootnoteContentNode(node: LexicalNode | null | undefined): node is FootnoteContentNode;
+export type SerializedFootnoteContainerNode = Spread<{
+    type: 'footnote-container';
+    version: 1;
+}, SerializedLexicalNode>;
+export declare class FootnoteContainerNode extends DecoratorNode<HTMLElement> {
+    static getType(): string;
+    static clone(node: FootnoteContainerNode): FootnoteContainerNode;
+    static importJSON(_serializedNode: SerializedFootnoteContainerNode): FootnoteContainerNode;
+    exportJSON(): SerializedFootnoteContainerNode;
+    createDOM(_config: EditorConfig): HTMLElement;
+    updateDOM(): boolean;
+    decorate(): HTMLElement;
+}
+export declare function $createFootnoteContainerNode(): FootnoteContainerNode;
+export declare function $isFootnoteContainerNode(node: LexicalNode | null | undefined): node is FootnoteContainerNode;

package/dist/plugins/advanced/footnote-plugin.d.ts

@@ -0,0 +1,6 @@
+import { LexicalCommand } from 'lexical';
+import { EditorPlugin } from '../../core/registry';
+export declare const INSERT_FOOTNOTE_COMMAND: LexicalCommand<void>;
+export declare const UPDATE_FOOTNOTE_NUMBERS_COMMAND: LexicalCommand<void>;
+export declare const FootnotePlugin: EditorPlugin;
+export default FootnotePlugin;

package/dist/plugins/advanced/footnote.d.ts

@@ -0,0 +1,8 @@
+import { LexicalCommand, NodeKey } from 'lexical';
+import { EditorSDK } from '../../core/sdk';
+export declare const INSERT_FOOTNOTE_COMMAND: LexicalCommand<string>;
+export declare const EDIT_FOOTNOTE_COMMAND: LexicalCommand<NodeKey>;
+export declare const FootnotePlugin: {
+    name: string;
+    init: (sdk: EditorSDK) => void;
+};

package/dist/plugins/advanced/html-snippet-node.d.ts

@@ -0,0 +1,16 @@
+import { DecoratorNode, NodeKey, SerializedLexicalNode, Spread } from 'lexical';
+export type SerializedHTMLSnippetNode = Spread<{
+    html: string;
+}, SerializedLexicalNode>;
+export declare class HTMLSnippetNode extends DecoratorNode<HTMLElement> {
+    __html: string;
+    static getType(): string;
+    static clone(node: HTMLSnippetNode): HTMLSnippetNode;
+    constructor(html: string, key?: NodeKey);
+    static importJSON(serializedNode: SerializedHTMLSnippetNode): HTMLSnippetNode;
+    exportJSON(): SerializedHTMLSnippetNode;
+    createDOM(): HTMLElement;
+    updateDOM(): false;
+    decorate(): HTMLElement;
+}
+export declare function $createHTMLSnippetNode(html: string): HTMLSnippetNode;

package/dist/plugins/advanced/markdown.d.ts

@@ -0,0 +1,5 @@
+import { LexicalCommand } from 'lexical';
+import { EditorPlugin } from '../../core/registry';
+export declare const IMPORT_MARKDOWN_COMMAND: LexicalCommand<string>;
+export declare const EXPORT_MARKDOWN_COMMAND: LexicalCommand<void>;
+export declare const MarkdownPlugin: EditorPlugin;

package/dist/plugins/advanced/media-embed.d.ts

@@ -0,0 +1,4 @@
+export declare const MediaEmbedPlugin: {
+    insertYouTube: (editor: any) => Promise<void>;
+    insertHTMLSnippet: (editor: any) => Promise<void>;
+};

package/dist/plugins/advanced/placeholder-node.d.ts

@@ -0,0 +1,22 @@
+import { DecoratorNode, EditorConfig, LexicalNode, NodeKey, SerializedLexicalNode, Spread } from 'lexical';
+export type SerializedPlaceholderNode = Spread<{
+    name: string;
+}, SerializedLexicalNode>;
+export declare class PlaceholderNode extends DecoratorNode<HTMLElement> {
+    __name: string;
+    static getType(): string;
+    static clone(node: PlaceholderNode): PlaceholderNode;
+    static importJSON(serializedNode: SerializedPlaceholderNode): PlaceholderNode;
+    constructor(name: string, key?: NodeKey);
+    exportJSON(): SerializedPlaceholderNode;
+    createDOM(_config: EditorConfig): HTMLElement;
+    private getPlaceholderMetadata;
+    private tooltipElement;
+    private showTooltip;
+    private hideTooltip;
+    updateDOM(prevNode: PlaceholderNode, dom: HTMLElement): boolean;
+    decorate(): HTMLElement;
+    getTextContent(): string;
+}
+export declare function $createPlaceholderNode(name: string): PlaceholderNode;
+export declare function $isPlaceholderNode(node: LexicalNode | null | undefined): node is PlaceholderNode;

package/dist/plugins/advanced/placeholder.d.ts

@@ -0,0 +1,18 @@
+import { LexicalEditor, LexicalCommand } from 'lexical';
+import { EditorSDK } from '../../core/sdk';
+/**
+ * Sanitizes a placeholder name to ensure it's safe and valid.
+ * Only allows alphanumeric characters and underscores.
+ * Prevents script injection and unsafe content.
+ */
+export declare function sanitizePlaceholderName(name: string): string | null;
+/**
+ * Checks if a placeholder name is valid (exists in predefined list).
+ */
+export declare function isValidPlaceholderName(name: string): boolean;
+export declare function showPlaceholderInsertPanel(editor: LexicalEditor): void;
+export declare const INSERT_PLACEHOLDER_COMMAND: LexicalCommand<string>;
+export declare const PlaceholderPlugin: {
+    name: string;
+    init: (sdk: EditorSDK) => void;
+};

package/dist/plugins/advanced/revision-history.d.ts

@@ -0,0 +1,22 @@
+import { LexicalCommand } from 'lexical';
+import { EditorPlugin } from '../../core/registry';
+export interface Revision {
+    id: string;
+    timestamp: number;
+    name: string;
+    state: string;
+    author: string;
+    isAuto: boolean;
+}
+export declare const SAVE_REVISION_COMMAND: LexicalCommand<{
+    name?: string;
+    isAuto?: boolean;
+}>;
+export declare const RESTORE_REVISION_COMMAND: LexicalCommand<string>;
+export declare const TOGGLE_REVISION_HISTORY_COMMAND: LexicalCommand<void>;
+export declare const RevisionHistoryPlugin: EditorPlugin;
+/**
+ * Utility for Diffing (Internal Use for UI)
+ * Simple word-level diff
+ */
+export declare function diffHtml(oldHtml: string, newHtml: string): string;

package/dist/plugins/advanced/source-view.d.ts

@@ -0,0 +1,37 @@
+export declare const SourceViewPlugin: {
+    _fullDocTemplate: {
+        head: string;
+        docType: string;
+    } | null;
+    _originalHtml: string | null;
+    _isDirty: boolean;
+    _listener: (() => void) | null;
+    /**
+     * Get HTML from Editor with literal fidelity.
+     */
+    getHtml: (editor: any) => string;
+    /**
+     * Professional HTML Beautifier
+     * Adds line breaks and indentation to a dense HTML string.
+     */
+    beautifyHTML: (html: string) => string;
+    /**
+     * Professional CSS Sandboxer
+     * Prefixes all selectors with .editor-container to ensure scoped styling and high specificity.
+     * Uses a robust balanced-brace parser to correctly handle nested rules (@keyframes, @media).
+     */
+    proxyCSS: (css: string) => string;
+    /**
+     * Replaces the editor content and injects styles into the document head for "Same-to-Same" design.
+     */
+    setHtml: (editor: any, html: string) => void;
+    /**
+     * Pure HTML post-processor to remove ALL Lexical pollution.
+     * This is the "Same-to-Same" guardian.
+     */
+    cleanHtml: (html: string) => string;
+    /**
+     * Permissive sanitizer to keep layout and attributes intact.
+     */
+    sanitizeHTML: (html: string) => string;
+};

package/dist/plugins/advanced/style-node.d.ts

@@ -0,0 +1,18 @@
+import { DecoratorNode, NodeKey, SerializedLexicalNode, Spread, DOMConversionMap, DOMExportOutput } from 'lexical';
+export type SerializedStyleNode = Spread<{
+    css: string;
+}, SerializedLexicalNode>;
+export declare class StyleNode extends DecoratorNode<HTMLElement> {
+    __css: string;
+    static getType(): string;
+    static clone(node: StyleNode): StyleNode;
+    constructor(css: string, key?: NodeKey);
+    static importJSON(serializedNode: SerializedStyleNode): StyleNode;
+    exportJSON(): SerializedStyleNode;
+    createDOM(): HTMLElement;
+    updateDOM(): false;
+    decorate(): HTMLElement;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(): DOMExportOutput;
+}
+export declare function $createStyleNode(css: string): StyleNode;

package/dist/plugins/advanced/youtube-node.d.ts

@@ -0,0 +1,34 @@
+import { DecoratorNode, NodeKey, EditorConfig, LexicalNode, SerializedLexicalNode, Spread, LexicalEditor, DOMExportOutput, DOMConversionMap } from 'lexical';
+export type YouTubeAlignment = 'left' | 'right' | 'center' | 'full';
+export type SerializedYouTubeNode = Spread<{
+    videoID: string;
+    width?: number;
+    height?: number;
+    alignment?: YouTubeAlignment;
+    caption?: string;
+    showCaption?: boolean;
+}, SerializedLexicalNode>;
+export declare class YouTubeNode extends DecoratorNode<HTMLElement> {
+    __videoID: string;
+    __width: 'inherit' | number;
+    __height: 'inherit' | number;
+    __alignment: YouTubeAlignment;
+    __caption: string;
+    __showCaption: boolean;
+    static getType(): string;
+    static clone(node: YouTubeNode): YouTubeNode;
+    static importJSON(serializedNode: SerializedYouTubeNode): YouTubeNode;
+    exportJSON(): SerializedYouTubeNode;
+    constructor(videoID: string, width?: 'inherit' | number, height?: 'inherit' | number, alignment?: YouTubeAlignment, caption?: string, showCaption?: boolean, key?: NodeKey);
+    createDOM(_config: EditorConfig): HTMLElement;
+    updateDOM(prevNode: YouTubeNode): boolean;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(): DOMExportOutput;
+    decorate(editor?: LexicalEditor): HTMLElement;
+    setWidthAndHeight(width: number | 'inherit', height: number | 'inherit'): void;
+    setAlignment(alignment: YouTubeAlignment): void;
+    setCaption(caption: string): void;
+    setShowCaption(show: boolean): void;
+}
+export declare function $createYouTubeNode(videoID: string): YouTubeNode;
+export declare function $isYouTubeNode(node: LexicalNode | null | undefined): node is YouTubeNode;

package/dist/plugins/collaboration/revision-history.d.ts

@@ -0,0 +1,25 @@
+import { LexicalEditor } from 'lexical';
+export interface Revision {
+    id: string;
+    timestamp: number;
+    name: string;
+    state: string;
+}
+export declare const RevisionHistory: {
+    /**
+     * Saves the current editor state as a new revision.
+     */
+    saveSnapshot: (editor: LexicalEditor, name: string) => Revision;
+    /**
+     * Retrieves all saved revisions from local storage.
+     */
+    getHistory: () => Revision[];
+    /**
+     * Restores a specific revision to the editor.
+     */
+    restoreSnapshot: (editor: LexicalEditor, revision: Revision) => void;
+    /**
+     * Clears all history.
+     */
+    clearHistory: () => void;
+};

package/dist/plugins/collaboration/revision-ui.d.ts

@@ -0,0 +1,2 @@
+import { LexicalEditor } from 'lexical';
+export declare function setupRevisionHistoryUI(internalEditor: LexicalEditor): void;

package/dist/plugins/collaboration/suggestion-node.d.ts

@@ -0,0 +1,21 @@
+import { TextNode, NodeKey, EditorConfig, SerializedTextNode, Spread } from 'lexical';
+export type SuggestionType = 'insert' | 'delete' | 'format';
+export type SerializedSuggestionNode = Spread<{
+    suggestionType: SuggestionType;
+    author: string;
+    timestamp: number;
+}, SerializedTextNode>;
+export declare class SuggestionNode extends TextNode {
+    __suggestionType: SuggestionType;
+    __author: string;
+    __timestamp: number;
+    static getType(): string;
+    static clone(node: SuggestionNode): SuggestionNode;
+    constructor(type: SuggestionType, author: string, text: string, key?: NodeKey);
+    getSuggestionType(): SuggestionType;
+    getAuthor(): string;
+    getTimestamp(): number;
+    createDOM(config: EditorConfig): HTMLElement;
+    static importJSON(serializedNode: SerializedSuggestionNode): SuggestionNode;
+    exportJSON(): SerializedSuggestionNode;
+}

package/dist/plugins/collaboration/track-changes.d.ts

@@ -0,0 +1,8 @@
+import { LexicalCommand } from 'lexical';
+import { EditorPlugin } from '../../core/registry';
+export declare const TOGGLE_TRACK_CHANGES_COMMAND: LexicalCommand<void>;
+export declare const ACCEPT_SUGGESTION_COMMAND: LexicalCommand<string>;
+export declare const REJECT_SUGGESTION_COMMAND: LexicalCommand<string>;
+export declare const TrackChangesPlugin: EditorPlugin;
+export declare const isTrackingEnabled: () => boolean;
+export declare const toggleTracking: () => boolean;

package/dist/plugins/configuration/accessibility.d.ts

@@ -0,0 +1,11 @@
+export declare const AccessibilityManager: {
+    /**
+     * Announces a message to screen readers via aria-live region.
+     */
+    announce: (message: string) => void;
+    /**
+     * Setup keyboard shortcuts overview (can be extended to a modal later)
+     */
+    setupKeyboardListeners: () => void;
+    init: () => void;
+};

package/dist/plugins/configuration/context-aware-toolbar.d.ts

@@ -0,0 +1,66 @@
+import { LexicalEditor } from 'lexical';
+export type SelectionContext = 'text' | 'image' | 'table' | 'code' | 'empty' | 'mixed';
+export interface ContextualToolbarConfig {
+    context: SelectionContext;
+    tools: string[];
+    position?: 'top' | 'floating' | 'inline';
+}
+export declare class ContextAwareToolbar {
+    private editor;
+    private currentContext;
+    private floatingToolbar;
+    constructor(editor: LexicalEditor);
+    /**
+     * Initialize context-aware toolbar
+     */
+    private init;
+    /**
+     * Create floating toolbar element
+     */
+    private createFloatingToolbar;
+    /**
+     * Attach selection change listeners
+     */
+    private attachListeners;
+    /**
+     * Detect current selection context
+     */
+    private detectContext;
+    /**
+     * Update toolbar visibility based on context
+     */
+    private updateToolbarVisibility;
+    /**
+     * Check if tool should show in context
+     */
+    private shouldShowInContext;
+    /**
+     * Check if tool is contextual (requires specific selection)
+     */
+    private isContextualTool;
+    /**
+     * Show floating toolbar
+     */
+    private showFloatingToolbar;
+    /**
+     * Hide floating toolbar
+     */
+    private hideFloatingToolbar;
+    /**
+     * Populate floating toolbar with tools
+     */
+    private populateFloatingToolbar;
+    /**
+     * Get tool icon
+     */
+    private getToolIcon;
+    /**
+     * Execute tool command
+     */
+    private executeToolCommand;
+    /**
+     * Get current context
+     */
+    getCurrentContext(): SelectionContext;
+}
+export default ContextAwareToolbar;

package/dist/plugins/configuration/i18n.d.ts

@@ -0,0 +1,40 @@
+export type TranslationKeys = {
+    undo: string;
+    redo: string;
+    clearFormatting: string;
+    bold: string;
+    italic: string;
+    underline: string;
+    strikethrough: string;
+    subscript: string;
+    superscript: string;
+    code: string;
+    h1: string;
+    h2: string;
+    paragraph: string;
+    bullets: string;
+    numbers: string;
+    link: string;
+    image: string;
+    table: string;
+    youtube: string;
+    htmlSnippet: string;
+    placeholders: string;
+    codeBlock: string;
+    pdf: string;
+    word: string;
+    importWord: string;
+    pageBreak: string;
+    footnote: string;
+    toc: string;
+    outline: string;
+    settings: string;
+    trackChanges: string;
+};
+export type LanguageCode = 'en' | 'ar' | 'es' | 'fr';
+export declare const I18nManager: {
+    getLanguage: () => LanguageCode;
+    setLanguage: (lang: LanguageCode) => void;
+    applyLanguage: (lang: LanguageCode) => void;
+    init: () => void;
+};

package/dist/plugins/configuration/toolbar-config.d.ts

@@ -0,0 +1,73 @@
+export type ToolbarItemType = 'button' | 'dropdown' | 'separator' | 'select' | 'custom';
+export interface ToolbarItem {
+    id: string;
+    type: ToolbarItemType;
+    label?: string;
+    icon?: string;
+    tooltip?: string;
+    command?: string;
+    commandPayload?: string;
+    group?: string;
+    contextual?: boolean;
+    requiredSelection?: 'text' | 'image' | 'table' | 'code' | 'any';
+    children?: ToolbarItem[];
+    enabled?: boolean;
+    visible?: boolean;
+    order?: number;
+}
+export interface ToolbarGroup {
+    id: string;
+    items: ToolbarItem[];
+}
+export interface ToolbarPreset {
+    id: string;
+    name: string;
+    description: string;
+    items: string[];
+}
+export interface ToolbarConfig {
+    preset?: string;
+    customItems?: string[];
+    hiddenItems?: string[];
+    groups?: ToolbarGroup[];
+    overflow?: boolean;
+    responsive?: boolean;
+}
+export declare const TOOLBAR_ITEMS: Record<string, ToolbarItem>;
+export declare const TOOLBAR_PRESETS: Record<string, ToolbarPreset>;
+export declare class ToolbarConfigManager {
+    private static STORAGE_KEY;
+    private static currentConfig;
+    /**
+     * Get active configuration from storage or default
+     */
+    static getConfig(): ToolbarConfig;
+    /**
+     * Save configuration
+     */
+    static saveConfig(config: ToolbarConfig): void;
+    /**
+     * Apply a specific preset
+     */
+    static applyPreset(presetId: string): void;
+    /**
+     * Render the toolbar based on config
+     */
+    static applyConfig(config: ToolbarConfig): void;
+    /**
+     * Reset to default configuration
+     */
+    static resetToDefault(): void;
+    /**
+     * Get all available items
+     */
+    static getAvailableItems(): ToolbarItem[];
+    /**
+     * Get currently active items
+     */
+    static getActiveItems(): string[];
+    /**
+     * Render individual toolbar item
+     */
+    private static renderToolbarItem;
+}

package/dist/plugins/configuration/toolbar-customization-ui.d.ts

@@ -0,0 +1,73 @@
+export declare class ToolbarCustomizationUI {
+    private modal;
+    private draggedItem;
+    /**
+     * Initialize the customization UI
+     */
+    init(): void;
+    /**
+     * Create the customization modal
+     */
+    private createModal;
+    /**
+     * Attach event listeners
+     */
+    private attachEventListeners;
+    /**
+     * Show the customization modal
+     */
+    show(): void;
+    /**
+     * Hide the customization modal
+     */
+    hide(): void;
+    /**
+     * Refresh the UI with current configuration
+     */
+    private refreshUI;
+    /**
+     * Update active preset button highlighting
+     */
+    private updatePresetHighlight;
+    /**
+     * Populate active tools list
+     */
+    private populateActiveTools;
+    /**
+     * Populate available tools by group
+     */
+    private populateAvailableTools;
+    /**
+     * Create a tool item element
+     */
+    private createToolItem;
+    /**
+     * Initialize drag and drop
+     */
+    private initializeDragAndDrop;
+    /**
+     * Get element after drag position
+     */
+    private getDragAfterElement;
+    /**
+     * Add item to active tools
+     */
+    private addToActive;
+    /**
+     * Remove item from active tools
+     */
+    private removeFromActive;
+    /**
+     * Apply a preset
+     */
+    private applyPreset;
+    /**
+     * Save current configuration
+     */
+    private saveConfiguration;
+    /**
+     * Filter tools by search query
+     */
+    private filterTools;
+}
+export declare const toolbarCustomizationUI: ToolbarCustomizationUI;