@seyamali/aurelia-editor 0.1.0

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

@@ -0,0 +1,12 @@
+export type ToolbarItemConfig = {
+    id: string;
+    label: string;
+    visible: boolean;
+};
+export declare const ToolbarCustomization: {
+    getDefaultConfig: () => ToolbarItemConfig[];
+    getConfig: () => ToolbarItemConfig[];
+    saveConfig: (config: ToolbarItemConfig[]) => void;
+    applyConfig: (config: ToolbarItemConfig[]) => void;
+    init: () => void;
+};

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

@@ -0,0 +1,25 @@
+import { LexicalEditor } from 'lexical';
+import { AureliaEditor } from '../../core/engine';
+export declare class ToolbarSystem {
+    private static isInitialized;
+    /**
+     * Initialize the complete toolbar system
+     */
+    static init(editor: AureliaEditor, internalEditor: LexicalEditor): void;
+    /**
+     * Setup toolbar customization button
+     */
+    private static setupCustomizationButton;
+    /**
+     * Setup responsive overflow handling
+     */
+    private static setupResponsiveOverflow;
+    /**
+     * Update overflow menu with hidden items
+     */
+    private static updateOverflowMenu;
+    static showCustomization(): void;
+    static applyPreset(presetId: string): void;
+    static resetToDefault(): void;
+}
+export default ToolbarSystem;

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

@@ -0,0 +1 @@
+export declare function setupToolbarSettingsUI(): void;

package/dist/plugins/custom-plugin-demo.d.ts

@@ -0,0 +1,11 @@
+import { EditorSDK } from '../core/sdk';
+import { LexicalCommand } from 'lexical';
+export declare const HELLO_WORLD_COMMAND: LexicalCommand<string>;
+/**
+ * A Demo Plugin to showcase the new Editor SDK.
+ * It adds a button to the toolbar and registers a custom command.
+ */
+export declare const HelloWorldPlugin: {
+    name: string;
+    init: (sdk: EditorSDK) => void;
+};

package/dist/plugins/essentials/clipboard.d.ts

@@ -0,0 +1,4 @@
+import { LexicalCommand } from 'lexical';
+import { EditorPlugin } from '../../core/registry';
+export declare const REMOVE_FORMATTING_COMMAND: LexicalCommand<void>;
+export declare const ClipboardPlugin: EditorPlugin;

package/dist/plugins/essentials/history.d.ts

@@ -0,0 +1,12 @@
+import { EditorPlugin } from '../../core/registry';
+export declare const HistoryPlugin: EditorPlugin;
+export declare const HISTORY_COMMANDS: {
+    UNDO: {
+        command: import('lexical').LexicalCommand<void>;
+        payload: undefined;
+    };
+    REDO: {
+        command: import('lexical').LexicalCommand<void>;
+        payload: undefined;
+    };
+};

package/dist/plugins/essentials/horizontal-rule-plugin.d.ts

@@ -0,0 +1,2 @@
+import { EditorPlugin } from '../../core/registry';
+export declare const HorizontalRulePlugin: EditorPlugin;

package/dist/plugins/export/pdf-export.d.ts

@@ -0,0 +1,4 @@
+import { LexicalEditor } from 'lexical';
+export declare const ExportPDF: {
+    exportToPdf: (editor: LexicalEditor) => void;
+};

package/dist/plugins/export/word-export.d.ts

@@ -0,0 +1,4 @@
+import { LexicalEditor } from 'lexical';
+export declare const ExportWord: {
+    exportToDoc: (editor: LexicalEditor) => void;
+};

package/dist/plugins/formatting/basic-styles.d.ts

