import * as react_jsx_runtime from 'react/jsx-runtime';
import * as React from 'react';
import * as lexical from 'lexical';
import { LexicalEditor, Spread, ElementFormatType, NodeKey, EditorConfig, LexicalNode, ElementNode, SerializedElementNode, DOMExportOutput, Klass, EditorThemeClasses, DecoratorNode, SerializedLexicalNode, LexicalCommand } from 'lexical';
import { HeadingTagType } from '@lexical/rich-text';
import { DecoratorBlockNode, SerializedDecoratorBlockNode } from '@lexical/react/LexicalDecoratorBlockNode';

/**
 * Resolves a CMS media ID into a displayable URL. May be synchronous
 * (an in-memory map) or asynchronous (a fetch against the host app's
 * media API). Returning `null` means "no such media" — the block then
 * renders a not-found placeholder instead of a broken image.
 */
type MediaResolver = (id: string) => string | null | Promise<string | null>;
interface MediaResolverProviderProps {
    children: React.ReactNode;
    resolveImageSrc?: MediaResolver;
}
/**
 * Makes the host app's media resolver available to decorator nodes.
 * Provided automatically by `RichTextEditor`.
 *
 * Decorator nodes are rendered through `createPortal` from inside
 * `<RichTextContent>`, and React portals inherit context from the
 * *component* tree rather than the DOM tree — so wrapping `children`
 * here is enough to reach every block's preview.
 */
declare function MediaResolverProvider({ children, resolveImageSrc, }: MediaResolverProviderProps): react_jsx_runtime.JSX.Element;
/**
 * Read the configured resolver. Falls back to `null` when no provider is
 * mounted, so blocks render harmlessly outside an editor.
 */
declare function useMediaResolver(): MediaResolver | null;
type ResolvedSrcStatus = 
/** No id was requested — nothing to resolve. */
"idle"
/** An async resolver is in flight. */
 | "loading"
/** `src` holds a usable URL. */
 | "resolved"
/** The resolver returned null/threw, or none is configured. */
 | "missing";
interface ResolvedSrc {
    src: string | null;
    status: ResolvedSrcStatus;
}
/**
 * Turn a media ID into a URL via the host-supplied resolver.
 *
 * Handles both sync and async resolvers, and ignores results from a
 * previous ID that land after the ID has already changed (or after
 * unmount) so a slow request can't overwrite a newer one.
 */
declare function useResolvedSrc(id: string | null | undefined): ResolvedSrc;

/**
 * Lexical stores inline text formatting in two different places:
 *
 * - `format` — a **bitmask** of the toggles (bold, italic, underline …)
 * - `style`  — a CSS string, written by `$patchStyleText` (colour,
 *              background colour, font size …)
 *
 * That split is awkward to consume downstream, where you usually just
 * want "the CSS for this run of text". These helpers decode the bitmask
 * and merge both halves into a single declaration string.
 */
/** Bit for each inline format. Mirrors `IS_*` in Lexical's constants. */
declare const TEXT_FORMAT_BITS: {
    readonly bold: 1;
    readonly italic: 2;
    readonly strikethrough: 4;
    readonly underline: 8;
    readonly code: 16;
    readonly subscript: 32;
    readonly superscript: 64;
    readonly highlight: 128;
    readonly lowercase: 256;
    readonly uppercase: 512;
    readonly capitalize: 1024;
};
type TextFormatName = keyof typeof TEXT_FORMAT_BITS;
/** Does this bitmask include the given format? */
declare function hasTextFormat(format: number, name: TextFormatName): boolean;
/** Every format switched on in the bitmask, e.g. `9` → `["bold", "underline"]`. */
declare function decodeTextFormat(format: number): TextFormatName[];
interface TextCssOptions {
    /** Background used for the `highlight` format. */
    highlightColor?: string;
    /** Font stack used for the `code` format. */
    codeFontFamily?: string;
    /** Background used for the `code` format. Pass `""` to skip it. */
    codeBackground?: string;
}
/**
 * CSS declarations for a format bitmask.
 *
 * `underline` and `strikethrough` deliberately collapse into a single
 * `text-decoration`; emitting them as two declarations would make the
 * second overwrite the first and silently drop one of the two.
 */
declare function textFormatToCss(format: number, options?: TextCssOptions): Record<string, string>;
/** Parse a CSS declaration string into a map. */
declare function parseCssText(style: string): Record<string, string>;
/** Serialize a declaration map back into a CSS string. */
declare function stringifyCss(css: Record<string, string>): string;
/**
 * One CSS string covering everything applied to a run of text.
 *
 * The node's own `style` is applied last, so an explicitly picked colour
 * beats one implied by a format bit (e.g. a custom background colour
 * wins over `highlight`'s default yellow).
 */
declare function textNodeCss(format: number, style?: string, options?: TextCssOptions): string;
interface InlineTextStyleOptions extends TextCssOptions {
    /**
     * Key the computed CSS is written under. Defaults to `"css"`.
     *
     * Avoid `"style"`: Lexical reads that key back on import into the
     * node's own `style`, so the derived declarations would become real
     * ones — and toggling bold off would no longer clear `font-weight`,
     * because that toggle only touches `format`. Keeping a separate key
     * leaves the JSON safe to feed back into `initialJson` / `setJson`.
     */
    key?: string;
}
/**
 * Walk a serialized editor state and add a ready-to-use CSS string to
 * every text node, so consumers never have to decode the bitmask.
 *
 * ```ts
 * const json = JSON.parse(editorRef.current.getJson());
 * withInlineTextStyles(json);
 * // { type: "text", text: "Merhaba", format: 9, style: "color: #ef4444;",
 * //   css: "font-weight: 700; text-decoration: underline; color: #ef4444" }
 * ```
 *
 * Returns the same object it was given (mutated in place) for easy
 * chaining; pass a copy if you need the original untouched.
 */
declare function withInlineTextStyles<T>(serialized: T, options?: InlineTextStyleOptions): T;

/**
 * Every user-facing string the editor chrome renders. Field labels that
 * belong to a consumer-supplied schema (`CmsBlockSpec.fields`) are not
 * here — those travel with the schema.
 */
interface RichTextMessages {
    cancel: string;
    save: string;
    insert: string;
    embed: string;
    delete: string;
    add: string;
    update: string;
    removeLink: string;
    searchBlocks: string;
    noBlocksFound: string;
    insertBlock: string;
    url: string;
    urlRequired: string;
    altText: string;
    altTextHint: string;
    caption: string;
    captionHint: string;
    maxWidth: string;
    auto: string;
    fixed: string;
    responsive: string;
    title: string;
    poster: string;
    aspectRatio: string;
    playerOptions: string;
    autoplay: string;
    mute: string;
    loop: string;
    showControls: string;
    preload: string;
    startAt: string;
    seconds: string;
    requiredByAutoplay: string;
    optional: string;
    imageId: string;
    videoId: string;
    resolvedUrl: string;
    resolving: string;
    notFoundForId: string;
    idOrUrlRequired: string;
    urlNotStoredHint: string;
    urlDisabledHint: string;
    /** Header of the image form, e.g. "Resim ekle" / "Resim". */
    insertImage: string;
    imageBlock: string;
    chooseImage: string;
    noImagesAvailable: string;
    loadingImages: string;
    clearSelection: string;
    spellCheck: string;
    spellLoading: string;
    spellChecking: string;
    spellPassed: string;
    /** `{count}` is replaced with the number of issues. */
    spellIssues: string;
    spellError: string;
    spellDisabled: string;
    spellMisspelling: string;
    spellCommonMistake: string;
    spellSeparateWords: string;
    spellSuggestionsLoading: string;
    spellNoSuggestions: string;
    spellIgnore: string;
    spellAddToDictionary: string;
    spellRecheck: string;
    spellShowIssues: string;
    spellHideIssues: string;
    loadingOptions: string;
    optionNotInList: string;
    textCase: string;
    upperCase: string;
    lowerCase: string;
    titleCase: string;
}
declare const trMessages: RichTextMessages;
declare const enMessages: RichTextMessages;
type RichTextLocale = "tr" | "en";
declare const LOCALE_MESSAGES: Record<RichTextLocale, RichTextMessages>;
/** Turkish is the default — this editor's primary audience. */
declare const DEFAULT_LOCALE: RichTextLocale;
/** Resolve the `locale` / `messages` props into one catalog. */
declare function resolveMessages(locale?: RichTextLocale, overrides?: Partial<RichTextMessages>): RichTextMessages;
declare function RichTextI18nProvider({ children, messages, locale, }: {
    children: React.ReactNode;
    messages: RichTextMessages;
    /** Needed on its own by anything that has to case text correctly —
     *  Turkish `i`/`İ` differs from the browser default. */
    locale?: RichTextLocale;
}): react_jsx_runtime.JSX.Element;
/**
 * The active message catalog. Falls back to Turkish outside a provider so
 * components stay renderable in isolation (tests, Storybook fragments).
 */
declare function useMessages(): RichTextMessages;

/**
 * One selectable item in the page's image library.
 *
 * `id` is the only required field — that's what gets stored on the node.
 * Everything else is a display convenience: leave `url` out and the
 * thumbnail is resolved through `resolveImageSrc` like any other ID, so
 * handing over a plain list of IDs is enough.
 */
interface MediaLibraryItem {
    id: string;
    /** Optional direct URL. Falls back to `resolveImageSrc(id)`. */
    url?: string;
    /** Optional caption shown under the thumbnail. */
    title?: string;
}
/** A static list, or a function returning one (optionally async). */
type MediaLibrary = MediaLibraryItem[] | (() => MediaLibraryItem[] | Promise<MediaLibraryItem[]>);
declare function MediaLibraryProvider({ children, library, }: {
    children: React.ReactNode;
    library?: MediaLibrary;
}): react_jsx_runtime.JSX.Element;
type MediaLibraryStatus = "idle" | "loading" | "ready";
interface MediaLibraryState {
    items: MediaLibraryItem[];
    status: MediaLibraryStatus;
    /** `false` when the host configured no library at all — callers use
     *  this to keep the manual ID/URL inputs editable. */
    configured: boolean;
}
/**
 * Read the configured image library, loading it if it's a function.
 *
 * A loader is called once per mount; results arriving after unmount are
 * ignored so a slow fetch can't set state on a dead component.
 */
declare function useMediaLibrary(): MediaLibraryState;

/**
 * Fields to hide, keyed by block type (`"image"`, `"galeri"`,
 * `"newsMoment"`, …). The `"*"` key applies to every block.
 *
 * ```ts
 * { image: ["caption", "maxWidth"], "*": ["position"] }
 * ```
 */
type HiddenFieldsConfig = Record<string, string[]>;
declare function HiddenFieldsProvider({ children, hiddenFields, }: {
    children: React.ReactNode;
    hiddenFields?: HiddenFieldsConfig;
}): react_jsx_runtime.JSX.Element;
/** The raw config, for callers that serialize rather than render. */
declare function useHiddenFieldsConfig(): HiddenFieldsConfig | null;
/** Field names hidden for one block type, including the `"*"` entries. */
declare function hiddenFieldsFor(config: HiddenFieldsConfig | null | undefined, blockType: string): Set<string>;
/**
 * `isHidden(fieldName)` for one block type — used by the forms to skip
 * rendering a field.
 */
declare function useHiddenFields(blockType: string): (field: string) => boolean;
/**
 * Remove hidden fields from a serialized editor state, so they never
 * reach the host's payload.
 *
 * A name is dropped whether it sits at the node's top level (CMS blocks
 * store fields flat) or inside its `options` object (the built-in media
 * blocks) — callers name the field, not its nesting. Lexical's own
 * structural keys are never touched.
 *
 * **Pure**: the input is left alone and a stripped deep copy is
 * returned. That matters because `exportJSON()` can hand out live node
 * internals (a media node's `options` used to be the very object the
 * node stores), so deleting in place would erase the field from the
 * document itself — permanently, and outside an `editor.update()`.
 *
 * The clone only happens when there is something to strip, so editors
 * without `hiddenFields` pay nothing.
 */
declare function stripHiddenFields<T>(serialized: T, config: HiddenFieldsConfig | null | undefined): T;

interface CmsFieldOption {
    value: string;
    label: string;
}
type CmsFieldInputType = "text" | "url" | "number" | "select" | "textarea"
/** Native date picker. Stored as `YYYY-MM-DD`. */
 | "date"
/** Native time picker. Stored as `HH:mm`. */
 | "time"
/** Comma-separated media IDs, previewed as thumbnails via the
 *  resolver passed to `RichTextEditor`. */
 | "image-ids";
interface CmsFieldSpec {
    /** Key this field is stored under — becomes a top-level key in the
     *  node's serialized JSON. */
    name: string;
    label: string;
    inputType: CmsFieldInputType;
    options?: CmsFieldOption[];
    placeholder?: string;
    optional?: boolean;
}
/** Field values as stored on the node. Everything is a string; numeric
 *  fields are parsed by the consumer. */
type CmsFieldValues = Record<string, string>;
interface CmsBlockSpec {
    /**
     * Lexical node type — also the `"type"` key in serialized JSON.
     * Must be unique across every registered node.
     */
    type: string;
    title: string;
    description?: string;
    /** Menu icon (Insert dropdown / slash menu). */
    icon: React.ReactElement;
    /** Extra search terms for the slash filter. `type` and `title` are
     *  matched automatically. */
    keywords?: string[];
    fields: CmsFieldSpec[];
    /**
     * Custom in-editor preview. Omit to get the generic card (title +
     * field summary). Rendered inside the block's decorator, so it can
     * use `useResolvedSrc()` to turn IDs into images.
     */
    renderPreview?: (fields: CmsFieldValues) => React.ReactNode;
}

/** A fixed list, or a function returning one (optionally async). */
type CmsFieldOptionsSource = CmsFieldOption[] | (() => CmsFieldOption[] | Promise<CmsFieldOption[]>);
/**
 * Replacement dropdown choices, keyed by block type and then field name.
 * The `"*"` block key applies to every block, so a field shared across
 * blocks (`position`) can be set once.
 *
 * ```ts
 * {
 *   canliyayin: { channel: [{ value: "300", label: "BHT TV" }] },
 *   piyasa: { usd_eur: async () => fetchMarkets() },
 *   "*": { position: [{ value: "left", label: "Sola yaslı" }] },
 * }
 * ```
 */
type CmsFieldOptionsConfig = Record<string, Record<string, CmsFieldOptionsSource>>;
declare function CmsFieldOptionsProvider({ children, cmsFieldOptions, }: {
    children: React.ReactNode;
    cmsFieldOptions?: CmsFieldOptionsConfig;
}): react_jsx_runtime.JSX.Element;
type CmsFieldOptionsStatus = "schema" | "loading" | "ready" | "error";
interface CmsFieldOptionsState {
    options: CmsFieldOption[];
    status: CmsFieldOptionsStatus;
    /** `true` when the host supplied a list for this field. */
    overridden: boolean;
}
/**
 * The choices for one select field: whatever the host configured for
 * this block type (or for `"*"`), else the schema's own list.
 *
 * While an async loader runs, the schema list is held back and `status`
 * is `"loading"` — better a momentarily empty select than the author
 * picking a channel that is about to disappear. If the loader rejects,
 * the schema list comes back so the form stays usable.
 */
