@mdxeditor/editor 0.1.0 → 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,722 @@
+/**
+ * The `@mdxeditor/editor` package exports the MDXEditor React component, along with some utilities and default option values that id the customization of the widget.
+ * In addition to that, the package exports the LexicalNodes used to represent the MDX AST, as well as the NodeDecorators used to render the nodes in the editor.
+ *
+ * @packageDocumentation
+ */
+
+/// <reference types="react" />
+
+import { AdmonitionKind } from 'lexical';
+import type { ComponentType } from 'react';
+import { ContainerDirective } from 'mdast-util-directive';
+import { DecoratorNode } from 'lexical';
+import type { DOMConversionMap } from 'lexical';
+import type { DOMExportOutput } from 'lexical';
+import { EditorConfig } from 'lexical';
+import { EditorThemeClasses } from 'lexical';
+import { ElementNode } from 'lexical';
+import { FromMarkdownOptions } from 'mdast-util-from-markdown/lib';
+import { HeadingNode } from '@lexical/rich-text';
+import { HorizontalRuleNode } from '@lexical/react/LexicalHorizontalRuleNode';
+import { Klass } from 'lexical';
+import { LexicalEditor } from 'lexical';
+import { LexicalNode } from 'lexical';
+import { LineBreakNode } from 'lexical';
+import { LinkNode } from '@lexical/link';
+import { ListItemNode } from '@lexical/list';
+import { ListNode } from '@lexical/list';
+import * as Mdast from 'mdast';
+import { MdxjsEsm } from 'mdast-util-mdx';
+import { MdxJsxAttribute } from 'mdast-util-mdx-jsx';
+import type { MdxJsxFlowElement } from 'mdast-util-mdx-jsx';
+import type { MdxJsxTextElement } from 'mdast-util-mdx-jsx';
+import { MdxJsxTextElement as MdxJsxTextElement_2 } from 'mdast-util-mdx';
+import { NodeKey } from 'lexical';
+import { ParagraphNode } from 'lexical';
+import { ParseOptions } from 'mdast-util-from-markdown/lib';
+import { QuoteNode } from '@lexical/rich-text';
+import * as RadixToolbar from '@radix-ui/react-toolbar';
+import { RangeSelection } from 'lexical';
+import { default as React_2 } from 'react';
+import { RootNode } from 'lexical';
+import { SandpackProvider } from '@codesandbox/sandpack-react';
+import { SerializedEditorState } from 'lexical';
+import { SerializedElementNode } from 'lexical';
+import { SerializedLexicalNode } from 'lexical';
+import { Spread } from 'lexical';
+import { TextNode } from 'lexical';
+import { Options as ToMarkdownOptions } from 'mdast-util-to-markdown';
+
+export declare function $createAdmonitionNode(kind?: AdmonitionKind): AdmonitionNode;
+
+export declare function $createCodeBlockNode({ code, language, meta }: CodeBlockPayload): CodeBlockNode;
+
+export declare function $createFrontmatterNode({ yaml }: FrontmatterPayload): FrontmatterNode;
+
+export declare function $createImageNode({ altText, title, src, key }: ImagePayload): ImageNode;
+
+export declare function $createJsxNode(payload: JsxPayload): JsxNode;
+
+export declare function $createSandpackNode({ code, language, meta }: SandpackPayload): SandpackNode;
+
+export declare function $createTableNode(mdastNode: Mdast.Table): TableNode;
+
+export declare function $isAdmonitionNode(node: LexicalNode | null | undefined): node is AdmonitionNode;
+
+export declare function $isCodeBlockNode(node: LexicalNode | null | undefined): node is CodeBlockNode;
+
+export declare function $isFrontmatterNode(node: LexicalNode | null | undefined): node is FrontmatterNode;
+
+export declare function $isImageNode(node: LexicalNode | null | undefined): node is ImageNode;
+
+export declare function $isJsxNode(node: LexicalNode | null | undefined): node is JsxNode;
+
+export declare function $isSandpackNode(node: LexicalNode | null | undefined): node is SandpackNode;
+
+export declare function $isTableNode(node: LexicalNode | null | undefined): node is TableNode;
+
+export declare type ActiveEditorType = LexicalEditorType | CodeBlockEditorType | SandpackEditorType;
+
+export { AdmonitionKind }
+
+export declare class AdmonitionNode extends ElementNode {
+    __kind: AdmonitionKind;
+    static getType(): string;
+    getKind(): AdmonitionKind;
+    setKind(kind: AdmonitionKind): void;
+    static clone(node: AdmonitionNode): AdmonitionNode;
+    constructor(kind?: AdmonitionKind, key?: NodeKey);
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(_prevNode: AdmonitionNode, _dom: HTMLElement): boolean;
+    static importJSON(serializedNode: SerializedAdmonitionNode): AdmonitionNode;
+    exportJSON(): SerializedElementNode;
+    insertNewAfter(_: RangeSelection, restoreSelection?: boolean): AdmonitionNode;
+    collapseAtStart(): true;
+}
+
+export declare interface CodeBlockEditorProps extends SandpackEditorProps {
+    language: string;
+}
+
+export declare type CodeBlockEditorType = {
+    type: 'codeblock';
+    nodeKey: string;
+};
+
+export declare class CodeBlockNode extends DecoratorNode<JSX.Element> {
+    __code: string;
+    __meta: string;
+    __language: string;
+    __focusEmitter: {
+        publish: () => void;
+        subscribe: (cb: () => void) => void;
+    };
+    static getType(): string;
+    static clone(node: CodeBlockNode): CodeBlockNode;
+    static importJSON(serializedNode: SerializedCodeBlockNode): CodeBlockNode;
+    constructor(code: string, language: string, meta: string, key?: NodeKey);
+    exportJSON(): SerializedCodeBlockNode;
+    createDOM(_config: EditorConfig): HTMLDivElement;
+    updateDOM(): false;
+    getCode(): string;
+    getMeta(): string;
+    getLanguage(): string;
+    setCode(code: string): void;
+    setMeta(meta: string): void;
+    setLanguage(language: string): void;
+    select(): void;
+    decorate(_editor: LexicalEditor, { theme: { nodeDecoratorComponents: { CodeBlockEditor } } }: ExtendedEditorConfig): JSX.Element;
+}
+
+export declare interface CodeBlockPayload {
+    code: string;
+    meta: string;
+    language: string;
+}
+
+export declare type CoordinatesSubscription = (coords: [colIndex: number, rowIndex: number]) => void;
+
+export declare const defaultExtensions: {
+    mdxToMarkdown: ToMarkdownOptions;
+    frontmatterToMarkdown: ToMarkdownOptions;
+    directiveToMarkdown: ToMarkdownOptions;
+    gfmTableToMarkdown: ToMarkdownOptions;
+};
+
+export declare const defaultLexicalNodes: Record<string, Klass<LexicalNode>>;
+
+export declare const defaultLexicalVisitors: {
+    LexicalRootVisitor: LexicalExportVisitor<RootNode, Mdast.Content>;
+    LexicalParagraphVisitor: LexicalExportVisitor<ParagraphNode, Mdast.Paragraph>;
+    LexicalFrontmatterVisitor: LexicalExportVisitor<FrontmatterNode, Mdast.YAML>;
+    LexicalTextVisitor: LexicalExportVisitor<TextNode, Mdast.Text>;
+    LexicalLinebreakVisitor: LexicalExportVisitor<LineBreakNode, Mdast.Text>;
+    LexicalLinkVisitor: LexicalExportVisitor<LinkNode, Mdast.Link>;
+    LexicalHeadingVisitor: LexicalExportVisitor<HeadingNode, Mdast.Heading>;
+    LexicalListVisitor: LexicalExportVisitor<ListNode, Mdast.List>;
+    LexicalListItemVisitor: LexicalExportVisitor<ListItemNode, Mdast.ListItem>;
+    LexicalQuoteVisitor: LexicalExportVisitor<QuoteNode, Mdast.Blockquote>;
+    SandpackNodeVisitor: LexicalExportVisitor<SandpackNode, Mdast.Code>;
+    CodeBlockVisitor: LexicalExportVisitor<CodeBlockNode, Mdast.Code>;
+    LexicalThematicBreakVisitor: LexicalExportVisitor<HorizontalRuleNode, Mdast.ThematicBreak>;
+    AdmonitionVisitor: LexicalExportVisitor<AdmonitionNode, ContainerDirective>;
+    LexicalImageVisitor: LexicalExportVisitor<ImageNode, Mdast.Image>;
+    JsxVisitor: LexicalExportVisitor<JsxNode, MdxJsxFlowElement | MdxJsxTextElement>;
+    LexicalTableVisitor: LexicalExportVisitor<TableNode, Mdast.Table>;
+};
+
+export declare const defaultMdastExtensions: Record<string, MarkdownParseOptions['mdastExtensions'][number]>;
+
+export declare const defaultMdastVisitors: Record<string, MdastImportVisitor<Mdast.Content>>;
+
+export declare interface DefaultMdxOptionValues {
+    markdownParse: {
+        defaultVisitors: typeof defaultMdastVisitors;
+        defaultSyntaxExtensions: typeof defaultSyntaxExtensions;
+        defaultMdastExtensions: typeof defaultMdastExtensions;
+    };
+    lexicalConvert: {
+        defaultVisitors: typeof defaultLexicalVisitors;
+        defaultExtensions: typeof defaultExtensions;
+        defaultMarkdownOptions: typeof defaultToMarkdownOptions;
+    };
+    defaultLexicalNodes: typeof defaultLexicalNodes;
+}
+
+export declare const defaultMdxOptionValues: DefaultMdxOptionValues;
+
+export declare const defaultSyntaxExtensions: Record<string, MarkdownParseOptions['syntaxExtensions'][number]>;
+
+export declare const defaultToMarkdownOptions: ToMarkdownOptions;
+
+export declare interface ExportLexicalTreeOptions {
+    root: RootNode;
+    visitors: LexicalVisitor[];
+    jsxComponentDescriptors: JsxComponentDescriptors;
+}
+
+export declare function exportLexicalTreeToMdast({ root, visitors, jsxComponentDescriptors }: ExportLexicalTreeOptions): Mdast.Root;
+
+export declare function exportMarkdownFromLexical({ root, toMarkdownOptions, toMarkdownExtensions, visitors, jsxComponentDescriptors }: ExportMarkdownFromLexicalOptions): string;
+
+export declare interface ExportMarkdownFromLexicalOptions extends ExportLexicalTreeOptions {
+    toMarkdownExtensions: ToMarkdownOptions['extensions'];
+    toMarkdownOptions: ToMarkdownOptions;
+}
+
+declare type ExtendedEditorConfig = EditorConfig & {
+    theme: EditorConfig['theme'] & {
+        nodeDecoratorComponents: NodeDecoratorComponents;
+    };
+};
+
+export declare interface FrontmatterEditorProps {
+    yaml: string;
+    onChange: (yaml: string) => void;
+}
+
+export declare class FrontmatterNode extends DecoratorNode<JSX.Element> {
+    __yaml: string;
+    static getType(): string;
+    static clone(node: FrontmatterNode): FrontmatterNode;
+    static importJSON(serializedNode: SerializedFrontmatterNode): FrontmatterNode;
+    constructor(code: string, key?: NodeKey);
+    exportJSON(): SerializedFrontmatterNode;
+    createDOM(_config: EditorConfig): HTMLDivElement;
+    updateDOM(): false;
+    getYaml(): string;
+    setYaml(yaml: string): void;
+    decorate(editor: LexicalEditor, { theme: { nodeDecoratorComponents: { FrontmatterEditor } } }: ExtendedEditorConfig): JSX.Element;
+}
+
+export declare interface FrontmatterPayload {
+    yaml: string;
+}
+
+export declare class ImageNode extends DecoratorNode<JSX.Element> {
+    __src: string;
+    __altText: string;
+    __title: string | undefined;
+    static getType(): string;
+    static clone(node: ImageNode): ImageNode;
+    static importJSON(serializedNode: SerializedImageNode): ImageNode;
+    exportDOM(): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
+    constructor(src: string, altText: string, title: string | undefined, key?: NodeKey);
+    exportJSON(): SerializedImageNode;
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(): false;
+    getSrc(): string;
+    getAltText(): string;
+    getTitle(): string | undefined;
+    setTitle(title: string | undefined): void;
+    decorate(): JSX.Element;
+}
+
+export declare interface ImagePayload {
+    altText: string;
+    title?: string;
+    key?: NodeKey;
+    src: string;
+}
+
+export declare function importMarkdownToLexical({ root, markdown, visitors, syntaxExtensions, mdastExtensions }: MarkdownParseOptions): void;
+
+export declare function importMdastTreeToLexical({ root, mdastRoot, visitors }: MdastTreeImportOptions): void;
+
+export declare type ImportVisitors = Array<MdastImportVisitor<Mdast.Content>>;
+
+declare const IS_BOLD: 1;
+
+declare const IS_ITALIC: 2;
+
+declare const IS_UNDERLINE: 8;
+
+export declare interface JsxComponentDescriptor {
+    name: string;
+    kind: 'flow' | 'text';
+    source: string;
+    defaultExport?: boolean;
+    props: Array<JsxPropertyDescriptor>;
+}
+
+export declare type JsxComponentDescriptors = Array<JsxComponentDescriptor>;
+
+export declare interface JsxEditorProps {
+    kind: JsxKind;
+    attributes: MdxJsxAttribute[];
+    componentName: string;
+    onSubmit: (values: Record<string, string>) => void;
+    theme: EditorThemeClasses;
+    editor: LexicalEditor;
+}
+
+export declare type JsxKind = 'text' | 'flow';
+
+export declare class JsxNode extends DecoratorNode<JSX.Element> {
+    __kind: JsxKind;
+    __name: string;
+    __attributes: Array<MdxJsxAttribute>;
+    __editor: LexicalEditor;
+    static getType(): string;
+    static clone(node: JsxNode): JsxNode;
+    static importJSON(serializedNode: SerializedJsxNode): JsxNode;
+    constructor({ name, kind, attributes, state, updateFn, key }: JsxNodeConstructorParams);
+    exportJSON(): SerializedJsxNode;
+    inNestedEditor(callback: () => void): void;
+    getChildren(): Array<LexicalNode>;
+    createDOM(): HTMLElement;
+    updateDOM(): false;
+    getName(): string;
+    getKind(): JsxKind;
+    getAttributes(): MdxJsxAttribute[];
+    updateAttributes(attributeValues: Record<string, string>): void;
+    decorate(_parentEditor: LexicalEditor, { theme: { nodeDecoratorComponents: { JsxEditor } } }: ExtendedEditorConfig): JSX.Element;
+}
+
+export declare interface JsxNodeConstructorParams extends JsxPayload {
+    key?: NodeKey;
+}
+
+export declare interface JsxPayload {
+    name: string;
+    kind: JsxKind;
+    attributes: Array<MdxJsxAttribute>;
+    state?: SerializedEditorState;
+    updateFn?: updateFn;
+}
+
+export declare interface JsxPropertyDescriptor {
+    name: string;
+    type: 'string' | 'number';
+    required?: boolean;
+}
+
+export declare type LexicalEditorType = {
+    type: 'lexical';
+};
+
+export declare interface LexicalExportVisitor<LN extends LexicalNode, UN extends Mdast.Content> {
+    testLexicalNode?(lexicalNode: LexicalNode): lexicalNode is LN;
+    visitLexicalNode?(params: LexicalNodeVisitParams<LN>): void;
+    shouldJoin?(prevNode: Mdast.Content, currentNode: UN): boolean;
+    join?<T extends Mdast.Content>(prevNode: T, currentNode: T): T;
+}
+
+export declare interface LexicalNodeVisitParams<T extends LexicalNode> {
+    lexicalNode: T;
+    mdastParent: Mdast.Parent;
+    actions: LexicalVisitActions<T>;
+}
+
+export declare interface LexicalVisitActions<T extends LexicalNode> {
+    visitChildren(node: T, mdastParent: Mdast.Parent): void;
+    addAndStepInto(type: string, props?: Record<string, unknown>, hasChildren?: boolean): void;
+    appendToParent<T extends Mdast.Parent>(parentNode: T, node: T['children'][number]): T['children'][number] | Mdast.Root;
+    registerReferredComponent(componentName: string): void;
+}
+
+export declare type LexicalVisitor = LexicalExportVisitor<LexicalNode, Mdast.Content>;
+
+export declare interface MarkdownParseOptions extends Omit<MdastTreeImportOptions, 'mdastRoot'> {
+    markdown: string;
+    syntaxExtensions: NonNullable<ParseOptions['extensions']>;
+    mdastExtensions: NonNullable<FromMarkdownOptions['mdastExtensions']>;
+}
+
+export declare const MdastAdmonitionVisitor: MdastImportVisitor<ContainerDirective>;
+
+export declare const MdastBlockQuoteVisitor: MdastImportVisitor<Mdast.Blockquote>;
+
+export declare const MdastCodeVisitor: MdastImportVisitor<Mdast.Code>;
+
+export declare const MdastFormattingVisitor: MdastImportVisitor<Mdast.Emphasis | Mdast.Strong | MdxJsxTextElement_2>;
+
+export declare const MdastFrontmatterVisitor: MdastImportVisitor<Mdast.YAML>;
+
+export declare const MdastHeadingVisitor: MdastImportVisitor<Mdast.Heading>;
+
+export declare const MdastImageVisitor: MdastImportVisitor<Mdast.Image>;
+
+export declare interface MdastImportVisitor<UN extends Mdast.Content> {
+    testNode: ((mdastNode: Mdast.Content | Mdast.Root) => boolean) | string;
+    visitNode(params: MdastVisitParams<UN>): void;
+}
+
+export declare const MdastInlineCodeVisitor: MdastImportVisitor<Mdast.InlineCode>;
+
+export declare const MdastLinkVisitor: MdastImportVisitor<Mdast.Link>;
+
+export declare const MdastListItemVisitor: MdastImportVisitor<Mdast.ListItem>;
+
+export declare const MdastListVisitor: MdastImportVisitor<Mdast.List>;
+
+export declare const MdastMdxJsEsmVisitor: MdastImportVisitor<MdxjsEsm>;
+
+export declare const MdastMdxJsxElementVisitor: MdastImportVisitor<MdxJsxTextElement_2>;
+
+export declare const MdastParagraphVisitor: MdastImportVisitor<Mdast.Paragraph>;
+
+export declare const MdastRootVisitor: MdastImportVisitor<Mdast.Content>;
+
+export declare const MdastTableVisitor: MdastImportVisitor<Mdast.Table>;
+
+export declare const MdastTextVisitor: MdastImportVisitor<Mdast.Text>;
+
+export declare const MdastThematicBreakVisitor: MdastImportVisitor<Mdast.ThematicBreak>;
+
+export declare interface MdastTreeImportOptions {
+    root: RootNode;
+    visitors: Array<MdastImportVisitor<Mdast.Content>>;
+    mdastRoot: Mdast.Root;
+}
+
+export declare interface MdastVisitActions {
+    visitChildren(node: Mdast.Parent, lexicalParent: LexicalNode): void;
+    addAndStepInto(lexicalNode: LexicalNode): void;
+    addFormatting(format: typeof IS_BOLD | typeof IS_ITALIC | typeof IS_UNDERLINE): void;
+    getParentFormatting(): number;
+}
+
+export declare interface MdastVisitParams<T extends Mdast.Content> {
+    mdastNode: T;
+    lexicalParent: LexicalNode;
+    actions: MdastVisitActions;
+}
+
+/**
+ * The MDXEditor React component
+ */
+export declare const MDXEditor: React_2.ForwardRefExoticComponent<MDXEditorProps & React_2.RefAttributes<MDXEditorMethods>>;
+
+/**
+ * The interface for the {@link MDXEditor} object reference.
+ *
+ * @example
+ * ```tsx
+ *  const mdxEditorRef = React.useRef<MDXEditorMethods>(null)
+ *  <MDXEditor ref={mdxEditorRef} />
+ * ```
+ */
+export declare interface MDXEditorMethods {
+    getMarkdown: () => string;
+}
+
+/**
+ * The properties of the {@link MDXEditor} react component
+ */
+export declare interface MDXEditorProps {
+    /**
+     * The markdown content to be edited.
+     */
+    markdown: string;
+    /**
+     * The configuration for the sandpack editor that's used for the fenced code blocks.
+     * @see the {@link SandpackConfig} interface for more details.
+     */
+    sandpackConfig?: SandpackConfig;
+    /**
+     * The markdown content to use for the diff view mode. If not provided, the contents of the `markdown` prop will be used.
+     */
+    headMarkdown?: string;
+    /**
+     * The configuration for the JSX components used in the markdown content.
+     * @see the {@link JsxComponentDescriptors} interface for more details.
+     */
+    jsxComponentDescriptors?: JsxComponentDescriptors;
+    /**
+     * The list of suggestions to be shown in the link autocomplete dialog dropdown.
+     */
+    linkAutocompleteSuggestions?: string[];
+    /**
+     * The list of suggestions to be shown in the image autocomplete dialog dropdown.
+     */
+    imageAutoCompleteSuggestions?: string[];
+    /**
+     * The set of components to be rendered in the toolbar.
+     */
+    toolbarComponents?: ComponentType[];
+    /**
+     * The initial view mode for the editor. Defaults to `ViewMode.editor`.
+     */
+    viewMode?: ViewMode;
+    onChange?: (markdown: string) => void;
+    className?: string;
+    contentEditableClassName?: string;
+    markdownParseOptions?: Partial<MarkdownParseOptions>;
+    lexicalNodes?: Klass<LexicalNode>[];
+    lexicalConvertOptions?: Partial<ExportMarkdownFromLexicalOptions>;
+}
+
+declare interface NodeDecoratorComponents {
+    FrontmatterEditor: React.FC<FrontmatterEditorProps>;
+    JsxEditor: React.FC<JsxEditorProps>;
+    SandpackEditor: React.FC<SandpackEditorProps>;
+    CodeBlockEditor: React.FC<CodeBlockEditorProps>;
+    TableEditor: React.FC<TableEditorProps>;
+}
+
+/**
+ * The configuration for the available sandpack presets
+ */
+export declare interface SandpackConfig {
+    /**
+     * The name of the default preset that will be used if no meta (other than live) is set
+     */
+    defaultPreset: string;
+    /**
+     * The list of sandpack presets that can be used
+     */
+    presets: Array<SandpackPreset>;
+}
+
+export declare interface SandpackEditorProps {
+    code: string;
+    nodeKey: string;
+    meta: string;
+    onChange: (code: string) => void;
+    focusEmitter: VoidEmitter;
+}
+
+export declare type SandpackEditorType = {
+    type: 'sandpack';
+    nodeKey: string;
+};
+
+export declare class SandpackNode extends DecoratorNode<JSX.Element> {
+    __code: string;
+    __meta: string;
+    __language: string;
+    __focusEmitter: {
+        publish: () => void;
+        subscribe: (cb: () => void) => void;
+    };
+    static getType(): string;
+    static clone(node: SandpackNode): SandpackNode;
+    static importJSON(serializedNode: SerializedSandpackNode): SandpackNode;
+    constructor(code: string, language: string, meta: string, key?: NodeKey);
+    exportJSON(): SerializedSandpackNode;
+    createDOM(_config: EditorConfig): HTMLDivElement;
+    updateDOM(): false;
+    getCode(): string;
+    getMeta(): string;
+    getLanguage(): string;
+    setCode(code: string): void;
+    setMeta(meta: string): void;
+    setLanguage(language: string): void;
+    select(): void;
+    decorate(_parentEditor: LexicalEditor, { theme: { nodeDecoratorComponents: { SandpackEditor } } }: ExtendedEditorConfig): JSX.Element;
+}
+
+export declare interface SandpackPayload {
+    code: string;
+    meta: string;
+    language: string;
+}
+
+/**
+ * Defines a single preset that can be used to create a sandbox.
+ */
+export declare interface SandpackPreset {
+    /**
+     * The name of the preset - use this to reference the preset from the defaultPreset field
+     */
+    name: string;
+    /**
+     * The label of th preset, displayed in the sandpack button dropdown
+     */
+    label: string;
+    /**
+     * The meta string that will be used to identify the preset from the fenced code block. e.g. "live react"
+     */
+    meta: string;
+    /**
+     * The sandpack template that will be used to create the sandbox. e.g. "react", "react-ts", "vanilla".
+     */
+    sandpackTemplate: SandpackProviderProps['template'];
+    /**
+     * The sandpack theme that will be used to create the sandbox. e.g. "light", "dark".
+     */
+    sandpackTheme: SandpackProviderProps['theme'];
+    /**
+     * The name of the file that will be created in the sandbox. e.g. "/App.js"
+     */
+    snippetFileName: string;
+    /**
+     * The dependencies that will be added to the sandbox, just like in package.json
+     */
+    dependencies?: Record<string, string>;
+    /**
+     * The files that will be added to the sandbox (read-only).
+     * The key is the name of the file, and the value is the contents of the file.
+     */
+    files?: Record<string, string>;
+    /**
+     * The language used in the editable snippet. e.g. "jsx", "tsx", etc
+     */
+    snippetLanguage?: string;
+    /**
+     * The initial content of the editable snippet.
+     */
+    initialSnippetContent?: string;
+}
+
+declare type SandpackProviderProps = React_2.ComponentProps<typeof SandpackProvider>;
+
+export declare type SerializedAdmonitionNode = Spread<{
+    type: 'admonition';
+    kind: AdmonitionKind;
+    version: 1;
+}, SerializedElementNode>;
+
+export declare type SerializedCodeBlockNode = Spread<CodeBlockPayload & {
+    type: 'codeblock';
+    version: 1;
+}, SerializedLexicalNode>;
+
+export declare type SerializedFrontmatterNode = Spread<{
+    yaml: string;
+    version: 1;
+}, SerializedLexicalNode>;
+
+export declare type SerializedImageNode = Spread<{
+    altText: string;
+    title?: string;
+    src: string;
+    type: 'image';
+    version: 1;
+}, SerializedLexicalNode>;
+
+export declare type SerializedJsxNode = Spread<Omit<JsxPayload, 'updateFn'> & {
+    version: 1;
+    type: 'jsx';
+}, SerializedLexicalNode>;
+
+export declare type SerializedSandpackNode = Spread<SandpackPayload & {
+    type: 'sandpack';
+    version: 1;
+}, SerializedLexicalNode>;
+
+export declare type SerializedTableNode = Spread<{
+    mdastNode: Mdast.Table;
+}, SerializedLexicalNode>;
+
+export declare interface TableEditorProps {
+    parentEditor: LexicalEditor;
+    lexicalTable: TableNode;
+    mdastNode: Mdast.Table;
+}
+
+export declare class TableNode extends DecoratorNode<JSX.Element> {
+    __mdastNode: Mdast.Table;
+    focusEmitter: {
+        publish: (coords: [colIndex: number, rowIndex: number]) => void;
+        subscribe: (cb: CoordinatesSubscription) => void;
+    };
+    static getType(): string;
+    static clone(node: TableNode): TableNode;
+    static importJSON(serializedNode: SerializedTableNode): TableNode;
+    exportJSON(): SerializedTableNode;
+    getMdastNode(): Mdast.Table;
+    getRowCount(): number;
+    getColCount(): number;
+    constructor(mdastNode?: Mdast.Table, key?: NodeKey);
+    createDOM(): HTMLElement;
+    updateDOM(): false;
+    updateCellContents(colIndex: number, rowIndex: number, children: Mdast.PhrasingContent[]): void;
+    insertColumnAt(colIndex: number): void;
+    deleteColumnAt(colIndex: number): void;
+    insertRowAt(y: number): void;
+    deleteRowAt(rowIndex: number): void;
+    addRowToBottom(): void;
+    addColumnToRight(): void;
+    setColumnAlign(colIndex: number, align: Mdast.AlignType): void;
+    decorate(parentEditor: LexicalEditor, { theme: { nodeDecoratorComponents: { TableEditor } } }: ExtendedEditorConfig): JSX.Element;
+    select(coords: [colIndex: number, rowIndex: number]): void;
+    isInline(): false;
+}
+
+export { ToMarkdownOptions }
+
+export declare const ToolbarComponents: {
+    BlockTypeSelect: () => React_2.JSX.Element;
+    BoldItalicUnderlineButtons: React_2.FC<{}>;
+    CodeBlockButton: React_2.FC<{}>;
+    FrontmatterButton: React_2.FC<{}>;
+    GroupGroup: React_2.FC<{
+        children: React_2.ReactNode;
+    }>;
+    HorizontalRuleIcon: React_2.FC<React_2.SVGProps<SVGSVGElement> & {
+        title?: string | undefined;
+    }>;
+    LinkButton: React_2.FC<{}>;
+    ListButtons: React_2.FC<{}>;
+    SandpackButton: React_2.FC<{}>;
+    TableButton: React_2.FC<{}>;
+    ToggleItem: React_2.ForwardRefExoticComponent<RadixToolbar.ToolbarToggleItemProps & React_2.RefAttributes<HTMLButtonElement>>;
+    ToggleSingleGroup: React_2.ForwardRefExoticComponent<Omit<RadixToolbar.ToolbarToggleGroupSingleProps, "type"> & React_2.RefAttributes<HTMLDivElement>>;
+    ToggleSingleGroupWithItem: React_2.ForwardRefExoticComponent<Omit<RadixToolbar.ToolbarToggleGroupSingleProps, "type"> & {
+        on: boolean;
+    } & React_2.RefAttributes<HTMLDivElement>>;
+    ToolbarButton: React_2.ForwardRefExoticComponent<RadixToolbar.ToolbarButtonProps & React_2.RefAttributes<HTMLButtonElement>>;
+    ToolbarSeparator: React_2.ForwardRefExoticComponent<RadixToolbar.ToolbarSeparatorProps & React_2.RefAttributes<HTMLDivElement>>;
+    ImageButton: React_2.ForwardRefExoticComponent<RadixToolbar.ToolbarButtonProps & React_2.RefAttributes<HTMLButtonElement>>;
+};
+
+export declare type updateFn = (node: LexicalNode) => void;
+
+/**
+ * The editor view mode.
+ * editor - The default rich text view mode.
+ * markdown - plain text markdown edit mode.
+ * diff - side by side comparison with the original markdown (passed as `headMarkdown`).
+ */
+export declare type ViewMode = 'editor' | 'markdown' | 'diff';
+
+export declare interface VoidEmitter {
+    publish: () => void;
+    subscribe: (callback: () => void) => void;
+}
+
+export { }