import * as react from 'react';
import { ReactNode, RefObject } from 'react';
import { R as RenderExtension } from './extensions-6PVd3-vB.js';
import { F as FieldMode } from './inputs.types-vl3PAc4q.js';
import './types-8Sv0rCjw.js';

interface EditorAction {
    icon: ReactNode;
    label: string;
    command: string;
    commandArg?: string;
    active?: boolean;
}
interface EditorToolbarProps {
    actions?: EditorAction[];
    onAction?: (command: string) => void;
    children?: ReactNode;
    className?: string;
    /**
     * Append a "Source" toggle (reveals the raw HTML/Markdown behind the editor)
     * to the right of the default toolbar. Ignored when `children` are supplied —
     * custom toolbars compose their own `<Editor.SourceToggle />`.
     * @default true
     */
    showSourceToggle?: boolean;
}
interface EditorContentProps {
    className?: string;
    /** Max height in px before scrolling. When set, content area becomes scrollable. */
    maxHeight?: number;
    /** Class names applied to the raw-source `<textarea>` shown while source mode is on. */
    sourceClassName?: string;
}
interface EditorSourceToggleProps {
    className?: string;
    /** Toggle glyph/label. @default `</>` */
    icon?: ReactNode;
    /** Accessible title when in rich-text mode (click → source). @default "Source" */
    title?: string;
    /** Accessible title when in source mode (click → rich text). @default "Rich text" */
    activeTitle?: string;
}
interface EditorProps {
    children: ReactNode;
    className?: string;
    value?: string;
    defaultValue?: string;
    onChange?: (value: string) => void;
    outputFormat?: "html" | "markdown";
    /**
     * The format of the INCOMING `value` / `defaultValue`. Default `"auto"`
     * keeps the historical sniff (`detectFormat`) — but real-world markdown that
     * merely mentions HTML-ish snippets (`<code>`, `<table`, …) flips the sniff
     * to html and renders as a wall of text. Callers with a KNOWN format
     * (file-typed content, values previously emitted with
     * `outputFormat="markdown"`) should declare it; explicit values bypass the
     * sniff entirely — in edit mode AND view mode.
     * @default "auto"
     */
    valueFormat?: "markdown" | "html" | "auto";
    lineSpacing?: number;
    placeholder?: string;
    /**
     * View/edit mode — like the react-fancy inputs. Resolution: this prop →
     * nearest `<Form>` / `<FormProvider>` context → `"edit"`. In `"view"` mode the
     * editor renders its value read-only through `<ContentRenderer>` (matching
     * `outputFormat` — markdown/html) instead of the editable toolbar + content.
     * @default "edit"
     */
    mode?: FieldMode;
    /** Per-instance render extensions. Merged with any globally-registered extensions. */
    extensions?: RenderExtension[];
    /**
     * Controlled source-view flag. When `true` the content area shows the raw
     * HTML/Markdown (`value`, in `outputFormat`) in an editable `<textarea>`
     * instead of the rich-text surface. Pair with `onShowSourceChange`, or leave
     * uncontrolled and drive it with the toolbar's Source toggle.
     */
    showSource?: boolean;
    /** Initial source-view flag when uncontrolled. @default false */
    defaultShowSource?: boolean;
    /** Fired when the Source toggle (or an agent) flips source view on/off. */
    onShowSourceChange?: (showSource: boolean) => void;
    /**
     * Skip HTML sanitization of the initial value. By default the initial markdown/HTML
     * is sanitized to remove `<script>`, `<iframe>`, event handlers, and `javascript:`
     * URIs before being placed into contentEditable. Pass `unsafe` only when the
     * initial value is fully trusted.
     * @default false
     */
    unsafe?: boolean;
}

declare function EditorToolbar({ actions, onAction, children, className, showSourceToggle, }: EditorToolbarProps): react.JSX.Element;
declare namespace EditorToolbar {
    var displayName: string;
}

declare function EditorToolbarSeparator(): react.JSX.Element;
declare namespace EditorToolbarSeparator {
    var displayName: string;
}

/**
 * Toolbar button that reveals the raw HTML/Markdown behind the editor. Reads
 * `showSource` / `setShowSource` from context, so it works in the default
 * toolbar and in any custom toolbar composed with `useEditor()`.
 */
declare function EditorSourceToggle({ className, icon, title, activeTitle, }: EditorSourceToggleProps): react.JSX.Element;
declare namespace EditorSourceToggle {
    var displayName: string;
}

declare function EditorContent({ className, maxHeight, sourceClassName }: EditorContentProps): react.JSX.Element;
declare namespace EditorContent {
    var displayName: string;
}

declare function EditorRoot({ children, className, value: controlledValue, defaultValue, onChange, outputFormat, valueFormat, lineSpacing, placeholder, mode: modeProp, extensions: instanceExtensions, unsafe, showSource: showSourceProp, defaultShowSource, onShowSourceChange, }: EditorProps): react.JSX.Element;
declare const Editor: typeof EditorRoot & {
    Toolbar: typeof EditorToolbar & {
        Separator: typeof EditorToolbarSeparator;
    };
    Content: typeof EditorContent;
    SourceToggle: typeof EditorSourceToggle;
};

interface EditorContextValue {
    contentRef: RefObject<HTMLDivElement | null>;
    exec: (command: string, arg?: string) => void;
    insertText: (text: string) => void;
    wrapSelection: (before: string, after: string) => void;
    outputFormat: "html" | "markdown";
    lineSpacing: number;
    placeholder?: string;
    /** Merged render extensions (global + instance). */
    extensions: RenderExtension[];
    /** Whether the raw-source view (textarea) is showing instead of the rich-text surface. */
    showSource: boolean;
    /** Toggle/set the raw-source view. */
    setShowSource: (showSource: boolean) => void;
    /** Initial HTML content to load into the editor on mount */
    _initialHtml: string;
    /** @internal Called by EditorContent on input events */
    _onInput: () => void;
    /** @internal Raw source value (`value` in `outputFormat`), for the source textarea. */
    _sourceValue: string;
    /** @internal Commit an edit made directly in the source textarea. */
    _onSourceInput: (value: string) => void;
}
declare function useEditor(): EditorContextValue;

export { Editor, type EditorAction, type EditorContentProps, type EditorContextValue, type EditorProps, type EditorSourceToggleProps, type EditorToolbarProps, useEditor };