@@ -0,0 +1,33 @@
+import { TextFormatType } from 'lexical';
+import { EditorPlugin } from '../../core/registry';
+export declare const BasicStylesPlugin: EditorPlugin;
+export declare const FORMAT_COMMANDS: {
+    BOLD: {
+        command: import('lexical').LexicalCommand<TextFormatType>;
+        payload: TextFormatType;
+    };
+    ITALIC: {
+        command: import('lexical').LexicalCommand<TextFormatType>;
+        payload: TextFormatType;
+    };
+    UNDERLINE: {
+        command: import('lexical').LexicalCommand<TextFormatType>;
+        payload: TextFormatType;
+    };
+    STRIKETHROUGH: {
+        command: import('lexical').LexicalCommand<TextFormatType>;
+        payload: TextFormatType;
+    };
+    SUBSCRIPT: {
+        command: import('lexical').LexicalCommand<TextFormatType>;
+        payload: TextFormatType;
+    };
+    SUPERSCRIPT: {
+        command: import('lexical').LexicalCommand<TextFormatType>;
+        payload: TextFormatType;
+    };
+    CODE: {
+        command: import('lexical').LexicalCommand<TextFormatType>;
+        payload: TextFormatType;
+    };
+};

package/dist/plugins/formatting/custom-heading-node.d.ts

@@ -0,0 +1,17 @@
+import { HeadingNode, SerializedHeadingNode } from '@lexical/rich-text';
+import { EditorConfig, NodeKey, DOMConversionMap, DOMExportOutput, Spread } from 'lexical';
+export type SerializedCustomHeadingNode = Spread<{
+    attributes: Record<string, string>;
+}, SerializedHeadingNode>;
+export declare class CustomHeadingNode extends HeadingNode {
+    __attributes: Record<string, string>;
+    constructor(tag: 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6', attributes?: Record<string, string>, key?: NodeKey);
+    static getType(): string;
+    static clone(node: CustomHeadingNode): CustomHeadingNode;
+    createDOM(config: EditorConfig): HTMLElement;
+    exportDOM(editor: any): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serializedNode: SerializedCustomHeadingNode): CustomHeadingNode;
+    exportJSON(): SerializedCustomHeadingNode;
+}
+export declare function $createCustomHeadingNode(tag: 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6', attributes?: Record<string, string>): CustomHeadingNode;

package/dist/plugins/formatting/custom-link-node.d.ts

@@ -0,0 +1,17 @@
+import { LinkNode, SerializedLinkNode } from '@lexical/link';
+import { EditorConfig, NodeKey, DOMConversionMap, DOMExportOutput, Spread } from 'lexical';
+export type SerializedCustomLinkNode = Spread<{
+    attributes: Record<string, string>;
+}, SerializedLinkNode>;
+export declare class CustomLinkNode extends LinkNode {
+    __attributes: Record<string, string>;
+    constructor(url: string, attributes?: Record<string, string>, key?: NodeKey);
+    static getType(): string;
+    static clone(node: CustomLinkNode): CustomLinkNode;
+    createDOM(config: EditorConfig): HTMLElement;
+    exportDOM(editor: any): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serializedNode: SerializedCustomLinkNode): CustomLinkNode;
+    exportJSON(): SerializedCustomLinkNode;
+}
+export declare function $createCustomLinkNode(url: string, attributes?: Record<string, string>): CustomLinkNode;

package/dist/plugins/formatting/custom-paragraph-node.d.ts

@@ -0,0 +1,16 @@
+import { ParagraphNode, SerializedParagraphNode, EditorConfig, NodeKey, DOMConversionMap, DOMExportOutput, Spread } from 'lexical';
+export type SerializedCustomParagraphNode = Spread<{
+    attributes: Record<string, string>;
+}, SerializedParagraphNode>;
+export declare class CustomParagraphNode extends ParagraphNode {
+    __attributes: Record<string, string>;
+    constructor(attributes?: Record<string, string>, key?: NodeKey);
+    static getType(): string;
+    static clone(node: CustomParagraphNode): CustomParagraphNode;
+    createDOM(config: EditorConfig): HTMLElement;
+    exportDOM(editor: any): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serializedNode: SerializedCustomParagraphNode): CustomParagraphNode;
+    exportJSON(): SerializedCustomParagraphNode;
+}
+export declare function $createCustomParagraphNode(attributes?: Record<string, string>): CustomParagraphNode;

package/dist/plugins/formatting/icon-node.d.ts