declare function useCmsFieldOptions(blockType: string, fieldName: string, schemaOptions?: CmsFieldOption[]): CmsFieldOptionsState;

/**
 * The editor-level registration, without React — `RichTextBlockEdges`
 * is a thin wrapper around it, and tests drive it headlessly.
 *
 * Returns the unregister function.
 */
declare function registerBlockEdges(editor: LexicalEditor, { leading, trailing }?: RichTextBlockEdgesProps): () => void;
interface RichTextBlockEdgesProps {
    /** Keep a paragraph above a leading block. Default `true`. */
    leading?: boolean;
    /** Keep a paragraph below a trailing block. Default `true`. */
    trailing?: boolean;
}
/**
 * Keeps an empty paragraph at either end of the document when the block
 * there can't be typed around — otherwise an image or CMS block that
 * opens or closes the document leaves nowhere to put the caret, and the
 * author can only get past it with the "+" menu.
 *
 * Mounted by `RichTextEditor`; switch it off with `blockEdges={false}`.
 */
declare function RichTextBlockEdges({ leading, trailing, }?: RichTextBlockEdgesProps): null;
declare namespace RichTextBlockEdges {
    var displayName: string;
}

/**
 * How many characters a heading should stay under. One number covers
 * every heading level; an object sets them per level, and a level left
 * out of the object is not counted at all.
 */
type HeadingLimitConfig = number | Partial<Record<HeadingTagType, number>>;
declare const DEFAULT_HEADING_LIMIT = 70;
interface HeadingLimitOptions {
    /** Characters allowed before the counter turns red. Default `70`. */
    limit?: HeadingLimitConfig;
    /**
     * Show the counter on every heading, not just the one being edited
     * and the ones already over. Default `false`.
     */
    always?: boolean;
}
/**
 * The editor-level registration, without React. Returns the unregister
 * function.
 */
declare function registerHeadingLimit(editor: LexicalEditor, { limit, always }?: HeadingLimitOptions): () => void;
interface RichTextHeadingLimitProps extends HeadingLimitOptions {
}
/**
 * Shows a character counter on headings — `62/70` next to the one
 * being edited, turning red once it is over. The limit is advisory: the
 * author can keep typing, and nothing is truncated.
 *
 * The counter is drawn with CSS from a data attribute, so it never
 * reaches the document: `onChange`, `getJson()`, the HTML export and
 * `getText()` are all unaffected.
 *
 * Mounted by `RichTextEditor`; configure with `headingLimit`.
 */
declare function RichTextHeadingLimit({ limit, always, }?: RichTextHeadingLimitProps): null;
declare namespace RichTextHeadingLimit {
    var displayName: string;
}

type RichTextValue = {
    /** Lexical editor state JSON */
    json: string;
    /** Serialized HTML */
    html: string;
    /** Plain text content */
    text: string;
    /** Markdown serialization (via @lexical/markdown TRANSFORMERS) */
    markdown: string;
};
interface RichTextEditorProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onChange"> {
    /** Initial Lexical editor state JSON (string) */
    initialJson?: string;
    /** Initial HTML — parsed and loaded into the editor on mount */
    initialHtml?: string;
    /** Initial Markdown — parsed and loaded via TRANSFORMERS on mount */
    initialMarkdown?: string;
    /** Called on every editor state change */
    onChange?: (value: RichTextValue) => void;
    /** Read-only mode when false (default true) */
    editable?: boolean;
    /** Auto-focus the editor on mount */
    autoFocus?: boolean;
    /** Lexical namespace (default "eglador-rich-text") */
    namespace?: string;
    /** Maximum character count. When set, content past the limit is wrapped
     *  in an `OverflowNode` and visually marked. */
    maxLength?: number;
    /** Charset for character counting (default `"UTF-16"`). UTF-8 counts
     *  emoji and CJK characters as multiple bytes; UTF-16 matches `String.length`. */
    charset?: "UTF-8" | "UTF-16";
    /**
     * Turns a CMS media ID into a displayable URL. Called by any block
     * that stores an ID instead of a URL — the `image` / `video` blocks in
     * ID mode, and CMS blocks with `image-ids` fields (e.g. `newsMoment`).
     *
     * May be sync (an in-memory map) or async (a fetch). Return `null`
     * when the ID has no media, and the block renders a placeholder
     * instead of a broken image.
     */
    resolveImageSrc?: MediaResolver;
    /**
     * Add a ready-to-use `css` string to every text node in the JSON —
     * merging the `format` bitmask with the node's `style`, so consumers
     * never decode `format: 9` by hand. **On by default**, affecting
     * `onChange`'s `json`, `useRichTextEditor().getJson()` and the
     * `RichTextOutput` JSON tab.
     *
     * The key is additive: the JSON still imports cleanly via
     * `initialJson` / `setJson`. Pass `false` for the raw Lexical shape,
     * or an options object to tune the `highlight` / `code` colours.
     */
    inlineTextStyles?: boolean | InlineTextStyleOptions;
    /** UI language for the editor chrome. Default `"tr"`. */
    locale?: RichTextLocale;
    /** Override individual strings without switching locale. */
    messages?: Partial<RichTextMessages>;
    /**
     * Images the author can pick from in the image block. Supply an array,
     * or a function (optionally async) returning one. Each item needs only
     * an `id`; a missing `url` is resolved through `resolveImageSrc`.
     *
     * When set, the image form shows a picker and its ID / URL fields
     * become read-only — the document stores the chosen ID.
     */
    imageLibrary?: MediaLibrary;
    /**
     * Fields to drop, keyed by block type. The `*` key applies to every
     * block. They disappear from the block's form **and** from the
     * serialized payload (`onChange`, `getJson()`, the output panel).
     *
     * A name matches whether the block stores it flat (CMS blocks) or
     * inside `options` (the built-in media blocks).
     */
    hiddenFields?: HiddenFieldsConfig;
    /**
     * Replace a CMS block's dropdown choices, keyed by block type and then
     * field name — the live-stream channel list, the market widgets, the
     * link colours. Each entry is a list or a function (optionally async)
     * returning one, so the values can come from your own API instead of
     * the built-in defaults.
     *
     * ```tsx
     * cmsFieldOptions={{
     *   canliyayin: { channel: async () => fetchChannels() },
     *   "*": { position: [{ value: "left", label: "Sola yaslı" }] },
     * }}
     * ```
     *
     * A stored value that is missing from the new list is kept and shown
     * as its own entry rather than being silently replaced.
     */
    cmsFieldOptions?: CmsFieldOptionsConfig;
    /**
     * Keep an empty paragraph next to a block the caret can't be typed
     * around — a media embed or CMS block that opens or closes the
     * document, a table, a columns row. Without it the author has no way
     * to click above the first block or below the last one.
     *
     * **On by default.** Pass `false` to leave documents exactly as they
     * are (the JSON then never gains these paragraphs), or an object to
     * control each end: `blockEdges={{ leading: false }}`.
     */
    blockEdges?: boolean | RichTextBlockEdgesProps;
    /**
     * Drop the blank spacer blocks word processors put between paragraphs,
     * so text pasted from Word, Google Docs or a web page doesn't arrive
     * double-spaced. **On by default**; `false` pastes verbatim.
     */
    pasteCleanup?: boolean;
    /**
     * Advisory character limit for headings, shown as a `62/70` counter
     * next to the heading being edited and turning red once it is over.
     * Nothing is blocked or truncated — the author can keep typing.
     *
     * Defaults to 70 for every heading level. Pass a number to change
     * it, an object to vary it per level
     * (`{ limit: { h2: 70, h3: 60 } }` — a level left out is not
     * counted), `{ always: true }` to show every heading's counter, or
     * `false` to turn the counter off.
     *
     * The counter is drawn in CSS from a data attribute, so it never
     * reaches `onChange`, `getJson()`, the HTML export or `getText()`.
     */
    headingLimit?: number | false | (HeadingLimitOptions & {
        limit?: HeadingLimitConfig;
    });
    /** Receive the LexicalEditor instance once initialized (escape hatch) */
    editorRef?: React.MutableRefObject<LexicalEditor | null> | ((editor: LexicalEditor) => void);
    children: React.ReactNode;
}

declare function RichTextEditor({ initialJson, initialHtml, initialMarkdown, onChange, editable, autoFocus, namespace, maxLength, charset, resolveImageSrc, inlineTextStyles, locale, messages, imageLibrary, hiddenFields, cmsFieldOptions, blockEdges, pasteCleanup, headingLimit, editorRef, className, children, ...props }: RichTextEditorProps): react_jsx_runtime.JSX.Element;
declare namespace RichTextEditor {
    var displayName: string;
}

interface LegacyFieldOption {
    value: string;
    label: string;
}
interface LegacyFieldSpec {
    /** Key under which this field's value is stored — becomes the field
     *  name in the `#type#field#value#` output. */
    name: string;
    label: string;
    inputType: "text" | "url" | "number" | "select" | "textarea";
    options?: LegacyFieldOption[];
    placeholder?: string;
    optional?: boolean;
}
interface LegacyComponentSpec {
    /** Shortcode type keyword, e.g. `"resim"`, `"video"` — entirely up to
     *  the consumer, not constrained by this library. */
    type: string;
    title: string;
    description?: string;
    /** Menu icon (Insert dropdown / slash menu). Falls back to a generic
     *  icon when omitted — see `createLegacyComponentBlocks`. */
    icon?: React.ReactElement;
    fields: LegacyFieldSpec[];
    /**
     * Custom output mask for this type's shortcode string, e.g.
     * `"#{type}#{ID}#"`. `{type}` is replaced with `type`; `{fieldName}`
     * placeholders (matching a field's `name`) are replaced with that
     * field's submitted value. Any field not referenced by the template is
     * simply omitted from the output.
     *
     * Omit to use the default `#type#field#value#field#value#...#` layout
     * (every field rendered as its `name` followed by its value), e.g.
     * `{ type: "resim", fields: [{ name: "ID", ... }] }` → `#resim#ID#345456#`.
     * With `template: "#{type}#{ID}#"` the same submission instead renders
     * `#resim#345456#`.
     */
    template?: string;
}

/**
 * Where a block can be invoked from. Each surface has its own UX
 * affordances:
 * - `"insert"` — top-toolbar Insert dropdown (supports multi-step forms)
 * - `"slash"` — `/` typeahead (quick action only, no forms)
 * - `"draggable"` — Notion-style block hover `+` (block conversion / quick insert)
 */
type BlockSurface = "insert" | "slash" | "draggable";
type BlockCategory = "text" | "list" | "block" | "separator" | "media" | "embed" | "layout";
interface BlockFormHandlers {
    /** Form should call when insertion is complete (host closes the popover). */
    onComplete: () => void;
    /** Form should call when the user cancels (host returns to main view). */
    onCancel: () => void;
}
/**
 * Single source of truth for an insertable / convertible block. All
 * surfaces (Insert menu, slash, draggable +) read from this registry —
 * adding a new block means adding one entry here.
 */
interface BlockSpec {
    /** Unique stable key. */
    key: string;
    /** Display label. */
    label: string;
    /** Short description for surfaces that show one (slash). */
    description?: string;
    /** Icon node, sized for menu items (~16px). */
    icon: React.ReactElement;
    /** Search keywords (slash filter). */
    keywords?: string[];
    /** Category — used for grouping / filtering. */
    category: BlockCategory;
    /** Which UI surfaces this block appears in. */
    surfaces: BlockSurface[];
    /**
     * Quick action — runs directly on selection. Required for slash and
     * draggable surfaces. Optional when the block needs configuration
     * via `renderForm` only (e.g. embed forms).
     */
    action?: (editor: LexicalEditor) => void;
    /**
     * Optional form. When provided, surfaces that support multi-step UI
     * (currently `"insert"`) show this form as a sub-view. The form is
     * responsible for calling `handlers.onComplete()` after successful
     * insertion or `handlers.onCancel()` when dismissed.
     */
    renderForm?: (editor: LexicalEditor, handlers: BlockFormHandlers) => React.ReactNode;
}
/**
 * Turns a consumer-supplied `LegacyComponentSpec[]` into `BlockSpec[]` —
 * one entry per spec, each opening a form (built from `spec.fields`) on
 * the `"insert"` / `"slash"` surfaces. This library has no built-in
 * notion of what types exist; call this with your own schema and merge
 * the result into `defaultBlocks` (or pass it standalone) via the
 * `blocks` prop on `RichTextToolbar` / `RichTextSlashCommands` /
 * `RichTextDraggableBlock`.
 *
 * @example
 * const blocks = [...defaultBlocks, ...createLegacyComponentBlocks(mySchema)];
 * <RichTextToolbar insertBlocks={blocks} />
 * <RichTextSlashCommands blocks={blocks} />
 */
declare function createLegacyComponentBlocks(schema: LegacyComponentSpec[]): BlockSpec[];
/**
 * Default block registry. Pass a custom `blocks` prop to any surface to
 * override / extend / re-order. Use `getBlocksForSurface()` to filter
 * defaults by surface, then concatenate your own.
 */
declare const defaultBlocks: BlockSpec[];
/** Filter the registry to a specific surface. All three surfaces accept
 *  both `action` and `renderForm`, so given the same `blocks` array they
 *  return identical lists in identical order — the toolbar Insert menu,
 *  the `/` menu and the drag-handle `+` menu never drift apart. */
declare function getBlocksForSurface(surface: BlockSurface, blocks?: BlockSpec[]): BlockSpec[];

interface RichTextContentProps {
    placeholder?: React.ReactNode;
    className?: string;
    contentClassName?: string;
    placeholderClassName?: string;
    /** Minimum editor height (Tailwind class). Default `min-h-32` */
    minHeight?: string;
    /** Enable Notion-style drag handle + "+" insert menu (default `false`) */
    draggable?: boolean;
    /**
     * Custom blocks shown inside the draggable "+" popover. Defaults to
     * `defaultBlocks` filtered to `surfaces.includes("draggable")`.
     */
    draggableBlocks?: BlockSpec[];
    /** Enable floating format toolbar that appears on text selection (default `false`) */
    floatingToolbar?: boolean;
    /** Heading buttons in the floating toolbar (default `["h2", "h3"]`). */
    floatingHeadings?: HeadingTagType[];
    /** Editor mode (default `"rich"`). `"plain"` swaps RichTextPlugin for
     *  PlainTextPlugin — text only, no inline/block formatting commands. */
    mode?: "rich" | "plain";
}
declare function RichTextContent({ placeholder, className, contentClassName, placeholderClassName, minHeight, draggable, draggableBlocks, floatingToolbar, floatingHeadings, mode, }: RichTextContentProps): react_jsx_runtime.JSX.Element;
declare namespace RichTextContent {
    var displayName: string;
}

