@notectl/core 0.0.2 → 0.0.6

package/dist/types/index.d.ts

@@ -1,1090 +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;
-}
-
-/**
- * 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;
-}
-
-/**
- * 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 handler function
- */
-export declare type CommandHandler = (...args: 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;
-
-/**
- * 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 }
-
-/**
- * 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;
-    [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;
-}
-
-/**
- * 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;
-    constructor();
-    /**
-     * Observed attributes for the web component
-     */
-    static get observedAttributes(): string[];
-    /**
-     * Called when element is connected to DOM
-     */
-    connectedCallback(): 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;
-    /**
-     * 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;
-    /**
-     * 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
-     */
-    registerPlugin(plugin: Plugin_2): Promise<void>;
-    /**
-     * Unregister a plugin
-     */
-    unregisterPlugin(pluginId: string): Promise<void>;
-    /**
-     * 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;
-}
-
-/**
- * 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;
-    /**
-     * 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)
-     */
-    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
-     */
-    register(plugin: Plugin_2, context: PluginContext): Promise<void>;
-    /**
-     * Unregister a plugin
-     */
-    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 }
-
-/**
- * Set attributes on a block
- */
-export declare interface SetAttrsOp extends BaseOperation {
-    op: 'set_attrs';
-    target: {
-        blockId: BlockId;
-    };
-    attrs: BlockAttrs;
-}
-
-/**
- * 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 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;
-
-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 { }