@@ -0,0 +1,22 @@
+import { ElementNode, EditorConfig, NodeKey, DOMConversionMap, DOMExportOutput, LexicalNode, SerializedElementNode, Spread } from 'lexical';
+export type SerializedIconNode = Spread<{
+    tagName: string;
+    attributes: Record<string, string>;
+}, SerializedElementNode>;
+export declare class IconNode extends ElementNode {
+    __tagName: string;
+    __attributes: Record<string, string>;
+    constructor(tagName: string, attributes?: Record<string, string>, key?: NodeKey);
+    static getType(): string;
+    static clone(node: IconNode): IconNode;
+    createDOM(_config: EditorConfig): HTMLElement;
+    updateDOM(prevNode: IconNode, dom: HTMLElement): boolean;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(): DOMExportOutput;
+    static importJSON(serializedNode: SerializedIconNode): IconNode;
+    exportJSON(): SerializedIconNode;
+    isInline(): boolean;
+    canBeEmpty(): boolean;
+}
+export declare function $createIconNode(tagName: string, attributes?: Record<string, string>): IconNode;
+export declare function $isIconNode(node: LexicalNode | null | undefined): node is IconNode;

package/dist/plugins/formatting/span-node.d.ts

@@ -0,0 +1,18 @@
+import { ElementNode, EditorConfig, NodeKey, DOMConversionMap, DOMExportOutput, SerializedElementNode, Spread } from 'lexical';
+export type SerializedSpanNode = Spread<{
+    attributes: Record<string, string>;
+}, SerializedElementNode>;
+export declare class SpanNode extends ElementNode {
+    __attributes: Record<string, string>;
+    constructor(attributes?: Record<string, string>, key?: NodeKey);
+    static getType(): string;
+    static clone(node: SpanNode): SpanNode;
+    createDOM(_config: EditorConfig): HTMLElement;
+    updateDOM(prevNode: SpanNode, dom: HTMLElement): boolean;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(): DOMExportOutput;
+    static importJSON(serializedNode: SerializedSpanNode): SpanNode;
+    exportJSON(): SerializedSpanNode;
+    canBeEmpty(): boolean;
+    isInline(): boolean;
+}

package/dist/plugins/import/word-import.d.ts

@@ -0,0 +1,5 @@
+import { LexicalEditor } from 'lexical';
+export declare const ImportWord: {
+    importDocx: (editor: LexicalEditor, file: File) => void;
+    triggerImport: (editor: LexicalEditor) => void;
+};

package/dist/plugins/layout/headings.d.ts

@@ -0,0 +1,7 @@
+import { HeadingTagType } from '@lexical/rich-text';
+import { LexicalEditor } from 'lexical';
+import { EditorPlugin } from '../../core/registry';
+export declare const HeadingsPlugin: EditorPlugin;
+export declare const setBlockType: (editor: any, type: HeadingTagType | "quote" | "paragraph") => void;
+export declare const toggleBlockQuote: (editor: LexicalEditor) => void;
+export declare const insertHorizontalRule: (editor: LexicalEditor) => void;

package/dist/plugins/layout/indent.d.ts

@@ -0,0 +1,2 @@
+import { EditorPlugin } from '../../core/registry';
+export declare const IndentPlugin: EditorPlugin;

package/dist/plugins/layout/layout-node.d.ts

@@ -0,0 +1,22 @@
+import { ElementNode, EditorConfig, NodeKey, DOMConversionMap, DOMExportOutput, LexicalNode, SerializedElementNode, Spread } from 'lexical';
+export type SerializedLayoutNode = Spread<{
+    tagName: string;
+    attributes: Record<string, string>;
+}, SerializedElementNode>;
+export declare class LayoutNode extends ElementNode {
+    __tagName: string;
+    __attributes: Record<string, string>;
+    constructor(tagName: string, attributes?: Record<string, string>, key?: NodeKey);
+    static getType(): string;
+    static clone(node: LayoutNode): LayoutNode;
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(prevNode: LayoutNode, dom: HTMLElement): boolean;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(): DOMExportOutput;
+    static importJSON(serializedNode: SerializedLayoutNode): LayoutNode;
+    exportJSON(): SerializedLayoutNode;
+    canBeEmpty(): boolean;
+    isInline(): boolean;
+}
+export declare function $createLayoutNode(tagName: string, attributes?: Record<string, string>): LayoutNode;
+export declare function $isLayoutNode(node: LexicalNode | null | undefined): node is LayoutNode;

