@particle-academy/react-fancy 5.12.0 → 5.14.0

package/dist/date-picker.d.ts

@@ -0,0 +1,26 @@
+import * as react from 'react';
+import { a as InputBaseProps } from './inputs.types-DERzxpe1.js';
+import './types-8Sv0rCjw.js';
+
+interface DatePickerBaseProps extends InputBaseProps {
+    min?: string;
+    max?: string;
+    includeTime?: boolean;
+}
+interface DatePickerSingleProps extends DatePickerBaseProps {
+    range?: false;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+}
+interface DatePickerRangeProps extends DatePickerBaseProps {
+    range: true;
+    value?: [string, string];
+    defaultValue?: [string, string];
+    onValueChange?: (value: [string, string]) => void;
+}
+type DatePickerProps = DatePickerSingleProps | DatePickerRangeProps;
+
+declare const DatePicker: react.ForwardRefExoticComponent<DatePickerProps & react.RefAttributes<HTMLInputElement>>;
+
+export { DatePicker, type DatePickerProps, type DatePickerRangeProps, type DatePickerSingleProps };

package/dist/date-picker.js

@@ -0,0 +1,10 @@
+export { DatePicker } from './chunk-MILTPAF6.js';
+import './chunk-K7JGOQJG.js';
+import './chunk-3DJGPNUI.js';
+import './chunk-GFYSELJF.js';
+import './chunk-OL53XYHF.js';
+import './chunk-NRXK42LO.js';
+import './chunk-6FQGMVF2.js';
+import './chunk-DSUHZO6T.js';
+//# sourceMappingURL=date-picker.js.map
+//# sourceMappingURL=date-picker.js.map

package/dist/date-picker.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"date-picker.js"}

package/dist/drawer.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+var chunkF6NEPU67_cjs = require('./chunk-F6NEPU67.cjs');
+require('./chunk-TXTRTTG7.cjs');
+require('./chunk-3WGRVDQR.cjs');
+require('./chunk-NBZC6LOB.cjs');
+require('./chunk-RXDRYWVD.cjs');
+require('./chunk-3Z6ALUWP.cjs');
+
+
+
+Object.defineProperty(exports, "Drawer", {
+  enumerable: true,
+  get: function () { return chunkF6NEPU67_cjs.Drawer; }
+});
+Object.defineProperty(exports, "useDrawer", {
+  enumerable: true,
+  get: function () { return chunkF6NEPU67_cjs.useDrawer; }
+});
+//# sourceMappingURL=drawer.cjs.map
+//# sourceMappingURL=drawer.cjs.map

package/dist/drawer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"drawer.cjs"}

package/dist/drawer.d.cts