type HeadingMenuItem = "paragraph" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6";

type RichTextToolbarFeature = "bold" | "italic" | "underline" | "strikethrough" | "code" | "heading1" | "heading2" | "heading3" | "heading4" | "heading5" | "heading6" | "heading" | "paragraph" | "quote" | "bulletList" | "orderedList" | "checkList" | "link" | "textColor" | "backgroundColor" | "alignment" | "textTransform" | "insert" | "undo" | "redo" | "separator";
interface RichTextToolbarProps extends React.HTMLAttributes<HTMLDivElement> {
    features?: RichTextToolbarFeature[];
    /** Items shown inside the heading dropdown (default: paragraph + h1–h6) */
    headingItems?: HeadingMenuItem[];
    /**
     * Blocks shown inside the Insert dropdown. Defaults to the built-in
     * `defaultBlocks` registry filtered to `surfaces.includes("insert")`.
     * Pass a custom array to extend / re-order / restrict.
     */
    insertBlocks?: BlockSpec[];
}
declare function RichTextToolbar({ features, headingItems, insertBlocks, className, ...props }: RichTextToolbarProps): react_jsx_runtime.JSX.Element;
declare namespace RichTextToolbar {
    var displayName: string;
}

interface RichTextFloatingToolbarProps {
    /**
     * Kept for API compatibility. The toolbar now portals to the body and
     * positions itself from the selection's viewport rect, so it is not
     * used — passing it is harmless.
     */
    anchorElem?: HTMLElement;
    /**
     * Heading buttons offered next to the inline formats. Each one turns
     * the selected block into that heading, or back into a paragraph when
     * it already is one. Pass `[]` to leave them out.
     */
    headings?: HeadingTagType[];
}
/**
 * Floating selection toolbar — appears above the selected text with format
 * buttons (bold, italic, underline, strikethrough, code, link).
 */
declare function RichTextFloatingToolbar({ headings, }?: RichTextFloatingToolbarProps): React.ReactPortal | null;
declare namespace RichTextFloatingToolbar {
    var displayName: string;
}

interface RichTextDraggableBlockProps {
    anchorElem: HTMLElement;
    /** Hide the "+" insert button (default `false` — button is shown) */
    hideInsertButton?: boolean;
    /**
     * Custom blocks registry. Defaults to `defaultBlocks` filtered to
     * `surfaces.includes("draggable")` and `action` defined.
     */
    blocks?: BlockSpec[];
}
/**
 * Notion-style drag handle with an optional "+" insert menu.
 * Hover over a block → grip handle appears on the left, drag to reorder.
 * Click "+" to insert a new block from the registry's draggable surface.
 */
declare function RichTextDraggableBlock({ anchorElem, hideInsertButton, blocks, }: RichTextDraggableBlockProps): react_jsx_runtime.JSX.Element;
declare namespace RichTextDraggableBlock {
    var displayName: string;
}

interface RichTextTableActionsProps {
    /** Element used as positioning anchor (typically the editor's content wrapper) */
    anchorElem: HTMLElement;
}
/**
 * Floating chevron button anchored to the active table cell. Click opens a
 * menu with structural operations (insert / delete row & column, merge,
 * unmerge, delete table). Operations use Lexical's official `@lexical/table`
 * helpers so they respect cell merge state and selection semantics.
 */
declare function RichTextTableActions({ anchorElem, }: RichTextTableActionsProps): React.ReactPortal | null;
declare namespace RichTextTableActions {
    var displayName: string;
}

interface RichTextLinkEditorProps {
    /** Element used as positioning anchor (typically the editor's content wrapper) */
    anchorElem: HTMLElement;
}
/**
 * Floating link editor that auto-opens when the cursor enters a link.
 * Anchored below the link element. Uses `LinkEditForm` for the actual
 * form, keyed by link node key so the form re-reads attributes when the
 * cursor moves to a different link.
 *
 * Closes when the cursor leaves the link, or when Update / Remove is
 * clicked (Update closes immediately; user can re-enter the link to
 * reopen). No Cancel — the editor is intrinsically tied to cursor
 * position.
 */
declare function RichTextLinkEditor({ anchorElem }: RichTextLinkEditorProps): React.ReactPortal | null;
declare namespace RichTextLinkEditor {
    var displayName: string;
}

interface RichTextSlashCommandsProps {
    /**
     * Custom blocks registry. Defaults to the built-in `defaultBlocks` —
     * filtered to entries with `surfaces.includes("slash")`. Pass your own
     * list to extend / re-order / restrict.
     */
    blocks?: BlockSpec[];
}
/**
 * Slash command menu — type `/` in the editor to open a popover with quick
 * block insertions (Notion / Linear / Discord pattern).
 *
 * - `action`-based blocks run immediately on select (paragraph, heading,
 *   list, divider, ...).
 * - `renderForm`-only blocks (YouTube, image, iframe, columns, ...) open
 *   a small form popover anchored near the cursor on select; submit
 *   inserts the block, cancel just dismisses.
 */
declare function RichTextSlashCommands({ blocks, }?: RichTextSlashCommandsProps): react_jsx_runtime.JSX.Element;
declare namespace RichTextSlashCommands {
    var displayName: string;
}

/**
 * Auto-embed plugin — when a user pastes (or types) a recognized URL
 * (YouTube), a small inline menu offers to convert it into an embed
 * block. Built on Lexical's `LexicalAutoEmbedPlugin`.
 *
 * Opt-in component:
 *
 * ```tsx
 * <RichTextEditor>
 *   <RichTextContent />
 *   <RichTextAutoEmbed />
 * </RichTextEditor>
 * ```
 */
declare function RichTextAutoEmbed(): react_jsx_runtime.JSX.Element;
declare namespace RichTextAutoEmbed {
    var displayName: string;
}

interface YouTubeOptions {
    /** Auto-start the video on load (browsers require `mute` for this to work). */
    autoplay?: boolean;
    /** Start the video muted. Required by browsers when `autoplay` is on. */
    mute?: boolean;
    /** Loop the video. YouTube requires the `playlist` param to be set to
     *  the same video ID — handled automatically. */
    loop?: boolean;
    /** Show YouTube's player controls (default `true`). */
    controls?: boolean;
    /** Start position in seconds (`0` = beginning). */
    start?: number;
}
type SerializedYouTubeNode = Spread<{
    /** The URL exactly as the author entered it. */
    url?: string;
    /**
     * Legacy: documents written before the node stored URLs kept only
     * the 11-character video ID. Still read on import, never written.
     */
    videoID?: string;
    options?: YouTubeOptions;
}, SerializedDecoratorBlockNode>;
/** Build the canonical privacy-friendly embed URL for a bare video ID. */
declare function youTubeEmbedUrl(videoID: string): string;
/**
 * The URL to actually put in the iframe.
 *
 * The stored URL is whatever the author typed; a `watch?v=` or
 * `youtu.be` link can't be framed (YouTube refuses with
 * `X-Frame-Options`), so those are normalized to their `/embed/` form
 * for rendering only — the document keeps the original string.
 */
declare function toYouTubeEmbedSrc(url: string): string;
/**
 * YouTube embed block. Wraps an iframe pointing to youtube-nocookie.com
 * inside a `BlockWithAlignableContents` container so users can align,
 * select, and delete it like other block-level decorators.
 *
 * The block renders a hover-action button (gear icon) at the top-right
 * corner — clicking it opens a Notion-style options popover where the
 * player options (autoplay, mute, loop, controls, start) can be edited
 * live or the embed removed.
 */
declare class YouTubeNode extends DecoratorBlockNode {
    __url: string;
    __options: Required<YouTubeOptions>;
    static getType(): string;
    static clone(node: YouTubeNode): YouTubeNode;
    static importJSON(serialized: SerializedYouTubeNode): YouTubeNode;
    exportJSON(): SerializedYouTubeNode;
    constructor(url: string, options?: YouTubeOptions, format?: ElementFormatType, key?: NodeKey);
    getUrl(): string;
    setUrl(url: string): this;
    getOptions(): Required<YouTubeOptions>;
    setOptions(options: YouTubeOptions): this;
    getTextContent(): string;
    decorate(_editor: LexicalEditor, config: EditorConfig): React.ReactElement;
}
/** `url` is stored verbatim — whatever the author entered. */
declare function $createYouTubeNode(url: string, options?: YouTubeOptions): YouTubeNode;
declare function $isYouTubeNode(node: LexicalNode | null | undefined): node is YouTubeNode;
interface YouTubeUrlMatch {
    id: string;
    /** Start time in seconds, parsed from `?t=` or `?start=` if present. */
    start?: number;
}
/**
 * Extract the 11-character video ID and optional start-time from any
 * YouTube URL form. Returns `null` if the URL doesn't match.
 */
declare function parseYouTubeUrl(url: string): YouTubeUrlMatch | null;

interface YouTubeFormSubmit {
    /** The URL exactly as typed — stored verbatim on the node. */
    url: string;
    options: YouTubeOptions;
}
declare const YOUTUBE_DEFAULT_OPTIONS: Required<YouTubeOptions>;
interface YouTubeFormProps {
    /** `"insert"` for new embeds, `"edit"` for changing an existing one. */
    mode: "insert" | "edit";
    /** Pre-filled URL (typically `https://www.youtube.com/watch?v=ID`) when editing. */
    initialUrl?: string;
    /** Current player options when editing. */
    initialOptions?: Required<YouTubeOptions>;
    /** Submitted on Embed/Save click with parsed video ID + final options. */
    onSubmit: (data: YouTubeFormSubmit) => void;
    /** Cancel — discards changes and closes the form. */
    onCancel: () => void;
    /** Remove — only shown in `"edit"` mode. */
    onRemove?: () => void;
}
/**
 * Unified YouTube create / edit form. Same fields render in both modes;
 * only the action buttons and header copy change. Inspired by Payload CMS,
 * which uses one form schema across the create and edit flows.
 */
declare function YouTubeForm({ mode, initialUrl, initialOptions, onSubmit, onCancel, onRemove, }: YouTubeFormProps): react_jsx_runtime.JSX.Element;
declare namespace YouTubeForm {
    var displayName: string;
}

type AudioPreload = "none" | "metadata" | "auto";
interface AudioOptions {
    /** Optional title shown above the player */
    title?: string;
    /** Auto-start playback on load (browsers require `muted` for this). */
    autoplay?: boolean;
    /** Loop after the track ends. */
    loop?: boolean;
    /** Start playback muted. Required by browsers when `autoplay` is on. */
    muted?: boolean;
    /** Show native player controls (default `true`). */
    controls?: boolean;
    /** How aggressively to preload the source (default `"metadata"`). */
    preload?: AudioPreload;
}
type SerializedAudioNode = Spread<{
    src: string;
    options?: AudioOptions;
}, SerializedDecoratorBlockNode>;
/**
 * Audio embed block backed by the native `<audio>` element. Wrapped in
 * `BlockWithAlignableContents` for selection / alignment support.
 *
 * Hover the embed → gear button at top-right → opens unified
 * `AudioForm` in `"edit"` mode (URL + options + Delete).
 */
declare class AudioNode extends DecoratorBlockNode {
    __src: string;
    __options: Required<AudioOptions>;
    static getType(): string;
    static clone(node: AudioNode): AudioNode;
    static importJSON(serialized: SerializedAudioNode): AudioNode;
    exportJSON(): SerializedAudioNode;
    constructor(src: string, options?: AudioOptions, format?: ElementFormatType, key?: NodeKey);
    getSrc(): string;
    setSrc(src: string): this;
    getOptions(): Required<AudioOptions>;
    setOptions(options: AudioOptions): this;
    getTextContent(): string;
    decorate(_editor: LexicalEditor, config: EditorConfig): React.ReactElement;
}
declare function $createAudioNode(src: string, options?: AudioOptions): AudioNode;
declare function $isAudioNode(node: LexicalNode | null | undefined): node is AudioNode;
/** Heuristic — matches direct audio file URLs by extension. */
declare function isAudioUrl(url: string): boolean;

interface AudioFormSubmit {
    src: string;
    options: AudioOptions;
}
declare const AUDIO_DEFAULT_OPTIONS: Required<AudioOptions>;
interface AudioFormProps {
    mode: "insert" | "edit";
    initialSrc?: string;
    initialOptions?: Required<AudioOptions>;
    onSubmit: (data: AudioFormSubmit) => void;
    onCancel: () => void;
    onRemove?: () => void;
}
/**
 * Unified audio create / edit form. Same fields render in both modes;
 * only action buttons and Delete visibility change.
 */
declare function AudioForm({ mode, initialSrc, initialOptions, onSubmit, onCancel, onRemove, }: AudioFormProps): react_jsx_runtime.JSX.Element;
declare namespace AudioForm {
    var displayName: string;
}

type VideoPreload = "none" | "metadata" | "auto";
type VideoAspectRatio = "16:9" | "4:3" | "1:1" | "9:16";
interface VideoOptions {
    /** Optional title (shown in form, not rendered on the video itself). */
    title?: string;
    /** Poster image URL displayed before playback. */
    poster?: string;
    /** Aspect ratio of the player frame (default `"16:9"`). */
    aspectRatio?: VideoAspectRatio;
    /** Auto-start playback on load (browsers require `muted`). */
    autoplay?: boolean;
    /** Loop after the video ends. */
    loop?: boolean;
    /** Start playback muted. Required by browsers when `autoplay` is on. */
    muted?: boolean;
    /** Show native player controls (default `true`). */
    controls?: boolean;
    /** Preload behaviour (default `"metadata"`). */
    preload?: VideoPreload;
    /**
     * CMS media ID. When set, the node is ID-addressed: `src` is resolved
     * at render time via `resolveImageSrc` on `RichTextEditor` and is left
     * out of `exportJSON()` — the document stores only the ID.
     */
    videoId?: string;
}
type SerializedVideoNode = Spread<{
    src?: string;
    options?: VideoOptions;
}, SerializedDecoratorBlockNode>;
/**
 * Video embed block backed by the native `<video>` element with poster
 * + aspect ratio support. Wrapped in `BlockWithAlignableContents` for
 * selection / alignment.
 *
 * Hover the embed → gear button at top-right → opens unified
 * `VideoForm` in `"edit"` mode.
 */
declare class VideoNode extends DecoratorBlockNode {
    __src: string;
    __options: Required<VideoOptions>;
    static getType(): string;
    static clone(node: VideoNode): VideoNode;
    static importJSON(serialized: SerializedVideoNode): VideoNode;
    /** ID-addressed videos omit `src` — see `ImageNode.exportJSON()`. */
    exportJSON(): SerializedVideoNode;
    constructor(src: string, options?: VideoOptions, format?: ElementFormatType, key?: NodeKey);
    getSrc(): string;
    setSrc(src: string): this;
    getOptions(): Required<VideoOptions>;
    setOptions(options: VideoOptions): this;
    getTextContent(): string;
    decorate(_editor: LexicalEditor, config: EditorConfig): React.ReactElement;
}
declare function $createVideoNode(src: string, options?: VideoOptions): VideoNode;
declare function $isVideoNode(node: LexicalNode | null | undefined): node is VideoNode;
/** Heuristic — matches direct video file URLs by extension. */
declare function isVideoUrl(url: string): boolean;