package/dist/plugins/layout/lists.d.ts

@@ -0,0 +1,22 @@
+import { LexicalEditor } from 'lexical';
+import { EditorPlugin } from '../../core/registry';
+export declare const ListsPlugin: EditorPlugin;
+export declare const toggleList: (editor: LexicalEditor, type: "bullet" | "number") => void;
+export declare const LIST_COMMANDS: {
+    BULLET: {
+        command: import('lexical').LexicalCommand<void>;
+        payload: undefined;
+    };
+    NUMBER: {
+        command: import('lexical').LexicalCommand<void>;
+        payload: undefined;
+    };
+    INDENT: {
+        command: import('lexical').LexicalCommand<void>;
+        payload: undefined;
+    };
+    OUTDENT: {
+        command: import('lexical').LexicalCommand<void>;
+        payload: undefined;
+    };
+};

package/dist/plugins/layout/table-resizer.d.ts

@@ -0,0 +1,5 @@
+import { EditorSDK } from '../../core/sdk';
+export declare const TableResizerPlugin: {
+    name: string;
+    init: (sdk: EditorSDK) => void;
+};

package/dist/plugins/layout/tables.d.ts

@@ -0,0 +1,16 @@
+import { EditorPlugin } from '../../core/registry';
+export declare const TablesPlugin: EditorPlugin;
+export declare const tableHandlers: {
+    insertRowAbove: (editor: any) => void;
+    insertRowBelow: (editor: any) => void;
+    insertColumnLeft: (editor: any) => void;
+    insertColumnRight: (editor: any) => void;
+    deleteRow: (editor: any) => void;
+    deleteColumn: (editor: any) => void;
+    deleteTable: (editor: any) => void;
+    insertRow: (editor: any) => void;
+    insertColumn: (editor: any) => void;
+    mergeCells: (editor: any) => void;
+    splitCell: (editor: any) => void;
+};
+export declare const insertTable: (editor: any) => void;

package/dist/plugins/media/custom-image-node.d.ts

@@ -0,0 +1,23 @@
+import { ImageNode, SerializedImageNode, ImageAlignment } from './image-node';
+import { NodeKey, DOMConversionMap, DOMExportOutput, Spread, EditorConfig, LexicalEditor } from 'lexical';
+export type SerializedCustomImageNode = Spread<{
+    attributes: Record<string, string>;
+}, SerializedImageNode>;
+export declare class CustomImageNode extends ImageNode {
+    __attributes: Record<string, string>;
+    constructor(src?: string, altText?: string, attributes?: Record<string, string>, maxWidth?: number, width?: number | 'inherit', height?: number | 'inherit', caption?: string, alignment?: ImageAlignment, showCaption?: boolean, linkUrl?: string, cropData?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null, key?: NodeKey);
+    static getType(): string;
+    static clone(node: CustomImageNode): CustomImageNode;
+    createDOM(config: EditorConfig): HTMLElement;
+    decorate(editor: LexicalEditor, config: EditorConfig): HTMLElement;
+    exportDOM(): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serializedNode: SerializedCustomImageNode): CustomImageNode;
+    exportJSON(): SerializedCustomImageNode;
+}
+export declare function $createCustomImageNode(src: string, altText: string, attributes?: Record<string, string>): CustomImageNode;

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

@@ -0,0 +1,9 @@
+import { LexicalCommand } from 'lexical';
+import { EditorPlugin } from '../../core/registry';
+import { EditorSDK } from '../../core/sdk';
+export declare const INSERT_YOUTUBE_COMMAND: LexicalCommand<string>;
+export declare const INSERT_HTML_SNIPPET_COMMAND: LexicalCommand<string>;
+export declare class EmbedPlugin implements EditorPlugin {
+    name: string;
+    init(sdk: EditorSDK): void;
+}

package/dist/plugins/media/image-drag-move.d.ts