@@ -0,0 +1,116 @@
+import * as react from 'react';
+import { HTMLAttributes, ReactNode } from 'react';
+
+/** Which edge the drawer is anchored to, and therefore slides in from. */
+type DrawerSide = "left" | "right" | "top" | "bottom";
+/**
+ * How large the drawer is along its own axis.
+ *
+ * `size` controls WIDTH for `left`/`right` and HEIGHT for `top`/`bottom` — the
+ * cross-axis always fills its anchor. One scale, two meanings, so `size="md"`
+ * reads the same whichever edge you attach to.
+ */
+type DrawerSize = "sm" | "md" | "lg" | "xl" | "full";
+/**
+ * Where the drawer is anchored.
+ *
+ * - `viewport` (default) — portalled, `fixed`, covers the screen, locks body
+ *   scroll and traps focus. The classic app-level drawer.
+ * - `container` — `absolute` inside the nearest positioned ancestor, no portal,
+ *   no scroll lock, no focus trap. Attach it to a Card, a layout region, or the
+ *   shell around a prompt input and it stays inside that box.
+ */
+type DrawerAttach = "viewport" | "container";
+interface DrawerContextValue {
+    open: boolean;
+    close: () => void;
+    side: DrawerSide;
+}
+interface DrawerProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    children: ReactNode;
+    open: boolean;
+    onClose: () => void;
+    /** Edge to anchor to. Default `right`. */
+    side?: DrawerSide;
+    /** Extent along the drawer's own axis. Default `md`. */
+    size?: DrawerSize;
+    /** Viewport-level or scoped to a container. Default `viewport`. */
+    attach?: DrawerAttach;
+    /** Render the scrim behind the panel. Default `true`. */
+    backdrop?: boolean;
+    /** Clicking the scrim closes. Default `true`. */
+    dismissOnBackdrop?: boolean;
+    /** Escape closes. Default `true`. */
+    dismissOnEscape?: boolean;
+    className?: string;
+}
+interface DrawerHeaderProps {
+    children: ReactNode;
+    /** Show the close button. Default `true`. */
+    closable?: boolean;
+    className?: string;
+}
+interface DrawerBodyProps {
+    children: ReactNode;
+    className?: string;
+}
+interface DrawerFooterProps {
+    children: ReactNode;
+    className?: string;
+}
+interface DrawerContainerProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+    className?: string;
+}
+
+declare function DrawerHeader({ children, closable, className }: DrawerHeaderProps): react.JSX.Element;
+declare namespace DrawerHeader {
+    var displayName: string;
+}
+
+declare function DrawerBody({ children, className }: DrawerBodyProps): react.JSX.Element;
+declare namespace DrawerBody {
+    var displayName: string;
+}
+
+declare function DrawerFooter({ children, className }: DrawerFooterProps): react.JSX.Element;
+declare namespace DrawerFooter {
+    var displayName: string;
+}
+
+/**
+ * The anchor for `<Drawer attach="container">`.
+ *
+ * A container-attached drawer positions itself `absolute`, which resolves
+ * against the nearest *positioned* ancestor — so without `relative` somewhere
+ * above it, the drawer silently escapes to the viewport and looks like it
+ * ignored `attach` entirely. This wrapper supplies `relative` + `overflow-hidden`
+ * so the panel slides within the box rather than out of it.
+ *
+ *   <Drawer.Container className="h-80 rounded-xl border">
+ *     <YourContent />
+ *     <Drawer attach="container" side="bottom" open={open} onClose={close}>
+ *       <Drawer.Body>Filters</Drawer.Body>
+ *     </Drawer>
+ *   </Drawer.Container>
+ *
+ * Any element works as long as it is positioned — this is the shortcut, not a
+ * requirement. Wrapping a Card, a layout pane, or a prompt-input shell in
+ * `relative overflow-hidden` does the same job.
+ */
+declare function DrawerContainer({ children, className, ...rest }: DrawerContainerProps): react.JSX.Element;
+declare namespace DrawerContainer {
+    var displayName: string;
+}
+
+declare function DrawerRoot({ children, open, onClose, side, size, attach, backdrop, dismissOnBackdrop, dismissOnEscape, className, ...rest }: DrawerProps): react.JSX.Element | null;
+declare const Drawer: typeof DrawerRoot & {
+    Header: typeof DrawerHeader;
+    Body: typeof DrawerBody;
+    Footer: typeof DrawerFooter;
+    Container: typeof DrawerContainer;
+};
+
+declare function useDrawer(): DrawerContextValue;
+
+export { Drawer, type DrawerAttach, type DrawerBodyProps, type DrawerContainerProps, type DrawerContextValue, type DrawerFooterProps, type DrawerHeaderProps, type DrawerProps, type DrawerSide, type DrawerSize, useDrawer };

package/dist/drawer.d.ts