interface VideoFormSubmit {
    src: string;
    options: VideoOptions;
}
declare const VIDEO_DEFAULT_OPTIONS: Required<VideoOptions>;
interface VideoFormProps {
    mode: "insert" | "edit";
    initialSrc?: string;
    initialOptions?: Required<VideoOptions>;
    onSubmit: (data: VideoFormSubmit) => void;
    onCancel: () => void;
    onRemove?: () => void;
}
/**
 * Unified video create / edit form. Same fields render in both modes;
 * only action buttons and Delete visibility change.
 */
declare function VideoForm({ mode, initialSrc, initialOptions, onSubmit, onCancel, onRemove, }: VideoFormProps): react_jsx_runtime.JSX.Element;
declare namespace VideoForm {
    var displayName: string;
}

interface ImageOptions {
    /** Accessibility label — required for SEO and screen readers. */
    alt?: string;
    /** Optional caption shown below the image. */
    caption?: string;
    /** Maximum display width in pixels. `0` = natural / responsive. */
    maxWidth?: number;
    /**
     * CMS media ID. When set, this node is ID-addressed: `src` is treated
     * as a transient preview value, resolved at render time through the
     * `resolveImageSrc` callback given to `RichTextEditor`, and is
     * deliberately left out of `exportJSON()` — the host app owns the URL,
     * the document only stores the ID.
     */
    imageId?: string;
}
type SerializedImageNode = Spread<{
    src?: string;
    options?: ImageOptions;
}, SerializedDecoratorBlockNode>;
/**
 * Image embed block. Wraps a native `<img>` inside a `<figure>` with an
 * optional `<figcaption>`. Handles all browser-native image formats —
 * including animated GIFs, which the browser plays automatically.
 */
declare class ImageNode extends DecoratorBlockNode {
    __src: string;
    __options: Required<ImageOptions>;
    static getType(): string;
    static clone(node: ImageNode): ImageNode;
    static importJSON(serialized: SerializedImageNode): ImageNode;
    /** ID-addressed images omit `src` entirely — the URL belongs to the
     *  host app's media service, not to the document. URL-addressed
     *  images serialize exactly as before. */
    exportJSON(): SerializedImageNode;
    constructor(src: string, options?: ImageOptions, format?: ElementFormatType, key?: NodeKey);
    getSrc(): string;
    setSrc(src: string): this;
    getOptions(): Required<ImageOptions>;
    setOptions(options: ImageOptions): this;
    getTextContent(): string;
    decorate(_editor: LexicalEditor, config: EditorConfig): React.ReactElement;
}
declare function $createImageNode(src: string, options?: ImageOptions): ImageNode;
declare function $isImageNode(node: LexicalNode | null | undefined): node is ImageNode;
/** Heuristic — matches direct image file URLs by extension (incl. .gif). */
declare function isImageUrl(url: string): boolean;

interface ImageFormSubmit {
    src: string;
    options: ImageOptions;
}
declare const IMAGE_DEFAULT_OPTIONS: Required<ImageOptions>;
interface ImageFormProps {
    mode: "insert" | "edit";
    initialSrc?: string;
    initialOptions?: Required<ImageOptions>;
    onSubmit: (data: ImageFormSubmit) => void;
    onCancel: () => void;
    onRemove?: () => void;
}
/**
 * Unified image create / edit form. Handles all browser-native formats
 * (.jpg, .png, .webp, .avif, .svg, .gif).
 */
declare function ImageForm({ mode, initialSrc, initialOptions, onSubmit, onCancel, onRemove, }: ImageFormProps): react_jsx_runtime.JSX.Element;
declare namespace ImageForm {
    var displayName: string;
}

type IframeAspectRatio = "16:9" | "4:3" | "1:1" | "9:16" | "custom";
interface IframeOptions {
    /** Accessibility label — read by screen readers, helps SEO. */
    title?: string;
    /** Aspect ratio of the frame, or `"custom"` to use `customHeight` (px). */
    aspectRatio?: IframeAspectRatio;
    /** Height in px, used only when `aspectRatio === "custom"`. */
    customHeight?: number;
    /** Allow content to enter fullscreen via the Fullscreen API. */
    allowFullscreen?: boolean;
}
type SerializedIframeNode = Spread<{
    src: string;
    options?: IframeOptions;
}, SerializedDecoratorBlockNode>;
/**
 * Generic iframe embed block. For embeds outside the dedicated YouTube /
 * Audio / Video flows: Figma, CodePen, Spotify, Maps, custom HTML pages.
 *
 * Not auto-embedded by URL paste — iframes can run third-party JS, so
 * inserting them must be an explicit user action via the Insert menu.
 */
declare class IframeNode extends DecoratorBlockNode {
    __src: string;
    __options: Required<IframeOptions>;
    static getType(): string;
    static clone(node: IframeNode): IframeNode;
    static importJSON(serialized: SerializedIframeNode): IframeNode;
    exportJSON(): SerializedIframeNode;
    constructor(src: string, options?: IframeOptions, format?: ElementFormatType, key?: NodeKey);
    getSrc(): string;
    setSrc(src: string): this;
    getOptions(): Required<IframeOptions>;
    setOptions(options: IframeOptions): this;
    getTextContent(): string;
    decorate(_editor: LexicalEditor, config: EditorConfig): React.ReactElement;
}
declare function $createIframeNode(src: string, options?: IframeOptions): IframeNode;
declare function $isIframeNode(node: LexicalNode | null | undefined): node is IframeNode;

interface IframeFormSubmit {
    src: string;
    options: IframeOptions;
}
declare const IFRAME_DEFAULT_OPTIONS: Required<IframeOptions>;
interface IframeFormProps {
    mode: "insert" | "edit";
    initialSrc?: string;
    initialOptions?: Required<IframeOptions>;
    onSubmit: (data: IframeFormSubmit) => void;
    onCancel: () => void;
    onRemove?: () => void;
}
/**
 * Unified iframe create / edit form. For embeds outside the dedicated
 * YouTube / Audio / Video flows.
 */
declare function IframeForm({ mode, initialSrc, initialOptions, onSubmit, onCancel, onRemove, }: IframeFormProps): react_jsx_runtime.JSX.Element;
declare namespace IframeForm {
    var displayName: string;
}

type ComparisonOrientation = "horizontal" | "vertical";
type ComparisonAspectRatio = "16:9" | "4:3" | "1:1" | "9:16" | "custom";
interface ImageComparisonOptions {
    beforeAlt?: string;
    afterAlt?: string;
    beforeLabel?: string;
    afterLabel?: string;
    showLabels?: boolean;
    orientation?: ComparisonOrientation;
    /** Initial divider position as a percentage (0-100). Default `50`. */
    initialPosition?: number;
    aspectRatio?: ComparisonAspectRatio;
    /** Used only when `aspectRatio === "custom"`. */
    customHeight?: number;
}
type SerializedImageComparisonNode = Spread<{
    beforeSrc: string;
    afterSrc: string;
    options?: ImageComparisonOptions;
}, SerializedDecoratorBlockNode>;
/**
 * Before/after image comparison block. Two images stacked with a draggable
 * divider that reveals more of one or the other. Supports horizontal and
 * vertical orientations, mouse + touch + keyboard input.
 */
declare class ImageComparisonNode extends DecoratorBlockNode {
    __beforeSrc: string;
    __afterSrc: string;
    __options: Required<ImageComparisonOptions>;
    static getType(): string;
    static clone(node: ImageComparisonNode): ImageComparisonNode;
    static importJSON(serialized: SerializedImageComparisonNode): ImageComparisonNode;
    exportJSON(): SerializedImageComparisonNode;
    constructor(beforeSrc: string, afterSrc: string, options?: ImageComparisonOptions, format?: ElementFormatType, key?: NodeKey);
    getBeforeSrc(): string;
    getAfterSrc(): string;
    setSources(beforeSrc: string, afterSrc: string): this;
    getOptions(): Required<ImageComparisonOptions>;
    setOptions(options: ImageComparisonOptions): this;
    getTextContent(): string;
    decorate(_editor: LexicalEditor, config: EditorConfig): React.ReactElement;
}
declare function $createImageComparisonNode(beforeSrc: string, afterSrc: string, options?: ImageComparisonOptions): ImageComparisonNode;
declare function $isImageComparisonNode(node: LexicalNode | null | undefined): node is ImageComparisonNode;

interface ImageComparisonFormSubmit {
    beforeSrc: string;
    afterSrc: string;
    options: ImageComparisonOptions;
}
declare const IMAGE_COMPARISON_DEFAULT_OPTIONS: Required<ImageComparisonOptions>;
interface ImageComparisonFormProps {
    mode: "insert" | "edit";
    initialBeforeSrc?: string;
    initialAfterSrc?: string;
    initialOptions?: Required<ImageComparisonOptions>;
    onSubmit: (data: ImageComparisonFormSubmit) => void;
    onCancel: () => void;
    onRemove?: () => void;
}
/**
 * Unified image comparison create / edit form. Two image URLs (before +
 * after) plus appearance options (orientation, aspect ratio, initial
 * divider position, labels).
 */
declare function ImageComparisonForm({ mode, initialBeforeSrc, initialAfterSrc, initialOptions, onSubmit, onCancel, onRemove, }: ImageComparisonFormProps): react_jsx_runtime.JSX.Element;
declare namespace ImageComparisonForm {
    var displayName: string;
}

type ColumnsGap = "small" | "medium" | "large";
declare const COLUMNS_MIN = 2;
declare const COLUMNS_MAX = 6;
type SerializedColumnsNode = Spread<{
    columnsCount: number;
    gap: ColumnsGap;
    mobileStack: boolean;
}, SerializedElementNode>;
/**
 * Multi-column responsive grid container. Holds N `ColumnNode` children
 * (`COLUMNS_MIN` ≤ N ≤ `COLUMNS_MAX`); user content (paragraphs, lists,
 * images, ...) lives inside each column and is edited natively.
 *
 * Stacks to a single column on narrow viewports when `mobileStack` is on.
 */
declare class ColumnsNode extends ElementNode {
    __count: number;
    __gap: ColumnsGap;
    __mobileStack: boolean;
    static getType(): string;
    static clone(node: ColumnsNode): ColumnsNode;
    static importJSON(serialized: SerializedColumnsNode): ColumnsNode;
    exportJSON(): SerializedColumnsNode;
    constructor(count?: number, gap?: ColumnsGap, mobileStack?: boolean, key?: NodeKey);
    getCount(): number;
    setCount(count: number): this;
    getGap(): ColumnsGap;
    setGap(gap: ColumnsGap): this;
    getMobileStack(): boolean;
    setMobileStack(value: boolean): this;
    createDOM(_config: EditorConfig): HTMLElement;
    updateDOM(prev: ColumnsNode, dom: HTMLElement): boolean;
    canBeEmpty(): false;
    isShadowRoot(): boolean;
}
/**
 * Single column inside a `ColumnsNode`. Just a flex/grid cell wrapper —
 * children are arbitrary content (paragraph, heading, list, image, ...).
 */
declare class ColumnNode extends ElementNode {
    static getType(): string;
    static clone(node: ColumnNode): ColumnNode;
    static importJSON(_serialized: SerializedElementNode): ColumnNode;
    createDOM(_config: EditorConfig): HTMLElement;
    updateDOM(): boolean;
    /**
     * A column is an independent region that holds block-level children,
     * so it has to declare itself a shadow root.
     *
     * Without this, `RangeSelection.insertNodes` treats a column as an
     * inline-only element and flattens anything block-level being inserted
     * into it to inline content — silently dropping nodes with no inline
     * form (images, embeds, every CMS block). Slash-inserting a gallery
     * into a column did nothing at all.
     */
    isShadowRoot(): boolean;
}
interface CreateColumnsOptions {
    count?: number;
    gap?: ColumnsGap;
    mobileStack?: boolean;
}
declare function $createColumnsNode(options?: CreateColumnsOptions): ColumnsNode;
declare function $createColumnNode(): ColumnNode;
declare function $isColumnsNode(node: LexicalNode | null | undefined): node is ColumnsNode;
declare function $isColumnNode(node: LexicalNode | null | undefined): node is ColumnNode;

interface ColumnsFormSubmit {
    count: number;
    gap: ColumnsGap;
    mobileStack: boolean;
}
declare const COLUMNS_DEFAULT_OPTIONS: ColumnsFormSubmit;
interface ColumnsFormProps {
    initialOptions?: ColumnsFormSubmit;
    onSubmit: (data: ColumnsFormSubmit) => void;
    onCancel: () => void;
}
/**
 * Insert form for the columns layout. Edit-time tweaks happen via the
 * floating `RichTextColumnsToolbar` (count, gap, mobile stack).
 */
declare function ColumnsForm({ initialOptions, onSubmit, onCancel, }: ColumnsFormProps): react_jsx_runtime.JSX.Element;
declare namespace ColumnsForm {
    var displayName: string;
}

interface RichTextColumnsToolbarProps {
    /** Element used as positioning anchor (typically the editor's content wrapper) */
    anchorElem: HTMLElement;
}
/**
 * Floating toolbar shown above the active `ColumnsNode` whenever the
 * cursor is inside one of its columns. Provides table-like contextual
 * column operations (insert L/R, move L/R, delete this column) plus
 * block-level options (gap, mobile stack, delete all).
 */
declare function RichTextColumnsToolbar({ anchorElem, }: RichTextColumnsToolbarProps): React.ReactPortal | null;
declare namespace RichTextColumnsToolbar {
    var displayName: string;
}

/** Lexical's own block keys plus one top-level key per spec field. */
type SerializedCmsBlockNode = SerializedDecoratorBlockNode & {
    [field: string]: unknown;
};
/**
 * Shared behaviour for every Eglador CMS block. Concrete per-type
 * classes are produced by {@link createCmsNodeClass} — each one carries
 * its own `getType()`, so a gallery serializes as
 * `{"type":"galeri","version":1,"format":"","id":"123"}`, matching how
 * the built-in image/video nodes serialize rather than collapsing every
 * CMS block into one generic node type.
 */