@@ -0,0 +1,2 @@
+import { LexicalEditor } from 'lexical';
+export declare function setupImageDragToMove(editor: LexicalEditor): () => void;

package/dist/plugins/media/image-node.d.ts

@@ -0,0 +1,70 @@
+import { DecoratorNode, NodeKey, EditorConfig, LexicalNode, SerializedLexicalNode, Spread, LexicalEditor, DOMConversionMap, DOMExportOutput } from 'lexical';
+export type ImageAlignment = 'left' | 'right' | 'center' | 'full';
+export type SerializedImageNode = Spread<{
+    altText: string;
+    caption: string;
+    height?: number;
+    maxWidth: number;
+    src: string;
+    width?: number;
+    alignment?: ImageAlignment;
+    showCaption?: boolean;
+    linkUrl?: string;
+    cropData?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    className?: string;
+}, SerializedLexicalNode>;
+export declare class ImageNode extends DecoratorNode<HTMLElement> {
+    __src: string;
+    __altText: string;
+    __width: 'inherit' | number;
+    __height: 'inherit' | number;
+    __maxWidth: number;
+    __caption: string;
+    __alignment: ImageAlignment;
+    __showCaption: boolean;
+    __linkUrl: string;
+    __cropData: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+    __className: string;
+    constructor(src?: string, altText?: string, maxWidth?: number, width?: number | 'inherit', height?: number | 'inherit', caption?: string, alignment?: ImageAlignment, showCaption?: boolean, linkUrl?: string, cropData?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null, className?: string, key?: NodeKey);
+    static getType(): string;
+    static clone(node: ImageNode): ImageNode;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(): DOMExportOutput;
+    static importJSON(serializedNode: SerializedImageNode): ImageNode;
+    exportJSON(): SerializedImageNode;
+    setClassName(className: string): void;
+    setWidthAndHeight(width: number | 'inherit', height: number | 'inherit'): void;
+    setAlignment(alignment: ImageAlignment): void;
+    setShowCaption(show: boolean): void;
+    setCaption(caption: string): void;
+    setAltText(altText: string): void;
+    setLinkUrl(url: string): void;
+    setCropData(cropData: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null): void;
+    isInline(): boolean;
+    isKeyboardSelectable(): boolean;
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(prevNode: ImageNode): boolean;
+    decorate(editor: LexicalEditor, _config: EditorConfig): HTMLElement;
+}
+export declare function $isImageNode(node: LexicalNode | null | undefined): node is ImageNode;
+export declare function $createImageNode(src: string, altText: string, maxWidth: number): ImageNode;

package/dist/plugins/media/image-popover-ui.d.ts

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

package/dist/plugins/media/image-resizer.d.ts

@@ -0,0 +1,6 @@
+import { LexicalEditor } from 'lexical';
+/**
+ * Universal Resizer for Images and YouTube Embeds.
+ * Handles dragging resizer handles to update node dimensions.
+ */
+export declare function setupImageResizer(editor: LexicalEditor): (() => void) | undefined;

package/dist/plugins/media/image-url-modal.d.ts

@@ -0,0 +1,3 @@
+export declare function setupImageURLModal(editor: any): {
+    showModal: () => void;
+};

package/dist/plugins/media/images.d.ts

@@ -0,0 +1,4 @@
+import { EditorPlugin } from '../../core/registry';
+export declare const ImagesPlugin: EditorPlugin;
+export declare const insertImage: () => void;
+export declare const insertImageFromURL: () => void;

package/dist/plugins/media/link-popover-ui.d.ts

@@ -0,0 +1,3 @@
+import { LexicalEditor, LexicalCommand } from 'lexical';
+export declare const SHOW_LINK_POPOVER_COMMAND: LexicalCommand<void>;
+export declare function setupLinkPopover(editor: LexicalEditor): void;

package/dist/plugins/media/links.d.ts

@@ -0,0 +1,3 @@
+import { EditorPlugin } from '../../core/registry';
+export declare const LinksPlugin: EditorPlugin;
+export declare const insertLink: (editor: any) => void;

package/dist/plugins/media/unified-image-modal.d.ts