@@ -0,0 +1,116 @@
+import * as react from 'react';
+import { HTMLAttributes, ReactNode } from 'react';
+
+/** Which edge the drawer is anchored to, and therefore slides in from. */
+type DrawerSide = "left" | "right" | "top" | "bottom";
+/**
+ * How large the drawer is along its own axis.
+ *
+ * `size` controls WIDTH for `left`/`right` and HEIGHT for `top`/`bottom` — the
+ * cross-axis always fills its anchor. One scale, two meanings, so `size="md"`
+ * reads the same whichever edge you attach to.
+ */
+type DrawerSize = "sm" | "md" | "lg" | "xl" | "full";
+/**
+ * Where the drawer is anchored.
+ *
+ * - `viewport` (default) — portalled, `fixed`, covers the screen, locks body
+ *   scroll and traps focus. The classic app-level drawer.
+ * - `container` — `absolute` inside the nearest positioned ancestor, no portal,
+ *   no scroll lock, no focus trap. Attach it to a Card, a layout region, or the
+ *   shell around a prompt input and it stays inside that box.
+ */
+type DrawerAttach = "viewport" | "container";
+interface DrawerContextValue {
+    open: boolean;
+    close: () => void;
+    side: DrawerSide;
+}
+interface DrawerProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    children: ReactNode;
+    open: boolean;
+    onClose: () => void;
+    /** Edge to anchor to. Default `right`. */
+    side?: DrawerSide;
+    /** Extent along the drawer's own axis. Default `md`. */
+    size?: DrawerSize;
+    /** Viewport-level or scoped to a container. Default `viewport`. */
+    attach?: DrawerAttach;
+    /** Render the scrim behind the panel. Default `true`. */
+    backdrop?: boolean;
+    /** Clicking the scrim closes. Default `true`. */
+    dismissOnBackdrop?: boolean;
+    /** Escape closes. Default `true`. */
+    dismissOnEscape?: boolean;
+    className?: string;
+}
+interface DrawerHeaderProps {
+    children: ReactNode;
+    /** Show the close button. Default `true`. */
+    closable?: boolean;
+    className?: string;
+}
+interface DrawerBodyProps {
+    children: ReactNode;
+    className?: string;
+}
+interface DrawerFooterProps {
+    children: ReactNode;
+    className?: string;
+}
+interface DrawerContainerProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+    className?: string;
+}
+
+declare function DrawerHeader({ children, closable, className }: DrawerHeaderProps): react.JSX.Element;
+declare namespace DrawerHeader {
+    var displayName: string;
+}
+
+declare function DrawerBody({ children, className }: DrawerBodyProps): react.JSX.Element;
+declare namespace DrawerBody {
+    var displayName: string;
+}
+
+declare function DrawerFooter({ children, className }: DrawerFooterProps): react.JSX.Element;
+declare namespace DrawerFooter {
+    var displayName: string;
+}
+
+/**
+ * The anchor for `<Drawer attach="container">`.
+ *
+ * A container-attached drawer positions itself `absolute`, which resolves
+ * against the nearest *positioned* ancestor — so without `relative` somewhere
+ * above it, the drawer silently escapes to the viewport and looks like it
+ * ignored `attach` entirely. This wrapper supplies `relative` + `overflow-hidden`
+ * so the panel slides within the box rather than out of it.
+ *
+ *   <Drawer.Container className="h-80 rounded-xl border">
+ *     <YourContent />
+ *     <Drawer attach="container" side="bottom" open={open} onClose={close}>
+ *       <Drawer.Body>Filters</Drawer.Body>
+ *     </Drawer>
+ *   </Drawer.Container>
+ *
+ * Any element works as long as it is positioned — this is the shortcut, not a
+ * requirement. Wrapping a Card, a layout pane, or a prompt-input shell in
+ * `relative overflow-hidden` does the same job.
+ */
+declare function DrawerContainer({ children, className, ...rest }: DrawerContainerProps): react.JSX.Element;
+declare namespace DrawerContainer {
+    var displayName: string;
+}
+
+declare function DrawerRoot({ children, open, onClose, side, size, attach, backdrop, dismissOnBackdrop, dismissOnEscape, className, ...rest }: DrawerProps): react.JSX.Element | null;
+declare const Drawer: typeof DrawerRoot & {
+    Header: typeof DrawerHeader;
+    Body: typeof DrawerBody;
+    Footer: typeof DrawerFooter;
+    Container: typeof DrawerContainer;
+};
+
+declare function useDrawer(): DrawerContextValue;
+
+export { Drawer, type DrawerAttach, type DrawerBodyProps, type DrawerContainerProps, type DrawerContextValue, type DrawerFooterProps, type DrawerHeaderProps, type DrawerProps, type DrawerSide, type DrawerSize, useDrawer };

package/dist/drawer.js

