@notectl/core 0.0.5 → 0.0.6

package/dist/types/index.d.ts

@@ -1,1469 +0,0 @@
-/**
- * Apply or remove a mark across a range
- */
-export declare interface ApplyMarkOp extends BaseOperation {
-    op: 'apply_mark';
-    range: Range_2;
-    mark: Mark;
-    add: boolean;
-}
-
-/**
- * Default timeout for screen reader announcements
- * Used to clear and reset the aria-live region
- */
-export declare const ARIA_ANNOUNCEMENT_DELAY = 100;
-
-/**
- * Attribute specification
- */
-export declare interface AttributeSpec {
-    default?: unknown;
-    validate?: (value: unknown) => boolean;
-    required?: boolean;
-}
-
-/**
- * Base operation interface
- */
-declare interface BaseOperation {
-    op: string;
-}
-
-/**
- * Base plugin class for convenience
- */
-export declare abstract class BasePlugin implements Plugin_2 {
-    abstract id: string;
-    abstract name: string;
-    abstract version: string;
-    dependencies?: string[];
-    protected context?: PluginContext;
-    init(context: PluginContext): Promise<void>;
-    destroy(): Promise<void>;
-    protected getContext(): PluginContext;
-}
-
-/**
- * Block node attributes
- */
-export declare interface BlockAttrs {
-    align?: 'left' | 'center' | 'right' | 'justify';
-    level?: number;
-    alt?: string;
-    src?: string;
-    decorative?: boolean;
-    dir?: 'ltr' | 'rtl' | 'auto';
-    locale?: string;
-    [key: string]: unknown;
-}
-
-/**
- * Block type utilities
- */
-export declare interface BlockHelpers {
-    /**
-     * Check if a node is a text node
-     */
-    isTextNode(node: Node_2): node is TextNode;
-    /**
-     * Check if a node is a block node
-     */
-    isBlockNode(node: Node_2): node is BlockNode;
-    /**
-     * Get all text content from a block
-     */
-    getTextContent(block: BlockNode): string;
-    /**
-     * Check if block is empty
-     */
-    isEmpty(block: BlockNode): boolean;
-}
-
-/**
- * Block helper implementation
- */
-export declare const blockHelpers: BlockHelpers;
-
-/**
- * Core type definitions for Notectl editor
- */
-/**
- * Unique identifier for blocks (UUID/ULID)
- */
-export declare type BlockId = string;
-
-/**
- * Block node (structural element)
- */
-export declare interface BlockNode {
-    id: BlockId;
-    type: NodeType;
-    attrs?: BlockAttrs;
-    children?: Node_2[];
-}
-
-/**
- * Check if two deltas can be safely composed
- */
-export declare function canCompose(deltaA: Delta, deltaB: Delta): boolean;
-
-/**
- * Command definition with type safety
- */
-export declare interface CommandDefinition<TArgs extends unknown[] = unknown[], TReturn = unknown> {
-    name: string;
-    description?: string;
-    handler: CommandHandler_2<TArgs, TReturn>;
-}
-
-/**
- * Command handler function
- */
-export declare type CommandHandler = (...args: unknown[]) => unknown;
-
-/**
- * Command handler function signature
- */
-declare type CommandHandler_2<TArgs extends unknown[] = unknown[], TReturn = unknown> = (...args: TArgs) => TReturn | Promise<TReturn>;
-
-/**
- * Built-in command registry
- * Maps command names to their handlers
- */
-export declare interface CommandRegistry {
-    [key: string]: CommandHandler_2<unknown[], unknown>;
-}
-
-/**
- * Compose two deltas into a single delta
- * Applies deltaB after deltaA
- */
-export declare function composeDelta(deltaA: Delta, deltaB: Delta): Delta;
-
-/**
- * Compute inverse operations for undo
- * This is a simplified implementation - full implementation would inspect document state
- */
-export declare function computeInverse(delta: Delta): Operation[];
-
-/**
- * Create default Notectl schema
- */
-export declare function createDefaultSchema(): Schema;
-
-/**
- * Utility function to create a delta builder
- */
-export declare function createDelta(clientId: string, baseVersion: number): DeltaBuilder;
-
-export declare function createEditor(container: HTMLElement, config?: EditorConfig): NotectlEditor;
-
-/**
- * Create a node factory with the given schema
- */
-export declare function createNodeFactory(schema: Schema): NodeFactory;
-
-/**
- * Default maximum number of history entries to keep
- */
-export declare const DEFAULT_MAX_HISTORY_DEPTH = 100;
-
-/**
- * Default minimum height for the editor content area
- */
-export declare const DEFAULT_MIN_HEIGHT = 200;
-
-/**
- * Delete a block
- */
-export declare interface DeleteBlockOp extends BaseOperation {
-    op: 'delete_block';
-    target: {
-        blockId: BlockId;
-    };
-}
-
-/**
- * Delete text across a range
- */
-export declare interface DeleteRangeOp extends BaseOperation {
-    op: 'delete_range';
-    range: Range_2;
-}
-
-/**
- * Delta envelope containing operations and metadata
- */
-export declare interface Delta {
-    txnId: string;
-    clientId: string;
-    timestamp: string;
-    baseVersion: number;
-    ltime: number;
-    intent: 'edit' | 'comment' | 'format' | 'import' | string;
-    undoGroup?: string;
-    ops: Operation[];
-    inverseOps?: Operation[];
-    validation?: DeltaValidation;
-}
-
-/**
- * Delta class for creating and managing deltas
- */
-export declare class DeltaBuilder {
-    private delta;
-    private operations;
-    constructor(clientId: string, baseVersion: number);
-    /**
-     * Set the intent of this delta
-     */
-    setIntent(intent: Delta['intent']): this;
-    /**
-     * Set the undo group for batch operations
-     */
-    setUndoGroup(group: string): this;
-    /**
-     * Add an operation to this delta
-     */
-    addOperation(op: Operation): this;
-    /**
-     * Add multiple operations
-     */
-    addOperations(ops: Operation[]): this;
-    /**
-     * Set inverse operations for fast undo
-     */
-    setInverseOps(inverseOps: Operation[]): this;
-    /**
-     * Set validation constraints
-     */
-    setValidation(validation: DeltaValidation): this;
-    /**
-     * Build the final delta
-     */
-    build(): Delta;
-    /**
-     * Generate a unique transaction ID
-     */
-    private generateTxnId;
-}
-
-/**
- * Validation metadata for delta
- */
-export declare interface DeltaValidation {
-    requiresSchemaVersion: string;
-    constraints: ValidationConstraint[];
-}
-
-/**
- * Document structure
- */
-declare interface Document_2 {
-    version: number;
-    schemaVersion: string;
-    children: BlockNode[];
-}
-export { Document_2 as Document }
-
-/**
- * Timeout in milliseconds to wait for editor's connectedCallback to complete
- * and render the DOM structure including plugin containers.
- *
- * This is needed when registering plugins immediately after appending the editor
- * to the DOM, as the connectedCallback runs asynchronously.
- *
- * @example
- * ```typescript
- * const editor = document.createElement('notectl-editor');
- * container.appendChild(editor);
- * await new Promise(resolve => setTimeout(resolve, EDITOR_READY_TIMEOUT));
- * await editor.registerPlugin(new ToolbarPlugin());
- * ```
- */
-export declare const EDITOR_READY_TIMEOUT = 100;
-
-/**
- * Editor API interface
- * Public methods exposed by the NotectlEditor class
- */
-export declare interface EditorAPI {
-    configure(config: EditorConfig): void;
-    getContent(): Document_2 | string;
-    setContent(content: string, allowHTML?: boolean): void;
-    getHTML(): string;
-    setHTML(html: string): void;
-    getJSON(): Document_2;
-    setJSON(doc: Document_2): void;
-    exportHTML(): string;
-    getState(): unknown;
-    undo(): void;
-    redo(): void;
-    on(event: EditorEvent, callback: EditorEventCallback): void;
-    off(event: EditorEvent, callback: EditorEventCallback): void;
-    registerCommand(name: string, handler: (...args: unknown[]) => unknown): void;
-    executeCommand(name: string, ...args: unknown[]): unknown;
-    registerPlugin(plugin: unknown): Promise<void>;
-    unregisterPlugin(pluginId: string): Promise<void>;
-    focus(): void;
-    blur(): void;
-    destroy(): void;
-}
-
-/**
- * Editor configuration options
- */
-export declare interface EditorConfig {
-    initialContent?: Document_2;
-    placeholder?: string;
-    readonly?: boolean;
-    autofocus?: boolean;
-    sanitizeHTML?: boolean;
-    maxHistoryDepth?: number;
-    content?: string | Document_2;
-    [key: string]: unknown;
-}
-
-/**
- * Editor event types
- */
-export declare type EditorEvent = 'change' | 'selection-change' | 'content-change' | 'focus' | 'blur' | 'ready' | 'error' | 'plugin-registered' | 'plugin-unregistered';
-
-/**
- * Editor event callback
- */
-export declare type EditorEventCallback<T = unknown> = (data: T) => void;
-
-/**
- * Editor state class
- */
-export declare class EditorState {
-    private document;
-    private selection;
-    private history;
-    private historyIndex;
-    private maxHistoryDepth;
-    readonly schema: Schema;
-    readonly nodeFactory: NodeFactory;
-    constructor(initialDoc?: Document_2, schema?: Schema, options?: {
-        maxHistoryDepth?: number;
-    });
-    /**
-     * Get current document
-     */
-    getDocument(): Document_2;
-    /**
-     * Get document version
-     */
-    getVersion(): number;
-    /**
-     * Get current selection
-     */
-    getSelection(): Selection_2 | null;
-    /**
-     * Set selection
-     */
-    setSelection(selection: Selection_2 | null): void;
-    /**
-     * Apply a delta to the state
-     */
-    applyDelta(delta: Delta): void;
-    /**
-     * Apply a single operation
-     */
-    private applyOperation;
-    /**
-     * Apply insert text operation
-     */
-    private applyInsertText;
-    /**
-     * Apply delete range operation
-     */
-    private applyDeleteRange;
-    /**
-     * Apply mark operation
-     */
-    private applyMark;
-    /**
-     * Apply insert block after operation
-     */
-    private applyInsertBlockAfter;
-    /**
-     * Apply insert block before operation
-     */
-    private applyInsertBlockBefore;
-    /**
-     * Apply delete block operation
-     */
-    private applyDeleteBlock;
-    /**
-     * Apply set attributes operation
-     */
-    private applySetAttrs;
-    /**
-     * Find a block by ID
-     */
-    findBlock(blockId: BlockId): BlockNode | undefined;
-    /**
-     * Add delta to history
-     */
-    private addToHistory;
-    /**
-     * Undo last change
-     */
-    canUndo(): boolean;
-    undo(): Delta | null;
-    /**
-     * Redo last undone change
-     */
-    canRedo(): boolean;
-    redo(): Delta | null;
-    /**
-     * Export state as JSON
-     */
-    toJSON(): Document_2;
-    /**
-     * Create state from JSON
-     */
-    static fromJSON(json: Document_2, schema?: Schema): EditorState;
-}
-
-/**
- * Type for error codes
- */
-export declare type ErrorCode = typeof ErrorCodes[keyof typeof ErrorCodes];
-
-/**
- * Error codes for structured error handling
- */
-export declare const ErrorCodes: {
-    readonly PLUGIN_ALREADY_REGISTERED: "PLUGIN_ALREADY_REGISTERED";
-    readonly PLUGIN_NOT_FOUND: "PLUGIN_NOT_FOUND";
-    readonly PLUGIN_MISSING_DEPENDENCY: "PLUGIN_MISSING_DEPENDENCY";
-    readonly PLUGIN_INVALID_CONFIG: "PLUGIN_INVALID_CONFIG";
-    readonly PLUGIN_INIT_FAILED: "PLUGIN_INIT_FAILED";
-    readonly PLUGIN_DESTROY_FAILED: "PLUGIN_DESTROY_FAILED";
-    readonly PLUGIN_DEPENDENCY_CONFLICT: "PLUGIN_DEPENDENCY_CONFLICT";
-    readonly EDITOR_NOT_MOUNTED: "EDITOR_NOT_MOUNTED";
-    readonly EDITOR_NOT_INITIALIZED: "EDITOR_NOT_INITIALIZED";
-    readonly EDITOR_DESTROYED: "EDITOR_DESTROYED";
-    readonly COMMAND_NOT_FOUND: "COMMAND_NOT_FOUND";
-    readonly COMMAND_ALREADY_REGISTERED: "COMMAND_ALREADY_REGISTERED";
-    readonly COMMAND_EXECUTION_FAILED: "COMMAND_EXECUTION_FAILED";
-    readonly COMMAND_INVALID_ARGS: "COMMAND_INVALID_ARGS";
-    readonly INVALID_CONTENT: "INVALID_CONTENT";
-    readonly INVALID_DELTA: "INVALID_DELTA";
-    readonly INVALID_DOCUMENT: "INVALID_DOCUMENT";
-    readonly SANITIZATION_FAILED: "SANITIZATION_FAILED";
-    readonly XSS_DETECTED: "XSS_DETECTED";
-    readonly UNSAFE_OPERATION: "UNSAFE_OPERATION";
-    readonly INVALID_OPERATION: "INVALID_OPERATION";
-    readonly INTERNAL_ERROR: "INTERNAL_ERROR";
-};
-
-/**
- * Error response envelope
- */
-export declare interface ErrorEnvelope {
-    error: {
-        code: string;
-        message: string;
-        details?: unknown;
-    };
-}
-
-/**
- * Generate a unique block ID
- */
-export declare function generateBlockId(): BlockId;
-
-/**
- * Insert a block after another block
- */
-export declare interface InsertBlockAfterOp extends BaseOperation {
-    op: 'insert_block_after';
-    after: BlockId;
-    block: BlockNode;
-}
-
-/**
- * Insert a block before another block
- */
-export declare interface InsertBlockBeforeOp extends BaseOperation {
-    op: 'insert_block_before';
-    before: BlockId;
-    block: BlockNode;
-}
-
-/**
- * Insert text at a position
- */
-export declare interface InsertTextOp extends BaseOperation {
-    op: 'insert_text';
-    target: Position;
-    text: string;
-    marks?: Mark[];
-}
-
-export declare function isBlockOperation(op: Operation): op is InsertBlockBeforeOp | InsertBlockAfterOp | DeleteBlockOp | SetAttrsOp;
-
-export declare function isSelectionOperation(op: Operation): op is UpdateSelectionOp;
-
-export declare function isTableOperation(op: Operation): boolean;
-
-/**
- * Type guard for operation types
- */
-export declare function isTextOperation(op: Operation): op is InsertTextOp | DeleteRangeOp | ApplyMarkOp;
-
-/**
- * Lift blocks out of their container
- */
-export declare interface LiftOutOp extends BaseOperation {
-    op: 'lift_out';
-    blockIds: BlockId[];
-}
-
-/**
- * Text mark (inline formatting)
- */
-export declare interface Mark {
-    type: 'bold' | 'italic' | 'underline' | 'strikethrough' | 'code' | 'link' | string;
-    attrs?: Record<string, unknown>;
-}
-
-/**
- * Mark specification in the schema
- */
-export declare interface MarkSpec {
-    type: string;
-    attrs?: Record<string, AttributeSpec>;
-    inclusive?: boolean;
-    excludes?: string;
-    group?: string;
-    spanning?: boolean;
-    toDOM?: (mark: Mark) => [string, Record<string, string>];
-    parseDOM?: Array<{
-        tag?: string;
-        style?: string;
-        attrs?: Record<string, unknown>;
-    }>;
-}
-
-/**
- * Union of all node types
- */
-declare type Node_2 = TextNode | BlockNode;
-export { Node_2 as Node }
-
-/**
- * Node factory for creating valid nodes
- */
-export declare class NodeFactory {
-    private schema;
-    constructor(schema: Schema);
-    /**
-     * Create a text node
-     */
-    text(text: string, marks?: Mark[]): TextNode;
-    /**
-     * Create a paragraph node
-     */
-    paragraph(content?: TextNode[], attrs?: BlockAttrs): BlockNode;
-    /**
-     * Create a heading node
-     */
-    heading(level: number, content?: TextNode[], attrs?: BlockAttrs): BlockNode;
-    /**
-     * Create a list node
-     */
-    list(items: BlockNode[], attrs?: BlockAttrs): BlockNode;
-    /**
-     * Create a list item node
-     */
-    listItem(content: BlockNode[], attrs?: BlockAttrs): BlockNode;
-    /**
-     * Create a table node
-     */
-    table(rows: BlockNode[], attrs?: BlockAttrs): BlockNode;
-    /**
-     * Create a table row node
-     */
-    tableRow(cells: BlockNode[], attrs?: BlockAttrs): BlockNode;
-    /**
-     * Create a table cell node
-     */
-    tableCell(content: BlockNode[], attrs?: BlockAttrs): BlockNode;
-    /**
-     * Create an image node
-     */
-    image(src: string, alt?: string, attrs?: BlockAttrs): BlockNode;
-    /**
-     * Create a code block node
-     */
-    codeBlock(content: string, attrs?: BlockAttrs): BlockNode;
-    /**
-     * Create a generic block node
-     */
-    block(type: NodeType, attrs?: BlockAttrs, children?: (TextNode | BlockNode)[]): BlockNode;
-    /**
-     * Create a mark
-     */
-    mark(type: string, attrs?: Record<string, unknown>): Mark;
-    /**
-     * Clone a node with new children
-     */
-    cloneNode(node: BlockNode, children?: (TextNode | BlockNode)[]): BlockNode;
-}
-
-/**
- * Node specification in the schema
- */
-export declare interface NodeSpec {
-    type: NodeType;
-    group?: 'block' | 'inline' | 'table';
-    content?: string;
-    marks?: string;
-    attrs?: Record<string, AttributeSpec>;
-    defining?: boolean;
-    isolating?: boolean;
-    toDOM?: (node: Node_2) => HTMLElement | [string, Record<string, string>, ...unknown[]];
-    parseDOM?: Array<{
-        tag?: string;
-        attrs?: Record<string, unknown>;
-    }>;
-}
-
-/**
- * Node types in the document
- */
-export declare type NodeType = 'text' | 'paragraph' | 'heading' | 'list' | 'list_item' | 'table' | 'table_row' | 'table_cell' | 'image' | 'code_block' | string;
-
-/**
- * NotectlEditor custom element
- */
-export declare class NotectlEditor extends HTMLElement {
-    private state;
-    private pluginManager;
-    private eventListeners;
-    private commands;
-    private contentElement;
-    private pluginContainerTop;
-    private pluginContainerBottom;
-    private config;
-    private keyboardShortcutCleanup?;
-    private ariaLiveRegion;
-    private pendingPlugins;
-    private readyPromise;
-    private readyResolve?;
-    private isReady;
-    constructor();
-    /**
-     * Observed attributes for the web component
-     */
-    static get observedAttributes(): string[];
-    /**
-     * Called when element is connected to DOM
-     */
-    connectedCallback(): Promise<void>;
-    /**
-     * Called when element is disconnected from DOM
-     */
-    disconnectedCallback(): void;
-    /**
-     * Called when attributes change
-     */
-    attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
-    /**
-     * Render the editor UI
-     */
-    private render;
-    /**
-     * Render document content
-     */
-    private renderContent;
-    /**
-     * Convert document to HTML
-     */
-    private documentToHTML;
-    /**
-     * Convert block to HTML (simplified)
-     */
-    private blockToHTML;
-    /**
-     * Convert children to HTML
-     */
-    private childrenToHTML;
-    /**
-     * Apply mark as HTML
-     */
-    private applyMarkHTML;
-    /**
-     * Escape HTML
-     */
-    private escapeHTML;
-    private tableToHTML;
-    private tableRowToHTML;
-    private tableCellToHTML;
-    private styleObjectToString;
-    /**
-     * Setup accessibility features
-     */
-    private setupAccessibility;
-    /**
-     * Setup keyboard shortcuts with screen reader announcements
-     */
-    private setupKeyboardShortcuts;
-    /**
-     * Toggle formatting
-     */
-    private toggleFormat;
-    /**
-     * Insert table at current selection
-     */
-    insertTable(rows?: number, cols?: number): void;
-    /**
-     * Announce message to screen readers
-     */
-    private announceToScreenReader;
-    /**
-     * Attach event listeners
-     */
-    private attachEventListeners;
-    /**
-     * Detach event listeners
-     */
-    private detachEventListeners;
-    /**
-     * Handle input event
-     */
-    private handleInput;
-    /**
-     * Handle keydown event
-     */
-    private handleKeydown;
-    /**
-     * Handle focus event
-     */
-    private handleFocus;
-    /**
-     * Handle blur event
-     */
-    private handleBlur;
-    private handleContextMenu;
-    /**
-     * Update placeholder visibility
-     */
-    private updatePlaceholder;
-    /**
-     * Sync content from DOM to state
-     */
-    private syncContentToState;
-    /**
-     * Convert HTML to document structure
-     */
-    private htmlToDocument;
-    /**
-     * Convert DOM node to block
-     */
-    private nodeToBlock;
-    /**
-     * Parse children nodes
-     */
-    private parseChildren;
-    /**
-     * Parse inline element with marks
-     */
-    private parseInlineElement;
-    /**
-     * Update readonly state
-     */
-    private updateReadonly;
-    /**
-     * Register a plugin
-     *
-     * Plugins can be registered before or after the editor is mounted.
-     * If registered before mounting, they will be queued and initialized
-     * automatically when the editor connects to the DOM.
-     *
-     * @param plugin - The plugin to register
-     * @returns Promise that resolves when the plugin is registered
-     */
-    registerPlugin(plugin: Plugin_2): Promise<void>;
-    /**
-     * Unregister a plugin
-     */
-    unregisterPlugin(pluginId: string): Promise<void>;
-    /**
-     * Wait for the editor to be ready
-     *
-     * Returns a Promise that resolves when the editor has been mounted
-     * and all pending plugins have been initialized. This is useful when
-     * you need to ensure the editor is fully initialized before performing
-     * operations that depend on the editor being mounted.
-     *
-     * @returns Promise that resolves when the editor is ready
-     * @example
-     * ```typescript
-     * const editor = document.createElement('notectl-editor');
-     * container.appendChild(editor);
-     * await editor.whenReady();
-     * // Editor is now fully initialized
-     * ```
-     */
-    whenReady(): Promise<void>;
-    /**
-     * Get the block containing the current selection
-     */
-    private getSelectedBlock;
-    /**
-     * Find all blocks of a specific type
-     */
-    private findBlocksByType;
-    /**
-     * Find parent block of a given block
-     */
-    private findParentBlock;
-    /**
-     * Get block at current cursor position
-     */
-    private getBlockAtCursor;
-    /**
-     * Insert a block after another block (Delta-based)
-     */
-    private insertBlockAfter;
-    /**
-     * Insert a block before another block (Delta-based)
-     */
-    private insertBlockBefore;
-    /**
-     * Update block attributes (Delta-based)
-     */
-    private updateBlockAttrs;
-    /**
-     * Delete a block (Delta-based)
-     */
-    private deleteBlockById;
-    /**
-     * Add mark to current selection (Delta-based)
-     */
-    private addMarkToSelection;
-    /**
-     * Remove mark from current selection (Delta-based)
-     */
-    private removeMarkFromSelection;
-    /**
-     * Toggle mark on current selection (Delta-based)
-     */
-    private toggleMarkOnSelection;
-    /**
-     * Create plugin context
-     */
-    private createPluginContext;
-    /**
-     * Apply a delta
-     */
-    applyDelta(delta: Delta): void;
-    /**
-     * Register event listener
-     */
-    on(event: EditorEvent, callback: EditorEventCallback): void;
-    /**
-     * Unregister event listener
-     */
-    off(event: EditorEvent, callback: EditorEventCallback): void;
-    /**
-     * Emit event
-     */
-    private emit;
-    /**
-     * Register command
-     */
-    registerCommand(name: string, handler: CommandHandler): void;
-    /**
-     * Execute command
-     */
-    executeCommand(name: string, ...args: unknown[]): unknown;
-    /**
-     * Undo last change
-     */
-    undo(): void;
-    /**
-     * Redo last undone change
-     */
-    redo(): void;
-    /**
-     * Configure editor options
-     * @param config - Configuration options to apply
-     */
-    configure(config: EditorConfig): void;
-    /**
-     * Destroy the editor and clean up resources
-     */
-    destroy(): void;
-    /**
-     * Get current content as string or JSON
-     * @returns Current document content
-     */
-    getContent(): Document_2 | string;
-    /**
-     * Get current state
-     */
-    getState(): EditorState;
-    /**
-     * Get document as JSON
-     */
-    getJSON(): Document_2;
-    /**
-     * Set document from JSON
-     */
-    setJSON(doc: Document_2): void;
-    /**
-     * Get HTML content (sanitized)
-     */
-    getHTML(): string;
-    /**
-     * Set HTML content (with sanitization)
-     * @param html - HTML content to set
-     */
-    setHTML(html: string): void;
-    /**
-     * Set content from string (with sanitization)
-     * @param content - Content to set
-     * @param allowHTML - Allow HTML tags
-     */
-    setContent(content: string, allowHTML?: boolean): void;
-    /**
-     * Export HTML content (sanitized)
-     * @returns Sanitized HTML
-     */
-    exportHTML(): string;
-    /**
-     * Focus the editor
-     */
-    focus(): void;
-    /**
-     * Blur the editor
-     */
-    blur(): void;
-}
-
-/**
- * Structured error class for Notectl
- */
-export declare class NotectlError extends Error {
-    code: ErrorCode;
-    details?: unknown | undefined;
-    constructor(code: ErrorCode, message: string, details?: unknown | undefined);
-    /**
-     * Convert to JSON-serializable format
-     */
-    toJSON(): {
-        error: {
-            code: ErrorCode;
-            message: string;
-            details: unknown;
-        };
-    };
-}
-
-/**
- * Union of all operation types
- */
-export declare type Operation = InsertTextOp | DeleteRangeOp | ApplyMarkOp | InsertBlockBeforeOp | InsertBlockAfterOp | DeleteBlockOp | SetAttrsOp | WrapInOp | LiftOutOp | TableInsertRowOp | TableDeleteRowOp | TableInsertColOp | TableDeleteColOp | TableMergeCellsOp | TableSplitCellOp | UpdateSelectionOp;
-
-/**
- * Plugin interface
- */
-declare interface Plugin_2 {
-    /**
-     * Unique plugin identifier
-     */
-    id: string;
-    /**
-     * Plugin name
-     */
-    name: string;
-    /**
-     * Plugin version
-     */
-    version: string;
-    /**
-     * Plugin dependencies (optional)
-     */
-    dependencies?: string[];
-    /**
-     * Initialize the plugin
-     */
-    init(context: PluginContext): Promise<void> | void;
-    /**
-     * Cleanup the plugin
-     */
-    destroy?(): Promise<void> | void;
-    /**
-     * Handle state updates (optional)
-     */
-    onStateUpdate?(oldState: EditorState, newState: EditorState): void;
-    /**
-     * Handle delta application (optional)
-     */
-    onDeltaApplied?(delta: Delta): void;
-}
-export { Plugin_2 as Plugin }
-
-/**
- * Plugin context provided to plugins
- */
-export declare interface PluginContext {
-    /**
-     * Get current editor state
-     */
-    getState(): EditorState;
-    /**
-     * Apply a delta to the editor
-     */
-    applyDelta(delta: Delta): void;
-    /**
-     * Get current selection
-     */
-    getSelection(): Selection_2 | null;
-    /**
-     * Set selection
-     */
-    setSelection(selection: Selection_2): void;
-    /**
-     * Get the block containing the current cursor/selection
-     */
-    getSelectedBlock(): BlockNode | null;
-    /**
-     * Find all blocks of a specific type
-     * @param type - Block type to search for (e.g., 'table', 'heading', 'paragraph')
-     * @returns Array of matching blocks
-     */
-    findBlocksByType(type: string): BlockNode[];
-    /**
-     * Find a block by its ID
-     * @param blockId - Block identifier
-     * @returns Block or undefined if not found
-     */
-    findBlockById(blockId: BlockId): BlockNode | undefined;
-    /**
-     * Find parent block of a given block
-     * @param block - Child block
-     * @returns Parent block or null if block is at root level
-     */
-    findParentBlock(block: BlockNode): BlockNode | null;
-    /**
-     * Get block at current cursor position
-     */
-    getBlockAtCursor(): BlockNode | null;
-    /**
-     * Insert a block after another block
-     * @param block - Block to insert
-     * @param afterId - ID of block to insert after (if undefined, appends to end)
-     */
-    insertBlockAfter(block: BlockNode, afterId?: BlockId): void;
-    /**
-     * Insert a block before another block
-     * @param block - Block to insert
-     * @param beforeId - ID of block to insert before (if undefined, prepends to start)
-     */
-    insertBlockBefore(block: BlockNode, beforeId?: BlockId): void;
-    /**
-     * Update block attributes
-     * @param blockId - Block to update
-     * @param attrs - Attributes to merge
-     */
-    updateBlockAttrs(blockId: BlockId, attrs: Record<string, unknown>): void;
-    /**
-     * Delete a block
-     * @param blockId - Block to delete
-     */
-    deleteBlock(blockId: BlockId): void;
-    /**
-     * Add mark to current selection
-     * @param mark - Mark to add
-     */
-    addMark(mark: Mark): void;
-    /**
-     * Remove mark from current selection
-     * @param markType - Type of mark to remove
-     */
-    removeMark(markType: string): void;
-    /**
-     * Toggle mark on current selection
-     * @param markType - Type of mark to toggle
-     */
-    toggleMark(markType: string): void;
-    /**
-     * Register event listener
-     */
-    on(event: string, callback: (data: unknown) => void): void;
-    /**
-     * Unregister event listener
-     */
-    off(event: string, callback: (data: unknown) => void): void;
-    /**
-     * Emit an event
-     */
-    emit(event: string, data?: unknown): void;
-    /**
-     * Register a command
-     */
-    registerCommand(name: string, handler: CommandHandler): void;
-    /**
-     * Execute a command
-     */
-    executeCommand(name: string, ...args: unknown[]): unknown;
-    /**
-     * Access DOM container (editable area)
-     * @deprecated Prefer using Delta operations instead of direct DOM manipulation
-     */
-    getContainer(): HTMLElement;
-    /**
-     * Access plugin container for UI elements (toolbar, etc.)
-     * @param position - 'top' or 'bottom'
-     */
-    getPluginContainer(position: 'top' | 'bottom'): HTMLElement;
-}
-
-/**
- * Plugin factory function type
- */
-export declare type PluginFactory<TConfig = unknown> = (config?: TConfig) => Plugin_2;
-
-/**
- * Plugin manager class
- */
-export declare class PluginManager {
-    private plugins;
-    private initializationOrder;
-    constructor();
-    /**
-     * Register a plugin
-     *
-     * @param plugin - The plugin to register
-     * @param context - Plugin context with editor APIs
-     * @throws {NotectlError} If plugin validation fails or initialization errors occur
-     *
-     * @example
-     * ```typescript
-     * const toolbarPlugin = new ToolbarPlugin();
-     * await pluginManager.register(toolbarPlugin, context);
-     * ```
-     */
-    register(plugin: Plugin_2, context: PluginContext): Promise<void>;
-    /**
-     * Unregister a plugin
-     *
-     * @param pluginId - ID of the plugin to unregister
-     * @param context - Plugin context for event emission
-     * @throws {NotectlError} If plugin is not found or has dependents
-     *
-     * @example
-     * ```typescript
-     * await pluginManager.unregister('toolbar-plugin', context);
-     * ```
-     */
-    unregister(pluginId: string, context: PluginContext): Promise<void>;
-    /**
-     * Get a plugin by ID
-     */
-    get(pluginId: string): Plugin_2 | undefined;
-    /**
-     * Check if a plugin is registered
-     */
-    has(pluginId: string): boolean;
-    /**
-     * Get all registered plugins
-     */
-    getAll(): Plugin_2[];
-    /**
-     * Notify plugins of state update
-     */
-    notifyStateUpdate(oldState: EditorState, newState: EditorState): void;
-    /**
-     * Notify plugins of delta application
-     */
-    notifyDeltaApplied(delta: Delta): void;
-    /**
-     * Destroy all plugins
-     */
-    destroyAll(): Promise<void>;
-}
-
-/**
- * Text position within a block (code point offset)
- */
-export declare interface Position {
-    blockId: BlockId;
-    offset: number;
-}
-
-/**
- * Range of text across blocks
- */
-declare interface Range_2 {
-    start: Position;
-    end: Position;
-}
-export { Range_2 as Range }
-
-/**
- * Document schema
- */
-export declare class Schema {
-    nodes: Map<NodeType, NodeSpec>;
-    marks: Map<string, MarkSpec>;
-    topNode: NodeType;
-    constructor(config: {
-        nodes: NodeSpec[];
-        marks: MarkSpec[];
-        topNode?: NodeType;
-    });
-    /**
-     * Get node specification
-     */
-    node(type: NodeType): NodeSpec | undefined;
-    /**
-     * Get mark specification
-     */
-    mark(type: string): MarkSpec | undefined;
-    /**
-     * Validate if a node conforms to the schema
-     */
-    validateNode(node: Node_2): {
-        valid: boolean;
-        errors: string[];
-    };
-    /**
-     * Check if a mark is allowed on a node
-     */
-    markAllowedOn(markType: string, nodeType: NodeType): boolean;
-    /**
-     * Check if two marks can coexist
-     */
-    marksCompatible(markA: string, markB: string): boolean;
-}
-
-/**
- * Selection state
- */
-declare interface Selection_2 {
-    anchor: Position;
-    head: Position;
-}
-export { Selection_2 as Selection }
-
-/**
- * Selection helper utilities
- */
-export declare interface SelectionHelpers {
-    /**
-     * Check if selection is collapsed (cursor)
-     */
-    isCollapsed(selection: Selection_2): boolean;
-    /**
-     * Check if selection spans multiple blocks
-     */
-    isMultiBlock(selection: Selection_2): boolean;
-    /**
-     * Get the direction of selection (forward/backward)
-     */
-    getDirection(selection: Selection_2): 'forward' | 'backward' | 'none';
-    /**
-     * Create a collapsed selection at a position
-     */
-    createCollapsed(position: Position): Selection_2;
-    /**
-     * Create a selection range
-     */
-    createRange(start: Position, end: Position): Selection_2;
-}
-
-/**
- * Selection helper implementation
- */
-export declare const selectionHelpers: SelectionHelpers;
-
-/**
- * Set attributes on a block
- */
-export declare interface SetAttrsOp extends BaseOperation {
-    op: 'set_attrs';
-    target: {
-        blockId: BlockId;
-    };
-    attrs: BlockAttrs;
-}
-
-/**
- * Table cell structure
- */
-export declare interface TableCell {
-    id?: string;
-    content: string;
-    rowSpan?: number;
-    colSpan?: number;
-    attrs?: {
-        style?: Record<string, string | number>;
-        [key: string]: unknown;
-    };
-}
-
-/**
- * Table structure for attributes
- */
-export declare interface TableData {
-    rows: TableRow[];
-}
-
-/**
- * Table operation: delete column
- */
-export declare interface TableDeleteColOp extends BaseOperation {
-    op: 'table_delete_col';
-    target: {
-        tableId: BlockId;
-        colIndex: number;
-    };
-}
-
-/**
- * Table operation: delete row
- */
-export declare interface TableDeleteRowOp extends BaseOperation {
-    op: 'table_delete_row';
-    target: {
-        tableId: BlockId;
-        rowIndex: number;
-    };
-}
-
-/**
- * Table operation: insert column
- */
-export declare interface TableInsertColOp extends BaseOperation {
-    op: 'table_insert_col';
-    target: {
-        tableId: BlockId;
-        colIndex: number;
-    };
-}
-
-/**
- * Table operation: insert row
- */
-export declare interface TableInsertRowOp extends BaseOperation {
-    op: 'table_insert_row';
-    target: {
-        tableId: BlockId;
-        rowIndex: number;
-    };
-    row: BlockNode;
-}
-
-/**
- * Table operation: merge cells
- */
-export declare interface TableMergeCellsOp extends BaseOperation {
-    op: 'table_merge_cells';
-    target: {
-        tableId: BlockId;
-        cells: BlockId[];
-    };
-}
-
-/**
- * Table row structure
- */
-export declare interface TableRow {
-    id?: string;
-    cells: TableCell[];
-    attrs?: {
-        style?: Record<string, string | number>;
-        [key: string]: unknown;
-    };
-}
-
-/**
- * Table operation: split cell
- */
-export declare interface TableSplitCellOp extends BaseOperation {
-    op: 'table_split_cell';
-    target: {
-        tableId: BlockId;
-        cellId: BlockId;
-    };
-}
-
-/**
- * Text node
- */
-export declare interface TextNode {
-    type: 'text';
-    text: string;
-    marks?: Mark[];
-}
-
-/**
- * Transform a delta against another delta
- * Returns transformed version of deltaA that can be applied after deltaB
- */
-export declare function transformDelta(deltaA: Delta, deltaB: Delta, side?: 'left' | 'right'): Delta;
-
-/**
- * Transform operation A against operation B
- * Returns transformed version of A that can be applied after B
- */
-export declare function transformOperation(opA: Operation, opB: Operation, side: 'left' | 'right'): Operation;
-
-/**
- * Update selection/cursor
- */
-export declare interface UpdateSelectionOp extends BaseOperation {
-    op: 'update_selection';
-    actorId: string;
-    selection: {
-        anchor: Position;
-        head: Position;
-    };
-}
-
-/**
- * Validate a delta against constraints
- */
-export declare function validateDelta(delta: Delta): {
-    valid: boolean;
-    errors: string[];
-};
-
-/**
- * Validation constraint types
- */
-export declare type ValidationConstraint = 'noDanglingRefs' | 'tableGridConsistent' | 'altOrDecorative' | 'rtlIntegrity' | string;
-
-/**
- * Validation constraints for document structure
- */
-export declare const ValidationConstraints: {
-    readonly NO_DANGLING_REFS: "noDanglingRefs";
-    readonly TABLE_GRID_CONSISTENT: "tableGridConsistent";
-    readonly ALT_OR_DECORATIVE: "altOrDecorative";
-    readonly RTL_INTEGRITY: "rtlIntegrity";
-};
-
-export declare const VERSION = "0.0.1";
-
-/**
- * Wrap blocks in a container
- */
-export declare interface WrapInOp extends BaseOperation {
-    op: 'wrap_in';
-    blockIds: BlockId[];
-    wrapperType: string;
-    wrapperAttrs?: BlockAttrs;
-}
-
-export { }