declare class CmsBlockNode extends DecoratorBlockNode {
    __fields: CmsFieldValues;
    constructor(fields?: CmsFieldValues, format?: ElementFormatType, key?: NodeKey);
    /** The spec this node was generated from. Overridden by every class
     *  {@link createCmsNodeClass} produces — the base is never registered
     *  with an editor on its own. */
    getSpec(): CmsBlockSpec;
    getFields(): CmsFieldValues;
    setFields(fields: CmsFieldValues): this;
    /** Field values are spread as top-level keys — the same flat shape
     *  `ImageNode` uses for `src` — with Lexical's own keys applied last
     *  so a stray field name can never clobber them. */
    exportJSON(): SerializedCmsBlockNode;
    /** Decorators render through React, so `$generateHtmlFromNodes` would
     *  otherwise emit the empty host `<div>`. Export the block as a
     *  data-attributed element instead, so HTML output stays lossless and
     *  machine-readable. */
    exportDOM(_editor: LexicalEditor): DOMExportOutput;
    decorate(_editor: LexicalEditor, config: EditorConfig): React.ReactElement;
}
/**
 * Shape of a generated CMS node class. Declared explicitly rather than
 * inferred: the inferred type of the anonymous class inside
 * {@link createCmsNodeClass} reaches into Lexical internals that aren't
 * exported, which `tsup`'s .d.ts build can't name.
 */
type CmsNodeClass = Klass<CmsBlockNode>;
/**
 * Build a concrete Lexical node class for one CMS block spec.
 *
 * One class per type is what makes the JSON come out right: Lexical
 * keys its node registry by `getType()` and writes that same string
 * into `exportJSON()`, so the generated class must own the type — a
 * single shared class would serialize everything as one type.
 */
declare function createCmsNodeClass(spec: CmsBlockSpec): CmsNodeClass;
declare function $isCmsBlockNode(node: LexicalNode | null | undefined): node is CmsBlockNode;

/**
 * Eglador CMS block set. Each entry becomes a real Lexical
 * `DecoratorBlockNode` (see `cms-node-factory.tsx`) whose `type` is the
 * `type` field below — so a gallery serializes as
 * `{"type":"galeri","version":1,"format":"","id":"123"}`, exactly like
 * the built-in image/video blocks, not as a `#galeri#123#` text run.
 *
 * Types already covered by a built-in block are deliberately absent:
 * `resim` → the `image` block (ID mode), `video` → the `video` block
 * (ID mode), `imagecompare` → the `image-comparison` block.
 */
declare const CMS_BLOCK_SCHEMA: CmsBlockSpec[];

/** Seed values for a brand-new block: selects default to their first
 *  option (so a required select is never submitted empty), everything
 *  else starts blank. */
declare function initialCmsValues(spec: CmsBlockSpec): CmsFieldValues;
interface CmsFormProps {
    spec: CmsBlockSpec;
    /** `"insert"` for a new block, `"edit"` for an existing one. */
    mode: "insert" | "edit";
    initialValues?: CmsFieldValues;
    onSubmit: (values: CmsFieldValues) => void;
    onCancel: () => void;
    /** Only rendered in `"edit"` mode. */
    onRemove?: () => void;
}
/**
 * Builds a form from a `CmsBlockSpec`'s field list. Shared by both the
 * insert surfaces (toolbar "+" / slash) and the per-block edit popover,
 * mirroring the single-schema-two-modes pattern the built-in media
 * forms use (see `youtube-form.tsx`).
 */
declare function CmsForm({ spec, mode, initialValues, onSubmit, onCancel, onRemove, }: CmsFormProps): react_jsx_runtime.JSX.Element;
declare namespace CmsForm {
    var displayName: string;
}

interface CmsBlockProps {
    spec: CmsBlockSpec;
    fields: CmsFieldValues;
    onSave: (values: CmsFieldValues) => void;
    onRemove: () => void;
}
/**
 * In-editor rendering for a CMS block: the spec's custom preview (or a
 * generic field-summary card) plus a hover gear that opens the same
 * form used to insert it. Purely presentational — the owning node wires
 * `onSave` / `onRemove`, which keeps this module free of any import
 * back into the node factory.
 */
declare function CmsBlock({ spec, fields, onSave, onRemove }: CmsBlockProps): react_jsx_runtime.JSX.Element;
declare namespace CmsBlock {
    var displayName: string;
}

/** Split an `image-ids` field value into individual IDs. */
declare function parseIdList(value: string | undefined): string[];
interface MediaThumbProps {
    id: string;
    alt?: string;
    className?: string;
}
/**
 * A single media ID rendered through the host's resolver. Shows a
 * skeleton while an async resolver is in flight and a labeled
 * placeholder when the ID can't be resolved — never a broken image.
 */
declare function MediaThumb({ id, alt, className }: MediaThumbProps): react_jsx_runtime.JSX.Element;

/** Every generated CMS node class — register these with the composer
 *  (already included in `defaultNodes`). */
declare const cmsNodes: Klass<LexicalNode>[];
/**
 * Create a CMS block node by type. Returns `null` for an unknown type
 * rather than throwing, so callers importing external content can skip
 * unrecognized blocks.
 */
declare function $createCmsNode(type: string, fields?: CmsFieldValues): CmsBlockNode | null;
/** Registry entries for the CMS blocks — merged into `defaultBlocks`,
 *  so they appear in the toolbar Insert menu and the slash menu. */
declare const cmsBlocks: BlockSpec[];

/** Field values stored on the node, keyed by the spec's field names. */
type NoteMeta = Record<string, string>;
/** Lexical's own element keys plus one top-level key per spec field. */
type SerializedNoteBlockNode = SerializedElementNode & {
    [field: string]: unknown;
};
/** Find the slot the chrome plugin portals a note's header into. */
declare function getNoteHeaderElement(wrapper: HTMLElement): HTMLElement | null;
/**
 * Shared behaviour for "note" blocks — structured metadata in the header
 * plus a **freely editable body**.
 *
 * Unlike the CMS decorator blocks these are `ElementNode`s: the body's
 * paragraphs are real children of the main editor, so typing, inline
 * formatting, undo/redo and selection all behave natively and the
 * content serializes as an ordinary Lexical `children` array rather than
 * as an opaque string.
 *
 * `createDOM` builds a wrapper holding a non-editable header and an
 * editable body; `getDOMSlot` points Lexical at the body so children land
 * there and the header stays clear for the chrome plugin
 * (`note-chrome.tsx`) to portal React into.
 */
declare class NoteBlockNode extends ElementNode {
    __meta: NoteMeta;
    constructor(meta?: NoteMeta, key?: NodeKey);
    /** The spec this node was generated from — overridden by every class
     *  {@link createNoteNodeClass} produces. */
    getSpec(): CmsBlockSpec;
    getMeta(): NoteMeta;
    setMeta(meta: NoteMeta): this;
    exportJSON(): SerializedNoteBlockNode;
    createDOM(_config: EditorConfig): HTMLElement;
    /** Children belong in the body, not next to the header. */
    getDOMSlot(element: HTMLElement): lexical.ElementDOMSlot<HTMLElement>;
    updateDOM(): false;
    /**
     * The body is an independent editing region that may hold block-level
     * children, so it has to declare itself a shadow root.
     *
     * Without this, `RangeSelection.insertNodes` reaches its "block ancestor
     * whose parent is not a root or shadow root" branch and treats the note
     * as an inline-only element: it flattens whatever is being inserted to
     * inline content and **silently drops** anything with no inline form —
     * which is every block-level CMS node. Slash-inserting a gallery inside
     * the body did nothing at all.
     */
    isShadowRoot(): boolean;
    canIndent(): false;
}
type NoteNodeClass = Klass<NoteBlockNode>;
/** Blank values for every field the spec declares. */
declare function emptyNoteMeta(spec: CmsBlockSpec): NoteMeta;
/**
 * Build a concrete Lexical node class for one note spec.
 *
 * One class per type is what makes the JSON come out right: Lexical keys
 * its node registry by `getType()` and writes that same string into
 * `exportJSON()`, so the generated class must own the type.
 */
declare function createNoteNodeClass(spec: CmsBlockSpec): NoteNodeClass;
declare function $isNoteBlockNode(node: LexicalNode | null | undefined): node is NoteBlockNode;

/**
 * Metadata form fields — the body is edited inline, so it has no field
 * here. Date, time and title are required: they are asked for when the
 * block is inserted and can be revised later from its header.
 */
declare const NEWS_MOMENT_META_FIELDS: CmsFieldSpec[];
/** Shared by the insert form and the in-document header's edit popover,
 *  so both always ask for exactly the same things. */
declare const NEWS_MOMENT_SPEC: CmsBlockSpec;
type NewsMomentMeta = NoteMeta;
declare const NEWS_MOMENT_DEFAULT_META: NewsMomentMeta;
/** Today's date / current time, in the shapes the native pickers want.
 *  Used to prefill the insert form — a live blog entry is almost always
 *  "now", and the user can still change either field. */
declare function nowMeta(): {
    date: string;
    time: string;
};
/** A news moment: date, time, title and image IDs in the header, with a
 *  freely editable body. See `note-block-node.tsx` for the mechanics. */
declare const NewsMomentNode: (new (...args: any[]) => NoteBlockNode) & (new (...args: any[]) => lexical.ElementNode) & {
    prototype: lexical.ElementNode;
    getType: typeof LexicalNode.getType;
    clone: typeof LexicalNode.clone;
    importDOM?: (() => lexical.DOMConversionMap<any> | null) | undefined;
    importJSON: typeof LexicalNode.importJSON;
    transform: typeof LexicalNode.transform;
};
declare function $createEmptyNewsMomentNode(meta?: NewsMomentMeta): NoteBlockNode;
declare function $createNewsMomentNode(meta?: NewsMomentMeta): NoteBlockNode;
declare function $isNewsMomentNode(node: LexicalNode | null | undefined): node is NoteBlockNode;

/**
 * Same shape as a news moment minus the timestamp — a context note is
 * background information attached to a story, not a dated entry in a
 * live blog, so `date` / `time` would only be noise.
 */
declare const CONTEXT_NOTE_META_FIELDS: CmsFieldSpec[];
declare const CONTEXT_NOTE_SPEC: CmsBlockSpec;
type ContextNoteMeta = NoteMeta;
declare const CONTEXT_NOTE_DEFAULT_META: ContextNoteMeta;
/** A context note: title and image IDs in the header, with a freely
 *  editable body. See `note-block-node.tsx` for the mechanics. */
declare const ContextNoteNode: (new (...args: any[]) => NoteBlockNode) & (new (...args: any[]) => lexical.ElementNode) & {
    prototype: lexical.ElementNode;
    getType: typeof LexicalNode.getType;
    clone: typeof LexicalNode.clone;
    importDOM?: (() => lexical.DOMConversionMap<any> | null) | undefined;
    importJSON: typeof LexicalNode.importJSON;
    transform: typeof LexicalNode.transform;
};
declare function $createEmptyContextNoteNode(meta?: ContextNoteMeta): NoteBlockNode;
declare function $createContextNoteNode(meta?: ContextNoteMeta): NoteBlockNode;
declare function $isContextNoteNode(node: LexicalNode | null | undefined): node is NoteBlockNode;

/**
 * Renders the non-editable header of every note block in the document
 * (news moments, context notes).
 *
 * These are `ElementNode`s, so their bodies are edited natively and
 * Lexical owns that DOM — but the header slot each one reserves stays
 * untouched, which lets us portal real React (and therefore hooks like
 * `useResolvedSrc` for the thumbnails) into it.
 *
 * Rendered automatically by `RichTextContent`.
 */
declare function RichTextNoteChrome(): React.ReactElement | null;
declare namespace RichTextNoteChrome {
    var displayName: string;
}
/** @deprecated Renamed to `RichTextNoteChrome` — it now covers every
 *  note-style block, not just news moments. */
declare const RichTextNewsMomentChrome: typeof RichTextNoteChrome;

interface RichTextStatsValue {
    /** Total characters including whitespace. */
    characters: number;
    /** Total characters excluding whitespace. */
    charactersNoSpaces: number;
    /** Word count (whitespace-separated, non-empty tokens). */
    words: number;
    /** Estimated reading time in minutes (rounded up, 200 wpm). */
    readingMinutes: number;
}
interface RichTextStatsProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "children"> {
    /** Show word count (default `true`) */
    showWords?: boolean;
    /** Show character count (default `true`) */
    showCharacters?: boolean;
    /** Show estimated reading time (default `false`) */
    showReadingTime?: boolean;
    /** Exclude whitespace when counting characters (default `false`) */
    excludeSpaces?: boolean;
    /** Words per minute used for reading time estimate (default `200`) */
    wordsPerMinute?: number;
    /** Custom render — receives live stats, returns ReactNode. Overrides
     *  the default segmented label rendering when provided. */
    children?: (stats: RichTextStatsValue) => React.ReactNode;
}
/**
 * Live document statistics — words, characters, optional reading time.
 * Reads the root text content on every editor update and re-renders.
 *
 * Render inside `<RichTextEditor>` to enable, like other plugin
 * composables (page-size, slash, auto-embed):
 *
 * ```tsx
 * <RichTextEditor>
 *   <RichTextToolbar />
 *   <RichTextContent />
 *   <RichTextStats showReadingTime />
 * </RichTextEditor>
 * ```
 */
declare function RichTextStats({ showWords, showCharacters, showReadingTime, excludeSpaces, wordsPerMinute, className, children, ...props }: RichTextStatsProps): react_jsx_runtime.JSX.Element;
declare namespace RichTextStats {
    var displayName: string;
}

/**
 * Find & Replace panel — Cmd/Ctrl+F to open, Esc to close.
 *
 * Active match is highlighted via the editor's native selection (blue
 * range), other matches stay un-highlighted. Match counter shows
 * `current / total`. Enter / Shift+Enter navigates while the find input
 * is focused.
 *
 * Render inside `<RichTextEditor>` like other plugin composables:
 *
 * ```tsx
 * <RichTextEditor>
 *   <RichTextToolbar />
 *   <RichTextContent />
 *   <RichTextFindReplace />
 * </RichTextEditor>
 * ```
 */
declare function RichTextFindReplace(): react_jsx_runtime.JSX.Element | null;
declare namespace RichTextFindReplace {
    var displayName: string;
}

type PageSizeName = "full" | "desktop" | "tablet" | "mobile" | "custom";
interface PageSize {
    name: PageSizeName;
    /** Width constraint in px; `null` means no constraint (full width) */
    width: number | null;
}
interface PageSizeContextValue {
    size: PageSize;
    setSize: (size: PageSize) => void;
}
/**
 * Read/write the active page size. Falls back to a no-op when no
 * provider is mounted, so consumers render harmlessly outside an editor.
 */
declare function usePageSize(): PageSizeContextValue;

interface Preset {
    name: PageSizeName;
    label: string;
    width: number | null;
    Icon: React.ComponentType<{
        className?: string;
    }>;
}
interface RichTextPageSizeProps extends React.HTMLAttributes<HTMLDivElement> {
    /** Custom preset list (overrides defaults) */
    presets?: Preset[];
    /** Hide the custom width input */
    hideCustom?: boolean;
}
/**
 * Bottom-anchored device toolbar — DevTools-style. Place after
 * `<RichTextContent />` inside `<RichTextEditor>` and it visually attaches
 * to the editor's lower edge with a top border and subtle backdrop.
 *
 * Layout: pill button group (Full / Desktop / Tablet / Mobile) · live
 * dimensions readout (`1280 × auto`) · custom px input.
 */