@@ -0,0 +1,8 @@
+export { Drawer, useDrawer } from './chunk-PRDWJ4AR.js';
+import './chunk-5U2DZ7AV.js';
+import './chunk-CHADHN6M.js';
+import './chunk-WHEXTDPV.js';
+import './chunk-JXE5XID6.js';
+import './chunk-DSUHZO6T.js';
+//# sourceMappingURL=drawer.js.map
+//# sourceMappingURL=drawer.js.map

package/dist/drawer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"drawer.js"}

package/dist/dropdown.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+var chunkORFHF6PT_cjs = require('./chunk-ORFHF6PT.cjs');
+require('./chunk-3WGRVDQR.cjs');
+require('./chunk-J2DI6RMR.cjs');
+require('./chunk-NBZC6LOB.cjs');
+require('./chunk-57FQGQJK.cjs');
+require('./chunk-RXDRYWVD.cjs');
+require('./chunk-3Z6ALUWP.cjs');
+
+
+
+Object.defineProperty(exports, "Dropdown", {
+  enumerable: true,
+  get: function () { return chunkORFHF6PT_cjs.Dropdown; }
+});
+Object.defineProperty(exports, "useDropdown", {
+  enumerable: true,
+  get: function () { return chunkORFHF6PT_cjs.useDropdown; }
+});
+//# sourceMappingURL=dropdown.cjs.map
+//# sourceMappingURL=dropdown.cjs.map

package/dist/dropdown.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"dropdown.cjs"}

package/dist/dropdown.d.cts

@@ -0,0 +1,67 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { P as Placement } from './types-8Sv0rCjw.cjs';
+
+interface DropdownContextValue {
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    anchorRef: React.RefObject<HTMLElement | null>;
+    activeIndex: number;
+    setActiveIndex: (index: number) => void;
+    placement: Placement;
+    offset: number;
+}
+interface DropdownProps {
+    children: ReactNode;
+    placement?: Placement;
+    offset?: number;
+}
+interface DropdownTriggerProps {
+    children: ReactNode;
+}
+interface DropdownItemsProps {
+    children: ReactNode;
+    className?: string;
+}
+interface DropdownItemProps {
+    children: ReactNode;
+    onClick?: () => void;
+    disabled?: boolean;
+    danger?: boolean;
+    className?: string;
+}
+interface DropdownSeparatorProps {
+    className?: string;
+}
+
+declare function DropdownTrigger({ children }: DropdownTriggerProps): react.JSX.Element;
+declare namespace DropdownTrigger {
+    var displayName: string;
+}
+
+declare function DropdownItems({ children, className }: DropdownItemsProps): react.JSX.Element | null;
+declare namespace DropdownItems {
+    var displayName: string;
+}
+
+declare function DropdownItem({ children, onClick, disabled, danger, className, }: DropdownItemProps): react.JSX.Element;
+declare namespace DropdownItem {
+    var displayName: string;
+}
+
+declare function DropdownSeparator({ className }: DropdownSeparatorProps): react.JSX.Element;
+declare namespace DropdownSeparator {
+    var displayName: string;
+}
+
+declare function DropdownRoot({ children, placement, offset, }: DropdownProps): react.JSX.Element;
+declare const Dropdown: typeof DropdownRoot & {
+    Trigger: typeof DropdownTrigger;
+    Items: typeof DropdownItems;
+    Item: typeof DropdownItem;
+    Separator: typeof DropdownSeparator;
+};
+
+declare function useDropdown(): DropdownContextValue;
+
+export { Dropdown, type DropdownContextValue, type DropdownItemProps, type DropdownItemsProps, type DropdownProps, type DropdownSeparatorProps, type DropdownTriggerProps, useDropdown };

package/dist/dropdown.d.ts