@@ -0,0 +1,3 @@
+export declare function setupUnifiedImageModal(editor: any): {
+    showModal: () => void;
+};

package/dist/plugins/page-layout/page-break-node.d.ts

@@ -0,0 +1,20 @@
+import { DecoratorNode, DOMExportOutput, EditorConfig, LexicalNode, NodeKey, SerializedLexicalNode, Spread, DOMConversionMap } from 'lexical';
+export type SerializedPageBreakNode = Spread<{
+    type: 'page-break';
+    version: 1;
+}, SerializedLexicalNode>;
+export declare class PageBreakNode extends DecoratorNode<HTMLDivElement> {
+    static getType(): string;
+    static clone(node: PageBreakNode): PageBreakNode;
+    static importJSON(_serializedNode: SerializedPageBreakNode): PageBreakNode;
+    constructor(key?: NodeKey);
+    exportJSON(): SerializedPageBreakNode;
+    createDOM(_config: EditorConfig): HTMLElement;
+    updateDOM(): boolean;
+    decorate(): HTMLDivElement;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(): DOMExportOutput;
+    getTextContent(): string;
+}
+export declare function $createPageBreakNode(): PageBreakNode;
+export declare function $isPageBreakNode(node: LexicalNode | null | undefined): node is PageBreakNode;

package/dist/plugins/page-layout/page-break.d.ts

@@ -0,0 +1,7 @@
+import { LexicalCommand } from 'lexical';
+import { EditorSDK } from '../../core/sdk';
+export declare const INSERT_PAGE_BREAK_COMMAND: LexicalCommand<undefined>;
+export declare const PageBreakPlugin: {
+    name: string;
+    init: (sdk: EditorSDK) => void;
+};

package/dist/plugins/page-layout/toc-node.d.ts

@@ -0,0 +1,46 @@
+import { DecoratorNode, EditorConfig, LexicalNode, NodeKey, SerializedLexicalNode, Spread, $getRoot } from 'lexical';
+export type TOCEntry = {
+    key: string;
+    text: string;
+    tag: string;
+    level: number;
+};
+export type TOCConfig = {
+    minLevel?: number;
+    maxLevel?: number;
+    numbered?: boolean;
+    collapsible?: boolean;
+    style?: 'ordered' | 'unordered' | 'nested';
+    theme?: 'light' | 'dark' | 'auto';
+};
+export type SerializedTableOfContentsNode = Spread<{
+    entries: TOCEntry[];
+    config: TOCConfig;
+    type: 'toc';
+    version: 2;
+}, SerializedLexicalNode>;
+export declare class TableOfContentsNode extends DecoratorNode<HTMLElement> {
+    __entries: TOCEntry[];
+    __config: TOCConfig;
+    static getType(): string;
+    static clone(node: TableOfContentsNode): TableOfContentsNode;
+    static importJSON(serializedNode: SerializedTableOfContentsNode): TableOfContentsNode;
+    constructor(entries?: TOCEntry[], config?: TOCConfig, key?: NodeKey);
+    exportJSON(): SerializedTableOfContentsNode;
+    createDOM(_config: EditorConfig): HTMLElement;
+    updateDOM(prevNode: TableOfContentsNode, dom: HTMLElement): boolean;
+    renderEntries(container: HTMLElement): void;
+    private buildNestedList;
+    private getNumberForEntry;
+    setEntries(entries: TOCEntry[]): void;
+    setConfig(config: Partial<TOCConfig>): void;
+    getConfig(): TOCConfig;
+    decorate(): HTMLElement;
+    getTextContent(): string;
+}
+export declare function $createTableOfContentsNode(entries?: TOCEntry[], config?: TOCConfig): TableOfContentsNode;
+export declare function $isTableOfContentsNode(node: LexicalNode | null | undefined): node is TableOfContentsNode;
+/**
+ * Recursively scan all nodes to find headings, including those in nested structures
+ */
+export declare function $scanAllHeadings(root: ReturnType<typeof $getRoot>): TOCEntry[];

package/dist/plugins/page-layout/toc-plugin.d.ts