declare function RichTextPageSize({ presets, hideCustom, className, ...props }: RichTextPageSizeProps): react_jsx_runtime.JSX.Element;
declare namespace RichTextPageSize {
    var displayName: string;
}

type RichTextOutputTab = "html" | "markdown" | "json" | "text";
interface RichTextOutputProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "children"> {
    /** Tabs to render. Default: all four. */
    tabs?: RichTextOutputTab[];
    /** Active tab on first render. Default: first entry in `tabs`. */
    defaultTab?: RichTextOutputTab;
    /** Show the Copy button. Default: `true`. */
    showCopy?: boolean;
    /** Show the Download button. Default: `true`. */
    showDownload?: boolean;
    /** Filename stem for downloads. Final name is `${downloadName}.{ext}`. Default: `richtext`. */
    downloadName?: string;
    /** Max content height (Tailwind class). Default: `max-h-72`. */
    maxHeight?: string;
    /**
     * Override the editor's `inlineTextStyles` setting for this panel.
     * Omit to mirror what `onChange` / `getJson()` produce — which is the
     * point of the panel. Pass `false` to inspect the raw Lexical shape.
     */
    inlineTextStyles?: boolean | InlineTextStyleOptions;
}
/**
 * Live serialization panel — tabbed view of the current editor state as
 * HTML, Markdown, Lexical JSON and plain text. Place after `<RichTextContent />`
 * inside `<RichTextEditor>`; subscribes to editor updates via
 * `registerUpdateListener`.
 */
declare function RichTextOutput({ tabs, defaultTab, showCopy, showDownload, downloadName, maxHeight, inlineTextStyles, className, ...props }: RichTextOutputProps): react_jsx_runtime.JSX.Element;
declare namespace RichTextOutput {
    var displayName: string;
}

/**
 * Placeholder media the generated document points at. Override any of
 * these so the demo document renders against your own CDN / media IDs
 * instead of the public samples.
 */
interface AllComponentsSample {
    /** URL for the URL-addressed image block. */
    imageUrl: string;
    /** ID for the ID-addressed image block (resolved via `resolveImageSrc`). */
    imageId: string;
    /** ID for the ID-addressed video block. */
    videoId: string;
    /** YouTube URL, stored on the node verbatim. */
    youtubeUrl: string;
    audioUrl: string;
    iframeUrl: string;
    compareBeforeUrl: string;
    compareAfterUrl: string;
    /** Media IDs used for `image-ids` fields (e.g. `newsMoment.images`). */
    mediaIds: string[];
    /** URL used by CMS types that preview a direct image URL. */
    cmsImageUrl: string;
    /** URL used by CMS types whose URL is a plain link, not an image. */
    cmsLinkUrl: string;
    /** `newsMoment` date, `YYYY-MM-DD`. Defaults to today. */
    newsMomentDate: string;
    /** `newsMoment` time, `HH:mm`. */
    newsMomentTime: string;
    newsMomentTitle: string;
}
declare const ALL_COMPONENTS_DEFAULT_SAMPLE: AllComponentsSample;
interface AllComponentsOptions {
    /**
     * `"replace"` (default) empties the document first; `"append"` keeps
     * what's there and adds the blocks at the end.
     */
    mode?: "replace" | "append";
    /** Include the `h1`/`h2` section headings and explanatory paragraphs. */
    includeHeadings?: boolean;
    /** Include the built-in blocks (text, table, columns, media). */
    includeBuiltIns?: boolean;
    /**
     * Restrict the CMS section to these types (defaults to every type in
     * `CMS_BLOCK_SCHEMA`). Pass `[]` to skip CMS blocks entirely.
     */
    cmsTypes?: string[];
    /** Placeholder media overrides — see {@link AllComponentsSample}. */
    sample?: Partial<AllComponentsSample>;
}
/**
 * Build one node per component this editor ships — text blocks, table,
 * columns, every media embed, and every CMS block — as a flat array in
 * document order.
 *
 * Must be called inside `editor.update()` / `editor.read()` (it uses
 * Lexical `$` factories). Prefer {@link insertAllComponents} unless you
 * need the nodes without inserting them.
 */
declare function $buildAllComponentNodes(options?: AllComponentsOptions): LexicalNode[];
/**
 * Insert every component into the document.
 *
 * ```ts
 * insertAllComponents(editor);                      // clear, then insert
 * insertAllComponents(editor, { mode: "append" });  // keep content, add at end
 * ```
 *
 * @returns how many top-level blocks were inserted.
 */
declare function insertAllComponents(editor: LexicalEditor, options?: AllComponentsOptions): number;
/** Shape of the function `RichTextDevGlobals` puts on `window`. */
type AllComponentsGlobal = (arg?: "replace" | "append" | AllComponentsOptions) => {
    inserted: number;
    mode: "replace" | "append";
};
interface RichTextDevGlobalsProps {
    /** Global name to register (default `"lexicalComponentAllSet"`). */
    name?: string;
}
/**
 * Registers a console helper that fills the editor with every
 * component — handy for eyeballing a integration without building any
 * UI for it. Drop it inside `<RichTextEditor>`:
 *
 * ```tsx
 * {process.env.NODE_ENV !== "production" && <RichTextDevGlobals />}
 * ```
 *
 * Then, from the browser console:
 *
 * ```js
 * lexicalComponentAllSet()                       // clear, then insert all
 * lexicalComponentAllSet("append")               // keep content, add at end
 * lexicalComponentAllSet({ mode: "append", cmsTypes: ["galeri", "newsMoment"] })
 * ```
 *
 * The global is removed on unmount. With several editors on one page,
 * give each a distinct `name`.
 */
declare function RichTextDevGlobals({ name, }?: RichTextDevGlobalsProps): null;
declare namespace RichTextDevGlobals {
    var displayName: string;
}

/** `null` disables the derived `css` key; an object enables it. */
type InlineTextStyleSetting = InlineTextStyleOptions | null;
/** Normalize the `inlineTextStyles` prop shape into a setting. */
declare function resolveInlineTextStyles(value: boolean | InlineTextStyleOptions | undefined): InlineTextStyleSetting;
declare function TextStyleProvider({ children, value, }: {
    children: React.ReactNode;
    value: InlineTextStyleSetting;
}): react_jsx_runtime.JSX.Element;
/**
 * The active inline-text-style setting. Enabled by default — including
 * outside a provider — so `getJson()` and `onChange` carry the ready-to-use
 * `css` string unless an editor explicitly opts out with
 * `inlineTextStyles={false}`.
 */
declare function useInlineTextStyles(): InlineTextStyleSetting;

interface ImagePickerProps {
    /** Currently selected media ID, if any. */
    value: string;
    onSelect: (id: string) => void;
}
/**
 * Grid of the page's image library. Selecting a tile writes its ID —
 * the URL never enters the document.
 *
 * Items without a `url` fall back to `MediaThumb`, which resolves the ID
 * through `resolveImageSrc`, so a bare list of IDs renders previews too.
 */
declare function ImagePicker({ value, onSelect }: ImagePickerProps): react_jsx_runtime.JSX.Element;
declare namespace ImagePicker {
    var displayName: string;
}

/** Match a block against a typed query — label first, then keywords. */
declare function filterBlocks(blocks: BlockSpec[], query: string): BlockSpec[];
interface BlockPickerProps {
    blocks: BlockSpec[];
    onSelect: (spec: BlockSpec) => void;
    /** Placeholder for the search field. */
    searchPlaceholder: string;
    /** Shown when the query matches nothing. */
    emptyLabel: string;
    className?: string;
}
/**
 * Searchable block list used by the "+" surfaces.
 *
 * The search field takes focus on mount so the list can be narrowed by
 * typing straight after opening the menu; ↑/↓ move the highlight and
 * Enter picks. Kept separate from the popovers themselves so the
 * drag-handle "+" and the toolbar Insert dropdown behave identically.
 */
declare function BlockPicker({ blocks, onSelect, searchPlaceholder, emptyLabel, className, }: BlockPickerProps): react_jsx_runtime.JSX.Element;
declare namespace BlockPicker {
    var displayName: string;
}

/**
 * Fully generic `#type#field#value#field#value#` shortcode format.
 *
 * Nothing here knows about any concrete component type (video, image,
 * quote, ...) — the set of types and their fields is entirely defined by
 * the consumer's own `LegacyComponentSpec[]` (see legacy-schema.ts) and
 * passed in at runtime via `createLegacyComponentBlocks()`. This module
 * only knows how to serialize/parse the generic `{ type, fields }` shape.
 */
interface LegacyComponentInput {
    type: string;
    fields: Record<string, string | number>;
}
/** Fills a `{placeholder}` template with a component's data — `{type}`
 *  becomes `input.type`; any other `{name}` becomes the value of the
 *  field called `name`. Placeholders for fields that aren't present in
 *  `input.fields` are left untouched (so a typo surfaces visibly rather
 *  than silently vanishing). */
declare function renderLegacyShortcodeTemplate(template: string, input: LegacyComponentInput): string;
/** Renders a typed component into its shortcode string. With no
 *  `template`, falls back to the default `#type#field#value#field#value#`
 *  layout (field order follows `Object.entries` insertion order). A
 *  `template` (see `LegacyComponentSpec.template`) renders via
 *  {@link renderLegacyShortcodeTemplate} instead — e.g. `"#{type}#{ID}#"`
 *  produces `#resim#345456#` instead of `#resim#ID#345456#`. */
declare function legacyComponentToShortcode(input: LegacyComponentInput, template?: string): string;
/** Parses a single `#type#field#value#field#value#` line back into the
 *  generic `{ type, fields }` shape, or `null` if it isn't a well-formed
 *  *default-format* shortcode line (must start/end with `#` and have an
 *  even number of field/value segments after the type). Lines produced
 *  via a custom `template` won't round-trip through this — use
 *  {@link isLegacyShortcodeLine} if you only need to detect/extract the
 *  raw string, not reconstruct its fields. */
declare function parseLegacyShortcode(line: string): LegacyComponentInput | null;
/** Loosely detects "this is a legacy shortcode line" — starts and ends
 *  with `#` and has a non-empty type segment — without assuming the
 *  default field/value-paired layout. Works for any `template`, since it
 *  doesn't try to reconstruct fields. */
declare function isLegacyShortcodeLine(line: string): boolean;

type RichTextEditorApi = {
    /** Underlying Lexical editor instance — for advanced commands */
    editor: LexicalEditor;
    /** Get current state as Lexical JSON. Every text node carries a
     *  ready-to-use `css` string (format bitmask + `style` merged) unless
     *  the editor sets `inlineTextStyles={false}`. */
    getJson: () => string;
    /** `getJson()` with the `css` key forced on, whatever the editor's
     *  `inlineTextStyles` setting is. */
    getStyledJson: (options?: InlineTextStyleOptions) => string;
    /** The untouched Lexical shape — no derived `css` key and no
     *  `hiddenFields` stripping. */
    getRawJson: () => string;
    /** Get current state as HTML */
    getHtml: () => string;
    /** Get current state as Markdown */
    getMarkdown: () => string;
    /** Get plain text content */
    getText: () => string;
    /** Get every legacy `#type#field#field#` component currently in the
     *  document, as an array of shortcode strings (one per component, in
     *  document order). Non-component content is ignored. */
    getLegacyShortcodes: () => string[];
    /** Replace state from Lexical JSON */
    setJson: (json: string) => void;
    /** Replace state from HTML */
    setHtml: (html: string) => void;
    /** Replace state from Markdown */
    setMarkdown: (markdown: string) => void;
    /** Append legacy components (image, video, embed link, etc.) to the
     *  document from typed `LegacyComponentInput` objects — see
     *  legacy-shortcode.ts for the full union and field shapes. Pass the
     *  same `schema` you hand to `createLegacyComponentBlocks()` so each
     *  item's type-specific `template` (if any) is honored — without it,
     *  every item renders in the default `#type#field#value#` layout. */
    importLegacyComponents: (items: LegacyComponentInput[], schema?: LegacyComponentSpec[]) => void;
    /** Fill the document with one of every component the editor ships —
     *  a one-click way to eyeball an integration. Defaults to clearing
     *  first; pass `{ mode: "append" }` to keep existing content and add
     *  the blocks at the end. Returns how many blocks were inserted. */
    insertAllComponents: (options?: AllComponentsOptions) => number;
    /** Empty the editor */
    clear: () => void;
    /** Move browser focus into the editor */
    focus: () => void;
    /** Get cursor position as a character offset from document start.
     *  Returns `null` when there is no range selection. */
    getCursorOffset: () => number | null;
    /** Place the cursor at a character offset from document start. */
    setCursorOffset: (offset: number) => void;
};
/**
 * Access the LexicalEditor instance plus high-level helpers from any
 * component that lives inside `<RichTextEditor>`.
 */
declare function useRichTextEditor(): RichTextEditorApi;

/**
 * Default Tailwind v4 theme — Lexical class name map.
 * User can override by passing their own theme via Carousel root.
 */
declare const defaultTheme: EditorThemeClasses;

/**
 * Default Lexical nodes registered with the composer.
 * Covers heading, quote, list, link, code, horizontal rule, page break,
 * table, hashtag and overflow (used by the optional character-limit plugin),
 * plus one node per Eglador CMS block type (see `cms/cms-schema.tsx`).
 */
declare const defaultNodes: Klass<LexicalNode>[];

type SerializedPageBreakNode = SerializedLexicalNode;
/**
 * Custom Lexical DecoratorNode for page breaks.
 *
 * No first-party Lexical package ships a page-break node, so this follows
 * the playground reference: a `break-after-page` block in the live document
 * (so print/PDF export honors it) plus a labeled visual marker in the
 * editor surface.
 */
declare class PageBreakNode extends DecoratorNode<React.ReactElement> {
    static getType(): string;
    static clone(node: PageBreakNode): PageBreakNode;
    static importJSON(): PageBreakNode;
    exportJSON(): SerializedPageBreakNode;
    createDOM(): HTMLElement;
    updateDOM(): boolean;
    getTextContent(): string;
    isInline(): false;
    decorate(): React.ReactElement;
}
declare function $createPageBreakNode(): PageBreakNode;
declare function $isPageBreakNode(node: LexicalNode | null | undefined): node is PageBreakNode;
declare const INSERT_PAGE_BREAK_COMMAND: LexicalCommand<undefined>;
/**
 * Plugin that registers the `INSERT_PAGE_BREAK_COMMAND` handler.
 * Render once inside `<LexicalComposer>` to enable page-break insertion.
 */
declare function PageBreakPlugin(): null;

