@lit-pigeon/editor 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,839 @@
+import { AssetManagerConfig } from '@lit-pigeon/core';
+import { AssetStorage } from '@lit-pigeon/core';
+import { ButtonBlock } from '@lit-pigeon/core';
+import { ColumnNode } from '@lit-pigeon/core';
+import { CSSResult } from 'lit';
+import { DividerBlock } from '@lit-pigeon/core';
+import { EditorConfig } from '@lit-pigeon/core';
+import { HeroBlock } from '@lit-pigeon/core';
+import { HtmlBlock } from '@lit-pigeon/core';
+import { ImageBlock } from '@lit-pigeon/core';
+import { LitElement } from 'lit';
+import { MergeTag } from '@lit-pigeon/core';
+import { NavBarBlock } from '@lit-pigeon/core';
+import { PigeonDocument } from '@lit-pigeon/core';
+import { Renderer } from '@lit-pigeon/core';
+import { RowNode } from '@lit-pigeon/core';
+import { Selection as Selection_2 } from '@lit-pigeon/core';
+import { SocialBlock } from '@lit-pigeon/core';
+import { SpacerBlock } from '@lit-pigeon/core';
+import { Spacing } from '@lit-pigeon/core';
+import { TemplateResult } from 'lit';
+import { TemplateStorage } from '@lit-pigeon/core';
+import { TextBlock } from '@lit-pigeon/core';
+
+/**
+ * Given a Y coordinate and a list of block elements within a column,
+ * determine which block gap the cursor is closest to.
+ */
+export declare function calculateBlockDropIndex(clientY: number, blockElements: HTMLElement[]): number;
+
+/**
+ * Given a Y coordinate and a list of row elements, determine
+ * which row gap the cursor is closest to.
+ */
+export declare function calculateRowDropIndex(clientY: number, rowElements: HTMLElement[]): number;
+
+export declare function clearDragData(): void;
+
+export declare interface DragData {
+    type: DragItemType;
+    /** Block type for palette-block drags (e.g. 'text', 'image') */
+    blockType?: string;
+    /** Number of columns for palette-row drags */
+    columnCount?: number;
+    /** Existing block info for rearranging */
+    blockId?: string;
+    rowId?: string;
+    columnId?: string;
+}
+
+/**
+ * Drag-and-drop manager using native HTML5 drag/drop API.
+ * Stores drag state globally so any component can query it.
+ */
+export declare type DragItemType = 'palette-block' | 'palette-row' | 'existing-block' | 'existing-row';
+
+/**
+ * Drop-zone calculation utilities.
+ * Given a mouse position and the set of rendered rows/columns/blocks,
+ * determines where the dragged item should be inserted.
+ */
+export declare interface DropTarget {
+    /** 'row' means inserting a new row between existing rows */
+    zone: 'row' | 'block';
+    /** Index to insert the row at (for zone=row) */
+    rowIndex?: number;
+    /** IDs for block drops */
+    rowId?: string;
+    columnId?: string;
+    /** Index within the column's block list */
+    blockIndex?: number;
+}
+
+export declare function getDragData(): DragData | null;
+
+export declare class PigeonAlignmentPicker extends LitElement {
+    label: string;
+    value: 'left' | 'center' | 'right';
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+    private _select;
+}
+
+export declare class PigeonAssetManager extends LitElement {
+    config: AssetManagerConfig;
+    /**
+     * Optional asset library. When set, the modal shows a "Library" tab where
+     * users browse and pick previously-saved assets; folders, search, and tag
+     * filters all run through `AssetStorage.list()`.
+     */
+    storage?: AssetStorage;
+    open: boolean;
+    /**
+     * Explicit tab selection — `null` means "use the default for the current
+     * storage state" (library when a storage is attached, upload otherwise).
+     * Updating only when the user explicitly clicks a tab keeps Lit's update
+     * cycle out of an update→state→update loop on initial property arrival.
+     */
+    private _tab;
+    private _dragOver;
+    private _uploading;
+    private _progress;
+    private _error;
+    private _urlInput;
+    /** Library state. */
+    private _folder;
+    private _search;
+    private _selectedTags;
+    private _folders;
+    private _assets;
+    private _libraryLoading;
+    private _libraryError;
+    private _searchTimer;
+    /**
+     * Monotonic token for in-flight library queries. The latest token wins so
+     * a slow folder switch can't overwrite a faster subsequent search.
+     */
+    private _libraryToken;
+    static styles: CSSResult;
+    updated(changed: Map<string, unknown>): void;
+    private get _activeTab();
+    render(): TemplateResult<1>;
+    private _renderTabs;
+    private _renderLibrary;
+    private _renderAssetCard;
+    private _renderUpload;
+    private _loadFolders;
+    private _loadAssets;
+    /** Distinct tags surfaced by the *current* result set. */
+    private get _availableTags();
+    private _onFolderChange;
+    private _onSearchInput;
+    private _toggleTag;
+    private get _acceptedTypes();
+    private _close;
+    private _openFilePicker;
+    private _onDragOver;
+    private _onDragLeave;
+    private _onDrop;
+    private _onFileSelected;
+    private _handleFile;
+    private _useUrl;
+    private _selectAsset;
+}
+
+export declare class PigeonBodyPanel extends LitElement {
+    doc: PigeonDocument;
+    mergeTags: MergeTag[];
+    private _pickerOpen;
+    private _pickerX;
+    private _pickerY;
+    private _previewInputRef;
+    private _triggerRef;
+    static styles: CSSResult[];
+    private _fontFamilies;
+    render(): TemplateResult<1>;
+    private _togglePicker;
+    private _onMergeTagInsert;
+    private _emit;
+    private _onWidthChange;
+    private _onBgColorChange;
+    private _onFontFamilyChange;
+    private _onAlignChange;
+    private _onNameChange;
+    private _onPreviewTextChange;
+}
+
+export declare class PigeonButtonBlock extends LitElement {
+    block: ButtonBlock;
+    selected: boolean;
+    editing: boolean;
+    private _editor;
+    private _editorHost;
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+    updated(changed: Map<string, unknown>): void;
+    disconnectedCallback(): void;
+    private _mountEditor;
+    private _teardownEditor;
+    private _commit;
+    private _exit;
+    private _preventNav;
+    private _handleClick;
+    private _handleDblClick;
+}
+
+export declare class PigeonButtonPanel extends LitElement {
+    block: ButtonBlock;
+    rowId: string;
+    columnId: string;
+    static styles: CSSResult[];
+    render(): TemplateResult<1>;
+    private _emit;
+    private _onTextChange;
+    private _contentToText;
+    private _onHrefChange;
+    private _onBgColorChange;
+    private _onTextColorChange;
+    private _onBorderRadiusChange;
+    private _onFontSizeChange;
+    private _onFontWeightChange;
+    private _onAlignChange;
+    private _onFullWidthChange;
+    private _onPaddingChange;
+    private _onInnerPaddingChange;
+}
+
+export declare class PigeonCanvas extends LitElement {
+    doc: PigeonDocument;
+    selection: Selection_2 | null;
+    editingBlockId: string | null;
+    previewWidth: number;
+    /**
+     * Active device preset. Drives the device-frame chrome around the canvas;
+     * `desktop` shows no frame, `tablet`/`mobile` wrap the sheet in a bezel.
+     */
+    device: 'desktop' | 'tablet' | 'mobile';
+    private _rowDropIndex;
+    private _isDragOver;
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+    /**
+     * The email "sheet" — the canvas-area and its rows. Rendered standalone on
+     * desktop, or nested inside a device frame for tablet/mobile. When framed,
+     * `bg` paints the document background onto the sheet itself (the area behind
+     * the frame stays neutral).
+     */
+    private _renderCanvasArea;
+    private _onCanvasClick;
+    private _onDragOver;
+    private _onDragLeave;
+    private _onDrop;
+    private _resetDragState;
+}
+
+export declare class PigeonColorPicker extends LitElement {
+    label: string;
+    value: string;
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+    private _onColorInput;
+    private _onTextChange;
+    private _emitChange;
+}
+
+export declare class PigeonColumn extends LitElement {
+    column: ColumnNode;
+    rowId: string;
+    selection: Selection_2 | null;
+    editingBlockId: string | null;
+    private _dropIndex;
+    private _isDragOver;
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+    private _renderBlock;
+    /**
+     * Render a registry-defined custom block. If its definition supplies a
+     * `renderCanvas` hook, its HTML is shown; otherwise we render a labelled
+     * placeholder so the block is still visible and selectable instead of
+     * failing with "Unknown block type".
+     */
+    private _renderCustomBlock;
+    private _onCustomBlockClick;
+    private _onDragOver;
+    private _onDragLeave;
+    private _onDrop;
+}
+
+export declare class PigeonDividerBlock extends LitElement {
+    block: DividerBlock;
+    selected: boolean;
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+    private _handleClick;
+}
+
+export declare class PigeonDropIndicator extends LitElement {
+    visible: boolean;
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+}
+
+/**
+ * `<pigeon-editor>` -- the main shell component for the Pigeon email editor.
+ *
+ * @element pigeon-editor
+ * @fires pigeon:change - Fired whenever the document changes
+ * @fires pigeon:select - Fired when the selection changes
+ * @fires pigeon:ready  - Fired once after the editor has initialised
+ * @fires pigeon:preview - Fired when the user clicks Preview in the toolbar
+ * @fires pigeon:export  - Fired when the user clicks Export in the toolbar
+ * @fires pigeon:export-json - Fired for JSON export
+ * @fires pigeon:export-mjml - Fired for MJML export
+ * @fires pigeon:export-html - Fired for HTML export
+ * @fires pigeon:merge-tag-request - Fired when merge tag trigger detected but no static tags
+ *
+ * @csspart toolbar - The toolbar area
+ * @csspart palette - The left palette area
+ * @csspart canvas  - The central canvas area
+ * @csspart properties - The right property panel area
+ * @csspart canvas-area - The email "sheet" inside the canvas (the rendered body)
+ * @csspart panel - The active property-panel wrapper
+ * @csspart palette-tab - A palette tab button (Content / Layers)
+ * @csspart palette-item - A draggable block/layout chip in the palette
+ * @csspart toolbar-button - Any toolbar button; also has a per-action part:
+ *   toolbar-button-{undo,redo,fullscreen,templates,preview,export}
+ *
+ * @cssprop [--pigeon-primary] - Brand / primary action colour
+ * @cssprop [--pigeon-bg] - Editor surface background
+ * @cssprop [--pigeon-text] - Primary text colour
+ * @cssprop [--pigeon-border] - Hairline border colour
+ * @cssprop [--pigeon-ring] - Focus-ring colour
+ * @cssprop [--pigeon-radius] - Base corner radius
+ *   (see src/themes/tokens.ts for the full token set)
+ */
+export declare class PigeonEditor extends LitElement {
+    /** Optional initial document. If not set a blank document is created. */
+    document: PigeonDocument | undefined;
+    /**
+     * Colour theme for the editor chrome.
+     *
+     * - `light` (default) — light tokens.
+     * - `dark` — dark tokens applied unconditionally.
+     * - `auto` — follows the OS `prefers-color-scheme`.
+     *
+     * Reflected to an attribute so it can be set declaratively
+     * (`<pigeon-editor theme="dark">`). Override individual tokens with the
+     * `themeOverrides` map or plain CSS (`pigeon-editor { --pigeon-…: … }`).
+     */
+    theme: 'light' | 'dark' | 'auto';
+    /**
+     * Partial map of design-token overrides applied as inline custom properties
+     * on the host, e.g. `{ '--pigeon-primary': '#db2777' }`. Useful for
+     * white-labelling without writing CSS. Merged on top of the active theme.
+     */
+    themeOverrides: Record<string, string>;
+    /** Additional editor configuration passed to EditorState.create(). */
+    config: Partial<EditorConfig>;
+    /** Optional renderer for preview mode. */
+    renderer?: Renderer;
+    /** Optional function to convert document to MJML. */
+    documentToMjml?: (doc: PigeonDocument) => string;
+    /**
+     * Optional template storage backend. When unset, the editor falls back to
+     * an in-memory storage seeded with the starter templates so the picker is
+     * useful out of the box.
+     */
+    templateStorage?: TemplateStorage;
+    /**
+     * Optional asset library backend. When set, the asset modal shows a
+     * "Library" tab next to "Upload" so users can browse previously-saved
+     * assets (folders, search, tag filters) without re-uploading. Falls back to
+     * `config.assetStorage` if not set directly. Without either, the modal
+     * keeps its current upload-only behaviour.
+     */
+    assetStorage?: AssetStorage;
+    private _state;
+    private _canUndo;
+    private _canRedo;
+    private _device;
+    private _fullscreen;
+    private _previewOpen;
+    private _templatePickerOpen;
+    private _templatePickerLoaded;
+    /** Block currently in inline rich-text editing mode, or null when none. */
+    private _editingBlockId;
+    /** Lazily-initialised default template storage. */
+    private _defaultTemplateStorage?;
+    /** In-memory clipboard for Cmd/Ctrl+C / Cmd/Ctrl+V on blocks. */
+    private _clipboard;
+    static styles: CSSResult[];
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    updated(changed: Map<string, unknown>): void;
+    /**
+     * Sync the active `theme` to the host classes the token sheet keys off, and
+     * apply any `themeOverrides` as inline custom properties.
+     */
+    private _applyTheme;
+    firstUpdated(): void;
+    /** Returns the current PigeonDocument. */
+    getDocument(): PigeonDocument;
+    /** Replaces the document entirely (resets history). */
+    loadDocument(doc: PigeonDocument): void;
+    /** Undo the last change. */
+    undo(): boolean;
+    /** Redo the last undone change. */
+    redo(): boolean;
+    /** Export the document as JSON. */
+    exportJson(): PigeonDocument;
+    /** Export the document as MJML. Requires documentToMjml to be set. */
+    exportMjml(): string | null;
+    /** Export the document as HTML. Requires renderer to be set. */
+    exportHtml(): Promise<string | null>;
+    /** Set merge tags dynamically (for lazy loading). */
+    setMergeTags(tags: MergeTag[]): void;
+    render(): TemplateResult<1>;
+    private _resolveTemplateStorage;
+    private _handleTemplatesOpen;
+    private _handleTemplateLoad;
+    private _handleTemplateSave;
+    private _initState;
+    /** Central dispatch -- every mutation flows through here. */
+    private _dispatch;
+    private _syncHistoryFlags;
+    private _fireChange;
+    private _fireSelect;
+    private _handleUndo;
+    private _handleRedo;
+    private _handleDevice;
+    private _handleFullscreen;
+    private _handlePreview;
+    private _handleExportHtml;
+    private _handleExportMjml;
+    private _handleExportJson;
+    private _handleBlockEnterEdit;
+    private _handleBlockExitEdit;
+    private _handleBlockSelect;
+    private _handleRowSelect;
+    private _handleBodySelect;
+    private _handleRowMove;
+    private _handleRowDuplicate;
+    private _handleRowDelete;
+    /**
+     * Returns true if the event originates from a text-editing context
+     * (input, textarea, select, or contentEditable element), in which
+     * case shortcuts like Delete and Ctrl+Z should not hijack the keys.
+     * Uses composedPath so it works across shadow DOM boundaries.
+     */
+    private _isInTextInput;
+    private _handleKeyDown;
+    private _flattenBlockLocations;
+    private _moveBlockSelection;
+    private _moveRowSelection;
+    private _findBlock;
+    private _findBlockIndex;
+    private _handleRowDrop;
+    private _handleBlockDrop;
+    private _handleBlockDropNewRow;
+    /**
+     * Keyboard equivalent of dragging a palette item onto the canvas: append the
+     * block/layout to the end of the document. Keeps the palette operable
+     * without a pointer (WCAG 2.1 — keyboard accessible).
+     */
+    private _handlePaletteActivate;
+    private _handlePropertyChange;
+    private _handleRowPropertyChange;
+    private _handleRowLayoutChange;
+    private _handleBodyPropertyChange;
+}
+
+export declare class PigeonHeroBlock extends LitElement {
+    block: HeroBlock;
+    selected: boolean;
+    editing: boolean;
+    private _editor;
+    private _editorHost;
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+    updated(changed: Map<string, unknown>): void;
+    disconnectedCallback(): void;
+    private _mountEditor;
+    private _teardownEditor;
+    private _commit;
+    private _exit;
+    private _handleClick;
+    private _handleDblClick;
+}
+
+export declare class PigeonHeroPanel extends LitElement {
+    block: HeroBlock;
+    rowId: string;
+    columnId: string;
+    assetManagerConfig?: AssetManagerConfig;
+    assetStorage?: AssetStorage;
+    private _assetManagerOpen;
+    static styles: CSSResult[];
+    render(): TemplateResult<1>;
+    private _emit;
+    private _onBackgroundUrlChange;
+    private _onBackgroundPositionChange;
+    private _onModeChange;
+    private _onHeightChange;
+    private _onWidthChange;
+    private _onVerticalAlignChange;
+    private _onBgColorChange;
+    private _onContentChange;
+    private _onPaddingChange;
+    private _onInnerPaddingChange;
+    private _onBgAssetSelected;
+}
+
+export declare class PigeonHtmlBlock extends LitElement {
+    block: HtmlBlock;
+    selected: boolean;
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+    private _handleClick;
+}
+
+export declare class PigeonImageBlock extends LitElement {
+    block: ImageBlock;
+    selected: boolean;
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+    private _handleClick;
+}
+
+export declare class PigeonImagePanel extends LitElement {
+    block: ImageBlock;
+    rowId: string;
+    columnId: string;
+    assetManagerConfig?: AssetManagerConfig;
+    assetStorage?: AssetStorage;
+    private _assetManagerOpen;
+    static styles: CSSResult[];
+    render(): TemplateResult<1>;
+    private _emit;
+    private _onSrcChange;
+    private _onAltChange;
+    private _onWidthChange;
+    private _onAlignChange;
+    private _onBorderRadiusChange;
+    private _onHrefChange;
+    private _onPaddingChange;
+    private _openAssetManager;
+    private _onAssetSelected;
+}
+
+export declare class PigeonLayers extends LitElement {
+    doc?: PigeonDocument;
+    selection: Selection_2 | null;
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+    private _renderRow;
+    private _renderColumn;
+    private _renderBlock;
+    private _selectRow;
+    private _selectBlock;
+}
+
+export declare class PigeonMergeTagPicker extends LitElement {
+    tags: MergeTag[];
+    open: boolean;
+    x: number;
+    y: number;
+    private _search;
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+    private _getFilteredTags;
+    private _groupByCategory;
+    private _selectTag;
+}
+
+export declare class PigeonNavBarBlock extends LitElement {
+    block: NavBarBlock;
+    selected: boolean;
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+    private _preventNav;
+    private _handleClick;
+}
+
+export declare class PigeonNavBarPanel extends LitElement {
+    block: NavBarBlock;
+    rowId: string;
+    columnId: string;
+    static styles: CSSResult[];
+    render(): TemplateResult<1>;
+    private _emit;
+    private _addLink;
+    private _removeLink;
+    private _onLinkTextChange;
+    private _onLinkHrefChange;
+    private _onAlignChange;
+    private _onHamburgerChange;
+    private _onLinkColorChange;
+    private _onLinkFontSizeChange;
+    private _onLinkPaddingChange;
+    private _onPaddingChange;
+}
+
+export declare class PigeonPalette extends LitElement {
+    doc?: PigeonDocument;
+    selection: Selection_2 | null;
+    private _blockDefs;
+    private _activeTab;
+    static styles: CSSResult;
+    connectedCallback(): void;
+    render(): TemplateResult<1>;
+    private _renderContentTab;
+    private _renderLayersTab;
+}
+
+export declare class PigeonPaletteItem extends LitElement {
+    label: string;
+    icon: string;
+    /** 'palette-block' or 'palette-row' */
+    dragType: DragItemType;
+    /** Block type for blocks (e.g. 'text'), unused for rows */
+    blockType: string;
+    /** Number of columns for row items */
+    columnCount: number;
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+    private _onKeyDown;
+    private _onDragStart;
+    private _onDragEnd;
+}
+
+export declare class PigeonPreview extends LitElement {
+    renderer?: Renderer;
+    doc?: PigeonDocument;
+    documentToMjml?: (doc: PigeonDocument) => string;
+    open: boolean;
+    private _viewMode;
+    private _device;
+    private _htmlContent;
+    private _mjmlContent;
+    private _loading;
+    static styles: CSSResult;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /** Element focused before the dialog opened, restored on close. */
+    private _previouslyFocused;
+    updated(changed: Map<string, unknown>): Promise<void>;
+    private _onKeyDown;
+    /** The deepest focused element, descending through shadow roots. */
+    private _deepActiveElement;
+    /** Focusable controls inside the modal (the dialog's own chrome). */
+    private _focusable;
+    /** Keep Tab focus within the dialog (WCAG modal pattern). */
+    private _trapTab;
+    render(): TemplateResult<1>;
+    private _renderContent;
+    private _loadPreview;
+    private _setView;
+    private _close;
+}
+
+export declare class PigeonProperties extends LitElement {
+    doc: PigeonDocument;
+    selection: Selection_2 | null;
+    mergeTags: MergeTag[];
+    assetManagerConfig?: AssetManagerConfig;
+    assetStorage?: AssetStorage;
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+    private _renderBlockPanel;
+    private _findRow;
+    private _findBlock;
+}
+
+export declare class PigeonRow extends LitElement {
+    row: RowNode;
+    index: number;
+    totalRows: number;
+    selection: Selection_2 | null;
+    editingBlockId: string | null;
+    private _dragging;
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+    private _onRowClick;
+    private _onMoveUp;
+    private _onMoveDown;
+    private _onDuplicate;
+    private _onDelete;
+    private _onDragStart;
+    private _onDragEnd;
+}
+
+export declare class PigeonRowPanel extends LitElement {
+    row: RowNode;
+    static styles: CSSResult[];
+    private _layouts;
+    render(): TemplateResult<1>;
+    private _emitRowUpdate;
+    private _onLayoutSelect;
+    private _onBgColorChange;
+    private _onBgImageChange;
+    private _onFullWidthChange;
+    private _onPaddingChange;
+    private _onConditionChange;
+}
+
+export declare class PigeonSliderInput extends LitElement {
+    label: string;
+    value: number;
+    min: number;
+    max: number;
+    step: number;
+    unit: string;
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+    private _onSlider;
+    private _onNumber;
+    private _emitChange;
+}
+
+export declare class PigeonSocialBlock extends LitElement {
+    block: SocialBlock;
+    selected: boolean;
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+    private _preventNav;
+    private _handleClick;
+}
+
+export declare class PigeonSpacerBlock extends LitElement {
+    block: SpacerBlock;
+    selected: boolean;
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+    private _handleClick;
+}
+
+export declare class PigeonSpacingInput extends LitElement {
+    label: string;
+    value: Spacing;
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+    private _onChange;
+}
+
+/**
+ * `<pigeon-template-picker>` — modal for browsing/saving templates.
+ *
+ * @element pigeon-template-picker
+ * @fires template-load - `{ template: Template }` when a card is clicked.
+ * @fires template-save - `{ name, description, category }` on save form submit.
+ */
+export declare class PigeonTemplatePicker extends LitElement {
+    /** Storage used to list templates. Required for the gallery to populate. */
+    storage?: TemplateStorage;
+    /** Toggles the modal visibility. */
+    open: boolean;
+    private _templates;
+    private _name;
+    private _description;
+    private _category;
+    private _formError;
+    static styles: CSSResult;
+    updated(changed: Map<string, unknown>): void;
+    /** Re-fetch templates from storage and re-render. */
+    refresh(): Promise<void>;
+    render(): TemplateResult<1>;
+    private _renderCard;
+    private _close;
+    private _onPick;
+    private _onSubmit;
+}
+
+export declare class PigeonTextBlock extends LitElement {
+    block: TextBlock;
+    selected: boolean;
+    /** When true, a TipTap editor is mounted inside this block. */
+    editing: boolean;
+    private _editor;
+    private _editorHost;
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+    updated(changed: Map<string, unknown>): void;
+    disconnectedCallback(): void;
+    private _mountEditor;
+    private _teardownEditor;
+    private _commit;
+    private _exit;
+    private _handleClick;
+    private _handleDblClick;
+}
+
+export declare class PigeonTextPanel extends LitElement {
+    block: TextBlock;
+    rowId: string;
+    columnId: string;
+    mergeTags: MergeTag[];
+    private _pickerOpen;
+    private _pickerX;
+    private _pickerY;
+    private _textareaRef;
+    private _triggerRef;
+    static styles: CSSResult[];
+    render(): TemplateResult<1>;
+    private _togglePicker;
+    private _onMergeTagInsert;
+    /** Strip `{{` and `}}` from a tag name string. */
+    private _extractTagName;
+    private _emit;
+    private _onContentChange;
+    private _onAlignChange;
+    private _onLineHeightChange;
+    private _onPaddingChange;
+}
+
+export declare class PigeonToolbar extends LitElement {
+    canUndo: boolean;
+    canRedo: boolean;
+    device: 'desktop' | 'tablet' | 'mobile';
+    fullscreen: boolean;
+    private _exportMenuOpen;
+    connectedCallback(): void;
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+    private _onUndo;
+    private _onRedo;
+    private _onDeviceChange;
+    private _onFullscreen;
+    private _onPreview;
+    private _onTemplates;
+    private _toggleExportMenu;
+    private _onExportHtml;
+    private _onExportMjml;
+    private _onExportJson;
+}
+
+/**
+ * Read drag data from the DataTransfer object.
+ * Falls back to the global store if DataTransfer is unavailable (dragover).
+ */
+export declare function readDragTransfer(e: DragEvent): DragData | null;
+
+export declare function setDragData(data: DragData): void;
+
+/**
+ * Serialize drag data to the DataTransfer object for native DnD.
+ */
+export declare function writeDragTransfer(e: DragEvent, data: DragData): void;
+
+export { }
+
+
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        fontSize: {
+            setFontSize: (size: string) => ReturnType;
+            unsetFontSize: () => ReturnType;
+        };
+    }
+}