@@ -0,0 +1,8 @@
+import { LexicalCommand } from 'lexical';
+import { TOCConfig } from './toc-node';
+import { EditorSDK } from '../../core/sdk';
+export declare const INSERT_TOC_COMMAND: LexicalCommand<TOCConfig | undefined>;
+export declare const TableOfContentsPlugin: {
+    name: string;
+    init: (sdk: EditorSDK) => void;
+};

package/dist/plugins/productivity/autosave.d.ts

@@ -0,0 +1,6 @@
+import { EditorPlugin } from '../../core/registry';
+import { LexicalEditor } from 'lexical';
+export declare const AUTOSAVE_KEY = "editor_autosave_state";
+export declare const AutosavePlugin: EditorPlugin;
+export declare function hasAutosavedState(): boolean;
+export declare function loadAutosavedState(editor: LexicalEditor): void;

package/dist/plugins/productivity/case-change.d.ts

@@ -0,0 +1,11 @@
+import { LexicalEditor } from 'lexical';
+import { EditorSDK } from '../../core/sdk';
+export declare const CaseChange: {
+    toUpperCase: (editor: LexicalEditor) => void;
+    toLowerCase: (editor: LexicalEditor) => void;
+    toTitleCase: (editor: LexicalEditor) => void;
+};
+export declare const CaseChangePlugin: {
+    name: string;
+    init: (_sdk: EditorSDK) => void;
+};

package/dist/plugins/productivity/document-outline.d.ts

@@ -0,0 +1,12 @@
+import { EditorSDK } from '../../core/sdk';
+export type OutlineEntry = {
+    key: string;
+    text: string;
+    tag: string;
+    level: number;
+};
+export declare const DocumentOutlinePlugin: {
+    name: string;
+    init: (sdk: EditorSDK) => void;
+    toggleVisibility: () => void;
+};

package/dist/plugins/productivity/emoji-ui.d.ts

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

package/dist/plugins/productivity/emoji.d.ts

@@ -0,0 +1,9 @@
+import { LexicalEditor } from 'lexical';
+import { EditorSDK } from '../../core/sdk';
+export declare const EmojiPlugin: {
+    name: string;
+    init: (_sdk: EditorSDK) => void;
+};
+export declare const EmojiPicker: {
+    insertEmoji: (editor: LexicalEditor, emoji: string) => void;
+};

package/dist/plugins/productivity/find-replace-ui.d.ts

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

package/dist/plugins/productivity/find-replace.d.ts

@@ -0,0 +1,26 @@
+import { TextNode, LexicalEditor } from 'lexical';
+export interface SearchOptions {
+    caseSensitive: boolean;
+    wholeWord: boolean;
+    isRegex: boolean;
+}
+export declare const FindReplace: {
+    /**
+     * Finds the next match relative to current cursor.
+     */
+    findNext: (editor: LexicalEditor, searchText: string, options: SearchOptions) => void;
+    /**
+     * Finds the previous match (search backwards).
+     */
+    findPrevious: (editor: LexicalEditor, searchText: string, options: SearchOptions) => void;
+    /**
+     * Internal search logic using Regex for flexibility
+     */
+    _find: (editor: LexicalEditor, searchText: string, options: SearchOptions, backwards: boolean) => void;
+    selectMatch: (editor: LexicalEditor, node: TextNode, index: number, length: number) => void;
+    /**
+     * Replaces, then moves to next.
+     */
+    replace: (editor: LexicalEditor, searchText: string, replaceText: string, options: SearchOptions) => void;
+    replaceAll: (editor: LexicalEditor, searchText: string, replaceText: string, options: SearchOptions) => void;
+};

package/dist/plugins/productivity/format-painter.d.ts

@@ -0,0 +1,10 @@
+import { LexicalEditor } from 'lexical';
+import { EditorPlugin } from '../../core/registry';
+export declare const FormatPainterPlugin: EditorPlugin;
+export declare const FormatPainter: {
+    /**
+     * Copies the format of the current selection.
+     */
+    copyFormat: (editor: LexicalEditor, isLocked?: boolean) => void;
+    isPainting: () => boolean;
+};