type SerializedLegacyComponentNode = Spread<{
    componentType: string;
    fields: Record<string, string>;
}, SerializedLexicalNode>;
/**
 * One block of a fully generic `#type#field#value#field#value#` legacy
 * CMS shortcode. Storage is `componentType` + a field/value map — there
 * is no built-in notion of "video" or "image"; the available types and
 * their fields are entirely defined by the consumer's own
 * `LegacyComponentSpec[]` (legacy-schema.ts) at the call site.
 *
 * Renders as the literal shortcode string — this is CMS-internal markup,
 * not a previewable embed, so the editor shows it as plain text rather
 * than a styled card.
 */
declare class LegacyComponentNode extends DecoratorNode<React.ReactElement> {
    __componentType: string;
    __fields: Record<string, string>;
    static getType(): string;
    static clone(node: LegacyComponentNode): LegacyComponentNode;
    static importJSON(serialized: SerializedLegacyComponentNode): LegacyComponentNode;
    exportJSON(): SerializedLegacyComponentNode;
    constructor(componentType: string, fields: Record<string, string>, key?: NodeKey);
    getComponentType(): string;
    getFields(): Record<string, string>;
    /** The literal `#type#field#value#field#value#` string this node represents. */
    getShortcode(): string;
    createDOM(): HTMLElement;
    updateDOM(): boolean;
    /** `createDOM()`'s element is the editor-only decorator host — React
     *  fills it via `decorate()`, which `$generateHtmlFromNodes` never
     *  calls. Export the shortcode text directly so HTML output matches
     *  what the editor shows. Exported as a plain `<p>` (not the `<div>`
     *  used by `createDOM()`) so re-importing the HTML lands on an
     *  ordinary editable paragraph the user can revise, instead of being
     *  re-parsed back into a non-editable decorator node. */
    exportDOM(_editor: LexicalEditor): DOMExportOutput;
    isInline(): false;
    getTextContent(): string;
    decorate(): React.ReactElement;
}
declare function $createLegacyComponentNode(componentType: string, fields: Record<string, string>): LegacyComponentNode;
/** Convenience constructor from a {@link LegacyComponentInput}. Coerces
 *  every field value to a string (storage is always string-keyed). */
declare function $createLegacyComponentNodeFromInput(input: LegacyComponentInput): LegacyComponentNode;
declare function $isLegacyComponentNode(node: LexicalNode | null | undefined): node is LegacyComponentNode;

interface LegacyComponentFormProps {
    spec: LegacyComponentSpec;
    onSubmit: (input: LegacyComponentInput) => void;
    onCancel: () => void;
}
/**
 * Renders one input per `spec.fields` entry (text / url / number / select
 * / textarea) and builds a generic `{ type, fields }` shortcode input on
 * submit. Entirely driven by `spec` — knows nothing about what a "video"
 * or "image" component is, only the field list it's handed.
 */
declare function LegacyComponentForm({ spec, onSubmit, onCancel, }: LegacyComponentFormProps): react_jsx_runtime.JSX.Element;
declare namespace LegacyComponentForm {
    var displayName: string;
}

interface TableSizePickerProps {
    maxRows?: number;
    maxCols?: number;
    onSelect: (rows: number, cols: number) => void;
    onBack?: () => void;
}
/**
 * Notion / Google-Docs style table size picker. Hover over the grid to
 * highlight an N×M selection, click to insert. Used as the `renderForm`
 * for the `table` block in the insert surface.
 */
declare function TableSizePicker({ maxRows, maxCols, onSelect, onBack, }: TableSizePickerProps): react_jsx_runtime.JSX.Element;
declare namespace TableSizePicker {
    var displayName: string;
}

type DateTimeFormat = "short-date" | "long-date" | "time" | "datetime" | "iso";
interface FormatOption {
    key: DateTimeFormat;
    label: string;
    format: (d: Date) => string;
}
declare const DATE_TIME_FORMATS: FormatOption[];
declare const DATE_TIME_DEFAULT_FORMAT: DateTimeFormat;
/** Format the current date/time according to one of the preset
 *  options. Used both by the form and by the registry's quick `action`. */
declare function formatDateTime(format?: DateTimeFormat, date?: Date): string;
interface DateTimeFormProps {
    /** Initial format selection (default `"datetime"`). */
    initialFormat?: DateTimeFormat;
    onSubmit: (text: string) => void;
    onCancel: () => void;
}
/**
 * Format picker for the Date / Time block. Live-previews the formatted
 * string so users see exactly what gets inserted before they commit.
 */
declare function DateTimeForm({ initialFormat, onSubmit, onCancel, }: DateTimeFormProps): react_jsx_runtime.JSX.Element;
declare namespace DateTimeForm {
    var displayName: string;
}

/**
 * Drop the blank blocks word processors use for vertical spacing.
 *
 * Word writes `<p class=MsoNormal><o:p>&nbsp;</o:p></p>` between
 * paragraphs, Google Docs writes a bare `<br>` between them, and plenty
 * of sites wrap text in `<div><br></div>`. Each one imports as an empty
 * paragraph, so pasted text arrives double-spaced. Paragraph spacing is
 * the stylesheet's job, so these carry no information worth keeping.
 */
declare function cleanPastedHtml(html: string): string;
/**
 * Collapse the blank lines in pasted plain text — `a\n\n\nb` is two
 * paragraphs, not two paragraphs with two empty ones between them.
 */
declare function collapsePastedText(text: string): string;
/**
 * The editor-level registration, without React. Returns the unregister
 * function.
 */
declare function registerPasteCleanup(editor: LexicalEditor): () => void;
/**
 * Strips the blank spacer blocks out of pasted content, so text copied
 * from Word, Google Docs or a web page doesn't arrive double-spaced.
 *
 * Mounted by `RichTextEditor`; switch it off with `pasteCleanup={false}`.
 */
declare function RichTextPasteCleanup(): null;
declare namespace RichTextPasteCleanup {
    var displayName: string;
}

interface TextCaseMenuProps {
    /** Tailwind size class for the trigger button (default `size-7`). */
    sizeClass?: string;
    /** Where the menu opens relative to the trigger. */
    placement?: "bottom-start" | "bottom-center" | "top-start";
}
/**
 * `Aa` dropdown that re-cases the selected text: UPPERCASE, lowercase,
 * or Capitalize Each Word.
 *
 * Casing follows the editor's `locale`, which matters in Turkish: `i`
 * uppercases to `İ` and `I` lowercases to `ı`.
 */
declare function TextCaseMenu({ sizeClass, placement, }: TextCaseMenuProps): react_jsx_runtime.JSX.Element;
declare namespace TextCaseMenu {
    var displayName: string;
}

type TextCaseMode = "upper" | "lower" | "title";
declare const toUpperCaseText: (text: string, locale?: RichTextLocale) => string;
declare const toLowerCaseText: (text: string, locale?: RichTextLocale) => string;
/**
 * Capitalise the first letter of each word, lowercasing the rest.
 *
 * `previous` is the character just before this chunk, so a word split
 * across two text nodes by formatting (`kita` + **`plar`**) is not
 * capitalised in the middle.
 */
declare function toTitleCaseText(text: string, locale?: RichTextLocale, previous?: string): string;
declare function applyTextCase(text: string, mode: TextCaseMode, locale?: RichTextLocale, previous?: string): string;
/**
 * Re-case the selected text in place, keeping the selection so the
 * author can try another casing straight away.
 *
 * `extract()` splits text nodes at the selection boundaries and returns
 * only what is inside it, so formatting on the surrounding text — and on
 * the selection's own runs — survives.
 */
declare function transformSelectionCase(editor: LexicalEditor, mode: TextCaseMode, locale?: RichTextLocale): void;

/**
 * Turning a pasted embed snippet into the bare URL a block stores.
 *
 * Google Maps, YouTube and friends hand out a full `<iframe …>` tag from
 * their Share dialogs, and that is what authors paste. The URL fields
 * keep only the `src`.
 */
/**
 * The `src` of a pasted `<iframe>`, or the input untouched when it isn't
 * one — so this can sit on a URL field's `onChange` without getting in
 * the way of ordinary typing.
 *
 * ```
 * <iframe src="https://www.google.com/maps/embed?pb=!1m18…" width="600">
 * → https://www.google.com/maps/embed?pb=!1m18…
 * ```
 */
declare function extractEmbedSrc(input: string): string;

/**
 * The contract every spell-check surface shares — the editor plugin, the
 * headless `checkSpelling()` helper, and whatever the host builds on the
 * result (an error screen, a publish gate, an analytics hook).
 */
/**
 * A spelling engine. The built-in one is Hunspell with a Turkish
 * dictionary (`createTurkishSpellChecker`); anything implementing this
 * interface can replace it — a server endpoint backed by Zemberek, a
 * different language, a test double.
 *
 * Words arrive exactly as written (case and apostrophe suffixes intact);
 * the engine decides what counts as correct.
 */
interface SpellChecker {
    /** Resolves once the engine can answer. Safe to call repeatedly. */
    ready(): Promise<void>;
    /** One boolean per word, same order: `true` = spelled correctly. */
    check(words: string[]): Promise<boolean[]>;
    /** Replacement candidates for one word, best first. */
    suggest(word: string): Promise<string[]>;
    /** Accept a word for the rest of this engine's lifetime. */
    addWord?(word: string): Promise<void>;
    /** Release workers / memory. */
    dispose?(): void;
}
type SpellIssueKind = 
/** The dictionary doesn't know the word. */
"misspelling"
/** A well-known wrong form from the rule list (`herkez` → `herkes`). */
 | "common-mistake"
/** Written together, belongs apart (`değilmi` → `değil mi`, `herşeyi` → `her şeyi`). */
 | "separate-words";
/** Where an issue sits in a live editor. Offsets are within the text node. */
interface SpellIssuePoint {
    key: string;
    offset: number;
}
interface SpellIssue {
    /** Stable while the word stays in place — use it to target an issue. */
    id: string;
    /** The word exactly as written. */
    word: string;
    kind: SpellIssueKind;
    /** Human-readable explanation, in the plugin's locale. */
    message: string;
    /** Best first. Empty until looked up (see `suggestionsPending`). */
    suggestions: string[];
    /** `true` while dictionary suggestions are still being computed. */
    suggestionsPending: boolean;
    /** A slice of the surrounding sentence, for error listings. */
    context: string;
    /** Character offset of the word within its block's text. */
    blockOffset: number;
    /** Index of the block (paragraph, heading, list item…) in document order. */
    blockIndex: number;
    /** Live-editor location. Absent for headless checks. */
    anchor?: SpellIssuePoint;
    focus?: SpellIssuePoint;
}
type SpellCheckStatus = 
/** Not run yet. */
"idle"
/** The engine / dictionary is still loading. */
 | "loading"
/** A check is in flight. */
 | "checking"
/** Finished with no issues. */
 | "passed"
/** Finished with at least one issue. */
 | "failed"
/** The engine couldn't start or a check threw — see `error`. */
 | "error"
/** The plugin is mounted with `enabled={false}`. */
 | "disabled";
interface SpellCheckResult {
    status: SpellCheckStatus;
    /**
     * The one flag most integrations need: `true` only when a check
     * finished and found nothing. Loading, checking, error and disabled
     * are all `false` — never treat "not known yet" as a pass.
     */
    passed: boolean;
    issueCount: number;
    issues: SpellIssue[];
    /** Distinct words sent through the check. */
    checkedWordCount: number;
    /** `Date.now()` of the last finished check, or `null`. */
    checkedAt: number | null;
    error?: string;
}
interface SpellAnalysisOptions {
    /**
     * Words always accepted — brand names, bylines, jargon. Compared
     * case-insensitively with Turkish casing rules (`I`/`ı`, `İ`/`i`).
     */
    ignoreWords?: string[];
    /**
     * Skip capitalised words the dictionary doesn't know when they are not
     * at the start of a sentence — almost always a name (`Kılıçdaroğlu`,
     * `Eglador'un`). Default `true`.
     */
    ignoreProperNouns?: boolean;
    /** Skip all-caps words the dictionary doesn't know (`TBMM`, `NATO`). Default `true`. */
    ignoreAllCaps?: boolean;
    /**
     * Extra wrong → right pairs, merged over the built-in Turkish list.
     * Keys are matched case-insensitively; map a key to `null` to switch a
     * built-in rule off.
     */
    commonMistakes?: Record<string, string | null>;
    /** Ignore words shorter than this. Default `2`. */
    minWordLength?: number;
}
declare const EMPTY_SPELL_RESULT: SpellCheckResult;

/** Imperative control over a mounted `<RichTextSpellCheck>`. */
interface RichTextSpellCheckApi {
    /**
     * Check now, skipping the debounce. Resolves with the result for the
     * document as it is when the check finishes (re-running if the text
     * changed meanwhile). Pass `{ suggestions: true }` to also wait for
     * dictionary suggestions — useful right before showing an error list.
     */
    check(options?: {
        suggestions?: boolean;
    }): Promise<SpellCheckResult>;
    /** The latest result, synchronously. */
    getResult(): SpellCheckResult;
    /** Select an issue's word, scroll it into view and open its suggestions. */
    focusIssue(id: string): boolean;
    /** Replace an issue's word. `false` if the word has changed since. */
    applySuggestion(id: string, replacement: string): boolean;
    /** Accept a word until the plugin unmounts. */
    ignoreWord(word: string): void;
    /** Accept a word and report it through `onAddWord` so the host can persist it. */
    addWord(word: string): Promise<void>;
}
interface SpellCheckSnapshot {
    result: SpellCheckResult;
    /** `null` until a `<RichTextSpellCheck>` is mounted in this editor. */
    api: RichTextSpellCheckApi | null;
}
/**
 * The spell-check state of the surrounding editor, for components that
 * live inside `<RichTextEditor>` — a publish button, a custom error
 * panel, a toolbar badge:
 *
 * ```tsx
 * const { result, api } = useRichTextSpellCheck();
 * <button disabled={!result.passed}>Yayınla</button>
 * ```
 */
declare function useRichTextSpellCheck(): SpellCheckSnapshot;
/** DOM event fired on the editor's root element after every result change. */
declare const SPELL_CHECK_EVENT = "eglador:spellcheck";