@@ -0,0 +1,67 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { P as Placement } from './types-8Sv0rCjw.js';
+
+interface DropdownContextValue {
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    anchorRef: React.RefObject<HTMLElement | null>;
+    activeIndex: number;
+    setActiveIndex: (index: number) => void;
+    placement: Placement;
+    offset: number;
+}
+interface DropdownProps {
+    children: ReactNode;
+    placement?: Placement;
+    offset?: number;
+}
+interface DropdownTriggerProps {
+    children: ReactNode;
+}
+interface DropdownItemsProps {
+    children: ReactNode;
+    className?: string;
+}
+interface DropdownItemProps {
+    children: ReactNode;
+    onClick?: () => void;
+    disabled?: boolean;
+    danger?: boolean;
+    className?: string;
+}
+interface DropdownSeparatorProps {
+    className?: string;
+}
+
+declare function DropdownTrigger({ children }: DropdownTriggerProps): react.JSX.Element;
+declare namespace DropdownTrigger {
+    var displayName: string;
+}
+
+declare function DropdownItems({ children, className }: DropdownItemsProps): react.JSX.Element | null;
+declare namespace DropdownItems {
+    var displayName: string;
+}
+
+declare function DropdownItem({ children, onClick, disabled, danger, className, }: DropdownItemProps): react.JSX.Element;
+declare namespace DropdownItem {
+    var displayName: string;
+}
+
+declare function DropdownSeparator({ className }: DropdownSeparatorProps): react.JSX.Element;
+declare namespace DropdownSeparator {
+    var displayName: string;
+}
+
+declare function DropdownRoot({ children, placement, offset, }: DropdownProps): react.JSX.Element;
+declare const Dropdown: typeof DropdownRoot & {
+    Trigger: typeof DropdownTrigger;
+    Items: typeof DropdownItems;
+    Item: typeof DropdownItem;
+    Separator: typeof DropdownSeparator;
+};
+
+declare function useDropdown(): DropdownContextValue;
+
+export { Dropdown, type DropdownContextValue, type DropdownItemProps, type DropdownItemsProps, type DropdownProps, type DropdownSeparatorProps, type DropdownTriggerProps, useDropdown };

package/dist/dropdown.js

@@ -0,0 +1,9 @@
+export { Dropdown, useDropdown } from './chunk-JIYP73OJ.js';
+import './chunk-CHADHN6M.js';
+import './chunk-MQ6VGG62.js';
+import './chunk-WHEXTDPV.js';
+import './chunk-RGANGU7X.js';
+import './chunk-JXE5XID6.js';
+import './chunk-DSUHZO6T.js';
+//# sourceMappingURL=dropdown.js.map
+//# sourceMappingURL=dropdown.js.map

package/dist/dropdown.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"dropdown.js"}

package/dist/editor.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+var chunkWT72KW5M_cjs = require('./chunk-WT72KW5M.cjs');
+require('./chunk-G34OBTU3.cjs');
+require('./chunk-T6YELZPJ.cjs');
+require('./chunk-RNHIDZLE.cjs');
+require('./chunk-TXTRTTG7.cjs');
+require('./chunk-DJ3YM72H.cjs');
+require('./chunk-3WGRVDQR.cjs');
+require('./chunk-BFKCVSNK.cjs');
+require('./chunk-J2DI6RMR.cjs');
+require('./chunk-L3V3BYVS.cjs');
+require('./chunk-57FQGQJK.cjs');
+require('./chunk-RXDRYWVD.cjs');
+require('./chunk-OUOEQZHY.cjs');
+require('./chunk-3Z6ALUWP.cjs');
+
+
+
+Object.defineProperty(exports, "Editor", {
+  enumerable: true,
+  get: function () { return chunkWT72KW5M_cjs.Editor; }
+});
+Object.defineProperty(exports, "useEditor", {
+  enumerable: true,
+  get: function () { return chunkWT72KW5M_cjs.useEditor; }
+});
+//# sourceMappingURL=editor.cjs.map
+//# sourceMappingURL=editor.cjs.map

package/dist/editor.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"editor.cjs"}

package/dist/editor.d.cts

@@ -0,0 +1,153 @@
+import * as react from 'react';
+import { ReactNode, RefObject } from 'react';
+import { R as RenderExtension } from './extensions-6PVd3-vB.cjs';
+import { F as FieldMode } from './inputs.types-CkWdvN-t.cjs';
+import './types-8Sv0rCjw.cjs';
+
+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 };