interface RichTextSpellCheckProps extends SpellAnalysisOptions {
    /**
     * The spelling engine. Defaults to one page-wide Turkish Hunspell
     * checker (see `createTurkishSpellChecker`). Pass a memoised instance —
     * a new object each render restarts the check.
     */
    checker?: SpellChecker;
    /** Turn checking off without unmounting. Default `true`. */
    enabled?: boolean;
    /** Quiet period after typing before a check runs. Default `500` ms. */
    debounceMs?: number;
    /** Draw wavy underlines under issues. Default `true`. */
    underline?: boolean;
    /**
     * Look up dictionary suggestions for every issue in the background, so
     * `onResult` payloads carry them. With `false` they are fetched only
     * when the author opens an issue. Default `true`.
     */
    suggestions?: boolean;
    /**
     * Fires on every result change — status transitions and suggestion
     * updates included. `result.passed` is the pass / fail flag.
     */
    onResult?: (result: SpellCheckResult) => void;
    /** The author chose "Add to dictionary" — persist the word if you like. */
    onAddWord?: (word: string) => void;
    /** Imperative handle, for code outside the editor tree. */
    apiRef?: React.Ref<RichTextSpellCheckApi>;
    /** Render the built-in status bar. Default `true`. */
    showStatus?: boolean;
    className?: string;
    /** Replace the status bar with your own UI. */
    children?: (state: {
        result: SpellCheckResult;
        api: RichTextSpellCheckApi;
    }) => React.ReactNode;
}
/**
 * Turkish spell checking for the editor — Hunspell with a Turkish
 * dictionary in a Web Worker, plus rules for mistakes a dictionary alone
 * handles badly (`herkez`, `değilmi`, `istanbul'da`).
 *
 * Issues get a wavy underline; click (or right-click) one for
 * suggestions. The outcome is exposed four ways — pick whichever reaches
 * the code that needs it:
 *
 * - `onResult` prop — every change, with `result.passed`
 * - `apiRef` prop — `await api.check()` before publishing
 * - `useRichTextSpellCheck()` — for components inside `<RichTextEditor>`
 * - `eglador:spellcheck` DOM event on the editor root
 *
 * ```tsx
 * <RichTextEditor>
 *   <RichTextToolbar />
 *   <RichTextContent />
 *   <RichTextSpellCheck onResult={(r) => setCanPublish(r.passed)} />
 * </RichTextEditor>
 * ```
 */
declare function RichTextSpellCheck({ checker: checkerProp, enabled, debounceMs, underline, suggestions: autoSuggest, onResult, onAddWord, apiRef, showStatus, className, children, ignoreWords, ignoreProperNouns, ignoreAllCaps, commonMistakes, minWordLength, }: RichTextSpellCheckProps): react_jsx_runtime.JSX.Element;
declare namespace RichTextSpellCheck {
    var displayName: string;
}
interface SpellCheckStatusBarProps {
    result: SpellCheckResult;
    api: RichTextSpellCheckApi;
    className?: string;
}
/**
 * The default spell-check UI: status, issue count, and an expandable list
 * that jumps to each issue. Exported so custom layouts can reuse it.
 */
declare function SpellCheckStatusBar({ result, api, className, }: SpellCheckStatusBarProps): react_jsx_runtime.JSX.Element;
declare namespace SpellCheckStatusBar {
    var displayName: string;
}

type DictionaryData = ArrayBuffer | Uint8Array | string;

/**
 * Default dictionary: `dictionary-tr` (MIT, Hunspell format, ~9 MB `.dic`)
 * served from jsDelivr. Only dictionary *data* is fetched — the text being
 * checked never leaves the browser. Self-host both files and pass
 * `dictionaryUrls` to avoid the CDN.
 */
declare const TURKISH_DICTIONARY_URLS: {
    readonly aff: "https://cdn.jsdelivr.net/npm/dictionary-tr@2.0.0/index.aff";
    readonly dic: "https://cdn.jsdelivr.net/npm/dictionary-tr@2.0.0/index.dic";
};
interface TurkishSpellCheckerOptions {
    /** Where to download the Hunspell `.aff` / `.dic` pair from. */
    dictionaryUrls?: {
        aff: string;
        dic: string;
    };
    /**
     * Supply the dictionary yourself instead of downloading it — e.g. read
     * it from disk on a server: `() => ({ aff: fs.readFileSync(...), ... })`.
     */
    loadDictionary?: () => Promise<{
        aff: DictionaryData;
        dic: DictionaryData;
    }> | {
        aff: DictionaryData;
        dic: DictionaryData;
    };
    /** Words accepted from the start (brand names, bylines…). */
    words?: string[];
    /**
     * Run Hunspell in a Web Worker (default: whenever `Worker` exists).
     * The loaded dictionary takes ~45 MB — keep it off the UI thread.
     * Without a worker the engine loads in-process, which is meant for
     * servers and tests.
     */
    worker?: boolean;
}
/**
 * Hunspell with a Turkish dictionary, lazily started: nothing downloads
 * until the first `ready()` / `check()`. A failed start (offline, CDN
 * blocked) rejects that call and is retried on the next one.
 */
declare function createTurkishSpellChecker(options?: TurkishSpellCheckerOptions): SpellChecker;
/**
 * One Turkish checker for the whole page, so several editors share a
 * single worker and a single copy of the dictionary.
 */
declare function getSharedTurkishSpellChecker(): SpellChecker;

/** A run of prose — one paragraph, heading, list item, table cell… */
interface SpellSegment {
    text: string;
    blockIndex: number;
    /** Map an offset inside `text` to a live-editor point (plugin only). */
    locate?: (offset: number, edge: "start" | "end") => SpellIssuePoint | null;
}
interface SpellIssueMessages {
    spellMisspelling: string;
    spellCommonMistake: string;
    spellSeparateWords: string;
}
/** Blocks of prose from a serialized editor state, in document order. */
declare function segmentsFromJson(state: unknown): SpellSegment[];
interface CheckSpellingOptions extends SpellAnalysisOptions {
    checker: SpellChecker;
    /** Look up dictionary suggestions too (slower). Default `true`. */
    suggestions?: boolean;
    messages?: Partial<SpellIssueMessages>;
}
/**
 * Spell-check content outside an editor — before saving, in an API
 * route, in CI. Accepts plain text, a Lexical JSON string, or a parsed
 * editor state. Resolves to the same `SpellCheckResult` the plugin emits
 * (without `anchor` / `focus`, since there is no live editor).
 *
 * ```ts
 * const result = await checkSpelling(json, { checker });
 * if (!result.passed) return res.status(422).json(result.issues);
 * ```
 */
declare function checkSpelling(input: string | object, { checker, suggestions, messages, ...options }: CheckSpellingOptions): Promise<SpellCheckResult>;

/**
 * Turkish language layer on top of the dictionary: casing, tokenising,
 * and the mistakes Hunspell alone handles badly. Pure functions only, so
 * the live plugin and the headless `checkSpelling()` agree exactly.
 */
declare const trLower: (s: string) => string;
declare const trUpper: (s: string) => string;
/** `istanbul` → `İstanbul` — the plain `toUpperCase()` gives `Istanbul`. */
declare const trCapitalize: (s: string) => string;
interface WordToken {
    word: string;
    start: number;
    end: number;
    /** First word of a sentence (or block) — capitals there prove nothing. */
    sentenceStart: boolean;
}
declare function tokenize(text: string): WordToken[];
/**
 * Frequent wrong forms (TDK Yazım Kılavuzu), keyed in lowercase. Many of
 * these are rejected by the dictionary too, but its suggestion for them
 * is often poor (`şöför` → `flaşör`) — the rule puts the right one first.
 */
declare const TURKISH_COMMON_MISTAKES: Record<string, string>;

export { $buildAllComponentNodes, $createAudioNode, $createCmsNode, $createColumnNode, $createColumnsNode, $createContextNoteNode, $createEmptyContextNoteNode, $createEmptyNewsMomentNode, $createIframeNode, $createImageComparisonNode, $createImageNode, $createLegacyComponentNode, $createLegacyComponentNodeFromInput, $createNewsMomentNode, $createPageBreakNode, $createVideoNode, $createYouTubeNode, $isAudioNode, $isCmsBlockNode, $isColumnNode, $isColumnsNode, $isContextNoteNode, $isIframeNode, $isImageComparisonNode, $isImageNode, $isLegacyComponentNode, $isNewsMomentNode, $isNoteBlockNode, $isPageBreakNode, $isVideoNode, $isYouTubeNode, ALL_COMPONENTS_DEFAULT_SAMPLE, AUDIO_DEFAULT_OPTIONS, type AllComponentsGlobal, type AllComponentsOptions, type AllComponentsSample, AudioForm, type AudioFormSubmit, AudioNode, type AudioOptions, type AudioPreload, type BlockCategory, type BlockFormHandlers, BlockPicker, type BlockPickerProps, type BlockSpec, type BlockSurface, CMS_BLOCK_SCHEMA, COLUMNS_DEFAULT_OPTIONS, COLUMNS_MAX, COLUMNS_MIN, CONTEXT_NOTE_DEFAULT_META, CONTEXT_NOTE_META_FIELDS, CONTEXT_NOTE_SPEC, type CheckSpellingOptions, CmsBlock, CmsBlockNode, type CmsBlockProps, type CmsBlockSpec, type CmsFieldInputType, type CmsFieldOption, type CmsFieldOptionsConfig, CmsFieldOptionsProvider, type CmsFieldOptionsSource, type CmsFieldOptionsState, type CmsFieldOptionsStatus, type CmsFieldSpec, type CmsFieldValues, CmsForm, type CmsFormProps, ColumnNode, ColumnsForm, type ColumnsFormSubmit, type ColumnsGap, ColumnsNode, type ComparisonAspectRatio, type ComparisonOrientation, type ContextNoteMeta, ContextNoteNode, DATE_TIME_DEFAULT_FORMAT, DATE_TIME_FORMATS, DEFAULT_HEADING_LIMIT, DEFAULT_LOCALE, DateTimeForm, type DateTimeFormat, EMPTY_SPELL_RESULT, type HeadingLimitConfig, type HeadingLimitOptions, type HeadingMenuItem, type HiddenFieldsConfig, HiddenFieldsProvider, IFRAME_DEFAULT_OPTIONS, IMAGE_COMPARISON_DEFAULT_OPTIONS, IMAGE_DEFAULT_OPTIONS, INSERT_PAGE_BREAK_COMMAND, type IframeAspectRatio, IframeForm, type IframeFormSubmit, IframeNode, type IframeOptions, ImageComparisonForm, type ImageComparisonFormSubmit, ImageComparisonNode, type ImageComparisonOptions, ImageForm, type ImageFormSubmit, ImageNode, type ImageOptions, ImagePicker, type InlineTextStyleOptions, type InlineTextStyleSetting, LOCALE_MESSAGES, LegacyComponentForm, type LegacyComponentFormProps, type LegacyComponentInput, LegacyComponentNode, type LegacyComponentSpec, type LegacyFieldOption, type LegacyFieldSpec, type MediaLibrary, type MediaLibraryItem, MediaLibraryProvider, type MediaLibraryState, type MediaLibraryStatus, type MediaResolver, MediaResolverProvider, MediaThumb, NEWS_MOMENT_DEFAULT_META, NEWS_MOMENT_META_FIELDS, NEWS_MOMENT_SPEC, type NewsMomentMeta, NewsMomentNode, NoteBlockNode, type NoteMeta, type NoteNodeClass, PageBreakNode, PageBreakPlugin, type PageSize, type PageSizeName, type ResolvedSrc, type ResolvedSrcStatus, RichTextAutoEmbed, RichTextBlockEdges, type RichTextBlockEdgesProps, RichTextColumnsToolbar, RichTextContent, type RichTextContentProps, RichTextDevGlobals, type RichTextDevGlobalsProps, RichTextDraggableBlock, RichTextEditor, type RichTextEditorApi, type RichTextEditorProps, RichTextFindReplace, RichTextFloatingToolbar, RichTextHeadingLimit, type RichTextHeadingLimitProps, RichTextI18nProvider, RichTextLinkEditor, type RichTextLocale, type RichTextMessages, RichTextNewsMomentChrome, RichTextNoteChrome, RichTextOutput, type RichTextOutputProps, type RichTextOutputTab, RichTextPageSize, RichTextPasteCleanup, RichTextSlashCommands, RichTextSpellCheck, type RichTextSpellCheckApi, type RichTextSpellCheckProps, RichTextStats, type RichTextStatsProps, type RichTextStatsValue, RichTextTableActions, RichTextToolbar, type RichTextToolbarFeature, type RichTextToolbarProps, type RichTextValue, SPELL_CHECK_EVENT, type SerializedAudioNode, type SerializedCmsBlockNode, type SerializedColumnsNode, type SerializedNoteBlockNode as SerializedContextNoteNode, type SerializedIframeNode, type SerializedImageComparisonNode, type SerializedImageNode, type SerializedLegacyComponentNode, type SerializedNoteBlockNode as SerializedNewsMomentNode, type SerializedNoteBlockNode, type SerializedPageBreakNode, type SerializedVideoNode, type SerializedYouTubeNode, type SpellAnalysisOptions, type SpellCheckResult, type SpellCheckSnapshot, type SpellCheckStatus, SpellCheckStatusBar, type SpellCheckStatusBarProps, type SpellChecker, type SpellIssue, type SpellIssueKind, type SpellIssuePoint, type SpellSegment, TEXT_FORMAT_BITS, TURKISH_COMMON_MISTAKES, TURKISH_DICTIONARY_URLS, TableSizePicker, TextCaseMenu, type TextCaseMenuProps, type TextCaseMode, type TextCssOptions, type TextFormatName, TextStyleProvider, type TurkishSpellCheckerOptions, VIDEO_DEFAULT_OPTIONS, type VideoAspectRatio, VideoForm, type VideoFormSubmit, VideoNode, type VideoOptions, type VideoPreload, YOUTUBE_DEFAULT_OPTIONS, YouTubeForm, type YouTubeFormSubmit, YouTubeNode, type YouTubeOptions, type YouTubeUrlMatch, applyTextCase, checkSpelling, cleanPastedHtml, cmsBlocks, cmsNodes, collapsePastedText, createCmsNodeClass, createLegacyComponentBlocks, createNoteNodeClass, createTurkishSpellChecker, decodeTextFormat, defaultBlocks, defaultNodes, defaultTheme, emptyNoteMeta, enMessages, extractEmbedSrc, filterBlocks, formatDateTime, getBlocksForSurface, getNoteHeaderElement, getSharedTurkishSpellChecker, hasTextFormat, hiddenFieldsFor, initialCmsValues, insertAllComponents, isAudioUrl, isImageUrl, isLegacyShortcodeLine, isVideoUrl, legacyComponentToShortcode, nowMeta, parseCssText, parseIdList, parseLegacyShortcode, parseYouTubeUrl, registerBlockEdges, registerHeadingLimit, registerPasteCleanup, renderLegacyShortcodeTemplate, resolveInlineTextStyles, resolveMessages, segmentsFromJson, stringifyCss, stripHiddenFields, textFormatToCss, textNodeCss, toLowerCaseText, toTitleCaseText, toUpperCaseText, toYouTubeEmbedSrc, tokenize as tokenizeTurkish, trCapitalize, trLower, trMessages, trUpper, transformSelectionCase, useCmsFieldOptions, useHiddenFields, useHiddenFieldsConfig, useInlineTextStyles, useMediaLibrary, useMediaResolver, useMessages, usePageSize, useResolvedSrc, useRichTextEditor, useRichTextSpellCheck, withInlineTextStyles, youTubeEmbedUrl };