@contentful/field-editor-rich-text 1.0.2 → 2.0.0-next.0

package/dist/plugins/List/index.d.ts

@@ -1,114 +1,15 @@
-export function ListPlugin(): any;
-export const UnorderedList: {
-    new (props: any): {
-        handleToggle: (event: any) => any;
-        render(): JSX.Element;
-        context: any;
-        setState<K extends string | number | symbol>(state: any, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<any> & Readonly<{
-            children?: React.ReactNode;
-        }>;
-        state: Readonly<any>;
-        refs: {
-            [key: string]: React.ReactInstance;
-        };
-        componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): boolean;
-        componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<any>, prevState: Readonly<any>): any;
-        componentDidUpdate?(prevProps: Readonly<any>, prevState: Readonly<any>, snapshot?: any): void;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<any>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<any>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): void;
-    };
-    new (props: any, context: any): {
-        handleToggle: (event: any) => any;
-        render(): JSX.Element;
-        context: any;
-        setState<K extends string | number | symbol>(state: any, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<any> & Readonly<{
-            children?: React.ReactNode;
-        }>;
-        state: Readonly<any>;
-        refs: {
-            [key: string]: React.ReactInstance;
-        };
-        componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): boolean;
-        componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<any>, prevState: Readonly<any>): any;
-        componentDidUpdate?(prevProps: Readonly<any>, prevState: Readonly<any>, snapshot?: any): void;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<any>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<any>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): void;
-    };
-    propTypes: any;
-    contextType?: React.Context<any> | undefined;
-};
-export const OrderedList: {
-    new (props: any): {
-        handleToggle: (event: any) => any;
-        render(): JSX.Element;
-        context: any;
-        setState<K extends string | number | symbol>(state: any, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<any> & Readonly<{
-            children?: React.ReactNode;
-        }>;
-        state: Readonly<any>;
-        refs: {
-            [key: string]: React.ReactInstance;
-        };
-        componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): boolean;
-        componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<any>, prevState: Readonly<any>): any;
-        componentDidUpdate?(prevProps: Readonly<any>, prevState: Readonly<any>, snapshot?: any): void;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<any>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<any>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): void;
-    };
-    new (props: any, context: any): {
-        handleToggle: (event: any) => any;
-        render(): JSX.Element;
-        context: any;
-        setState<K extends string | number | symbol>(state: any, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<any> & Readonly<{
-            children?: React.ReactNode;
-        }>;
-        state: Readonly<any>;
-        refs: {
-            [key: string]: React.ReactInstance;
-        };
-        componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): boolean;
-        componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<any>, prevState: Readonly<any>): any;
-        componentDidUpdate?(prevProps: Readonly<any>, prevState: Readonly<any>, snapshot?: any): void;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<any>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<any>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): void;
-    };
-    propTypes: any;
-    contextType?: React.Context<any> | undefined;
-};
-import React from "react";
+/// <reference types="react" />
+import * as Slate from 'slate-react';
+import { BLOCKS } from '@contentful/rich-text-types';
+import { CustomSlatePluginOptions } from '../../types';
+interface ToolbarListButtonProps {
+    isDisabled?: boolean;
+}
+export declare function ToolbarListButton(props: ToolbarListButtonProps): JSX.Element | null;
+export declare function createList(Tag: any, block: BLOCKS): (props: Slate.RenderElementProps) => JSX.Element;
+export declare const UL: (props: Slate.RenderElementProps) => JSX.Element;
+export declare const OL: (props: Slate.RenderElementProps) => JSX.Element;
+export declare const LI: (props: Slate.RenderElementProps) => JSX.Element;
+export declare const withListOptions: CustomSlatePluginOptions;
+export declare const createListPlugin: () => import("@udecode/plate-core").PlatePlugin<import("@udecode/plate-core").SPEditor>;
+export {};

package/dist/plugins/NewLine/index.d.ts

@@ -0,0 +1,2 @@
+import { PlatePlugin } from '@udecode/plate-core';
+export declare function createNewLinePlugin(): PlatePlugin;

package/dist/plugins/Paragraph/index.d.ts

@@ -1,5 +1,7 @@
-export function ParagraphPlugin(type?: BLOCKS): {
-    renderNode: (props: any, _editor: any, next: any) => any;
-    onKeyDown: (e: any, editor: any, next: any) => any;
-};
-import { BLOCKS } from "@contentful/rich-text-types";
+/// <reference types="react" />
+import { RenderElementProps } from 'slate-react';
+import { PlatePlugin } from '@udecode/plate-core';
+import { CustomSlatePluginOptions } from '../../types';
+export declare function Paragraph(props: RenderElementProps): JSX.Element;
+export declare function createParagraphPlugin(): PlatePlugin;
+export declare const withParagraphOptions: CustomSlatePluginOptions;

package/dist/plugins/Paste/index.d.ts

@@ -1,7 +1,2 @@
-export function PastePlugin({ richTextAPI: { logShortcutAction } }: {
-    richTextAPI: {
-        logShortcutAction: any;
-    };
-}): {
-    onPaste(_event: any, editor: any, next: any): void;
-};
+import { PlatePlugin } from '@udecode/plate-core';
+export declare const createPastePlugin: () => PlatePlugin;

package/dist/plugins/Paste/sanitizers/helpers.d.ts

@@ -0,0 +1,7 @@
+import { SPEditor } from '@udecode/plate-core';
+export declare type SanitizerTuple = [Document, SPEditor];
+declare type Predicate = (node: ChildNode) => boolean;
+export declare const isHTMLElement: (node: ChildNode) => node is HTMLElement;
+export declare const removeChildNodes: (node: ChildNode, predicate?: Predicate) => void;
+export declare const removeChildNodesUsingPredicate: (predicate: Predicate) => (nodeList: NodeList) => Node[];
+export {};

package/dist/plugins/Paste/sanitizers/index.d.ts

@@ -0,0 +1,3 @@
+export { removeComments } from './removeComments';
+export { sanitizeTables } from './sanitizeTables';
+export { sanitizeEntityBlocks } from './sanitizeEntityBlocks';

package/dist/plugins/Paste/sanitizers/removeComments.d.ts

@@ -0,0 +1,2 @@
+import { SanitizerTuple } from './helpers';
+export declare const removeComments: ([doc, editor]: SanitizerTuple) => SanitizerTuple;

package/dist/plugins/Paste/sanitizers/sanitizeEntityBlocks.d.ts

@@ -0,0 +1,6 @@
+import { SanitizerTuple } from './helpers';
+/**
+ * Ensures the text selection from entity block elements is
+ * not included in the paste buffer.
+ */
+export declare const sanitizeEntityBlocks: ([doc, editor]: SanitizerTuple) => SanitizerTuple;

package/dist/plugins/Paste/sanitizers/sanitizeTables.d.ts

@@ -0,0 +1,2 @@
+import { SanitizerTuple } from './helpers';
+export declare const sanitizeTables: ([doc, editor]: SanitizerTuple) => SanitizerTuple;

package/dist/plugins/Quote/index.d.ts

@@ -1,59 +1,13 @@
-declare var _default: {
-    new (props: any): {
-        handleToggle: (event: any) => any;
-        render(): JSX.Element;
-        context: any;
-        setState<K extends string | number | symbol>(state: any, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<any> & Readonly<{
-            children?: React.ReactNode;
-        }>;
-        state: Readonly<any>;
-        refs: {
-            [key: string]: React.ReactInstance;
-        };
-        componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): boolean;
-        componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<any>, prevState: Readonly<any>): any;
-        componentDidUpdate?(prevProps: Readonly<any>, prevState: Readonly<any>, snapshot?: any): void;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<any>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<any>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): void;
-    };
-    new (props: any, context: any): {
-        handleToggle: (event: any) => any;
-        render(): JSX.Element;
-        context: any;
-        setState<K extends string | number | symbol>(state: any, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<any> & Readonly<{
-            children?: React.ReactNode;
-        }>;
-        state: Readonly<any>;
-        refs: {
-            [key: string]: React.ReactInstance;
-        };
-        componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): boolean;
-        componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<any>, prevState: Readonly<any>): any;
-        componentDidUpdate?(prevProps: Readonly<any>, prevState: Readonly<any>, snapshot?: any): void;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<any>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<any>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): void;
-    };
-    propTypes: any;
-    contextType?: React.Context<any> | undefined;
-};
-export default _default;
-export { default as QuotePlugin } from "./QuotePlugin";
-import React from "react";
+import * as React from 'react';
+import * as Slate from 'slate-react';
+import { PlatePlugin, SPEditor } from '@udecode/plate-core';
+import { CustomSlatePluginOptions } from 'types';
+interface ToolbarQuoteButtonProps {
+    isDisabled?: boolean;
+}
+export declare function withQuoteEvents(editor: SPEditor): (event: React.KeyboardEvent) => void;
+export declare function ToolbarQuoteButton(props: ToolbarQuoteButtonProps): JSX.Element | null;
+export declare function Quote(props: Slate.RenderLeafProps): JSX.Element;
+export declare function createQuotePlugin(): PlatePlugin;
+export declare const withQuoteOptions: CustomSlatePluginOptions;
+export {};

package/dist/plugins/Table/TableActions.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+export declare const styles: {
+    topRight: string;
+};
+export declare const TableActions: () => JSX.Element;

package/dist/plugins/Table/actions/addColumn.d.ts

@@ -0,0 +1,4 @@
+import { SPEditor } from '@udecode/plate-core';
+import { TablePluginOptions } from '@udecode/plate-table';
+export declare const addColumnRight: (editor: SPEditor, options: TablePluginOptions) => void;
+export declare const addColumnLeft: (editor: SPEditor, options: TablePluginOptions) => void;

package/dist/plugins/Table/actions/addRow.d.ts

@@ -0,0 +1,3 @@
+import { SPEditor } from '@udecode/plate-core';
+export declare const addRowBelow: (editor: SPEditor) => void;
+export declare const addRowAbove: (editor: SPEditor) => void;

package/dist/plugins/Table/actions/index.d.ts

@@ -0,0 +1,3 @@
+export * from './addRow';
+export * from './addColumn';
+export * from './setHeader';

package/dist/plugins/Table/actions/setHeader.d.ts

@@ -0,0 +1,2 @@
+import { SPEditor } from '@udecode/plate-core';
+export declare const setHeader: (editor: SPEditor, enable?: boolean | undefined) => void;

package/dist/plugins/Table/helpers.d.ts

@@ -0,0 +1,4 @@
+import { SPEditor } from '@udecode/plate-core';
+export declare function insertTableAndFocusFirstCell(editor: SPEditor): void;
+export declare function isTableActive(editor: SPEditor): boolean;
+export declare function isTableHeaderEnabled(editor: SPEditor): boolean;

package/dist/plugins/Table/index.d.ts

@@ -0,0 +1,186 @@
+import * as React from 'react';
+import * as Slate from 'slate-react';
+import { SPEditor } from '@udecode/plate-core';
+import { CustomSlatePluginOptions } from '../../types';
+import { TrackingProvider } from '../../TrackingProvider';
+export declare const Table: (props: Slate.RenderElementProps) => JSX.Element;
+export declare const TR: (props: Slate.RenderElementProps) => JSX.Element;
+export declare const TH: (props: Slate.RenderElementProps) => JSX.Element;
+export declare const TD: (props: Slate.RenderElementProps) => JSX.Element;
+export declare const withTableOptions: CustomSlatePluginOptions;
+export declare const createTablePlugin: (tracking: TrackingProvider) => {
+    onKeyDown: (editor: SPEditor) => (event: React.KeyboardEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType;
+    withOverrides: (editor: any) => any;
+    decorate?: import("@udecode/plate-core").Decorate<SPEditor> | undefined;
+    deserialize?: import("@udecode/plate-core").Deserialize<SPEditor> | undefined;
+    inlineTypes?: ((editor: SPEditor) => string[]) | undefined;
+    onChange?: import("@udecode/plate-core").OnChange<SPEditor> | undefined;
+    pluginKeys?: string | string[] | undefined;
+    renderElement?: import("@udecode/plate-core").RenderElement<SPEditor> | undefined;
+    renderLeaf?: import("@udecode/plate-core").RenderLeaf<SPEditor> | undefined;
+    serialize?: import("@udecode/plate-core").Serialize | undefined;
+    voidTypes?: ((editor: SPEditor) => string[]) | undefined;
+    onCopy?: ((editor: SPEditor) => (event: React.ClipboardEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onCopyCapture?: ((editor: SPEditor) => (event: React.ClipboardEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onCut?: ((editor: SPEditor) => (event: React.ClipboardEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onCutCapture?: ((editor: SPEditor) => (event: React.ClipboardEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onPaste?: ((editor: SPEditor) => (event: React.ClipboardEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onPasteCapture?: ((editor: SPEditor) => (event: React.ClipboardEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onCompositionEnd?: ((editor: SPEditor) => (event: React.CompositionEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onCompositionEndCapture?: ((editor: SPEditor) => (event: React.CompositionEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onCompositionStart?: ((editor: SPEditor) => (event: React.CompositionEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onCompositionStartCapture?: ((editor: SPEditor) => (event: React.CompositionEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onCompositionUpdate?: ((editor: SPEditor) => (event: React.CompositionEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onCompositionUpdateCapture?: ((editor: SPEditor) => (event: React.CompositionEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onFocus?: ((editor: SPEditor) => (event: React.FocusEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onFocusCapture?: ((editor: SPEditor) => (event: React.FocusEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onBlur?: ((editor: SPEditor) => (event: React.FocusEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onBlurCapture?: ((editor: SPEditor) => (event: React.FocusEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onDOMBeforeInput?: ((editor: SPEditor) => (event: Event) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onBeforeInput?: ((editor: SPEditor) => (event: React.FormEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onBeforeInputCapture?: ((editor: SPEditor) => (event: React.FormEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onInput?: ((editor: SPEditor) => (event: React.FormEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onInputCapture?: ((editor: SPEditor) => (event: React.FormEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onReset?: ((editor: SPEditor) => (event: React.FormEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onResetCapture?: ((editor: SPEditor) => (event: React.FormEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onSubmit?: ((editor: SPEditor) => (event: React.FormEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onSubmitCapture?: ((editor: SPEditor) => (event: React.FormEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onInvalid?: ((editor: SPEditor) => (event: React.FormEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onInvalidCapture?: ((editor: SPEditor) => (event: React.FormEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onLoad?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onLoadCapture?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onError?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onErrorCapture?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onKeyDownCapture?: ((editor: SPEditor) => (event: React.KeyboardEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onKeyPress?: ((editor: SPEditor) => (event: React.KeyboardEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onKeyPressCapture?: ((editor: SPEditor) => (event: React.KeyboardEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onKeyUp?: ((editor: SPEditor) => (event: React.KeyboardEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onKeyUpCapture?: ((editor: SPEditor) => (event: React.KeyboardEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onAbort?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onAbortCapture?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onCanPlay?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onCanPlayCapture?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onCanPlayThrough?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onCanPlayThroughCapture?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onDurationChange?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onDurationChangeCapture?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onEmptied?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onEmptiedCapture?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onEncrypted?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onEncryptedCapture?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onEnded?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onEndedCapture?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onLoadedData?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onLoadedDataCapture?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onLoadedMetadata?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onLoadedMetadataCapture?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onLoadStart?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onLoadStartCapture?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onPause?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onPauseCapture?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onPlay?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onPlayCapture?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onPlaying?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onPlayingCapture?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onProgress?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onProgressCapture?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onRateChange?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onRateChangeCapture?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onSeeked?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onSeekedCapture?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onSeeking?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onSeekingCapture?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onStalled?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onStalledCapture?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onSuspend?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onSuspendCapture?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onTimeUpdate?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onTimeUpdateCapture?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onVolumeChange?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onVolumeChangeCapture?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onWaiting?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onWaitingCapture?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onAuxClick?: ((editor: SPEditor) => (event: React.MouseEvent<globalThis.Element, MouseEvent>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onAuxClickCapture?: ((editor: SPEditor) => (event: React.MouseEvent<globalThis.Element, MouseEvent>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onClick?: ((editor: SPEditor) => (event: React.MouseEvent<globalThis.Element, MouseEvent>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onClickCapture?: ((editor: SPEditor) => (event: React.MouseEvent<globalThis.Element, MouseEvent>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onContextMenu?: ((editor: SPEditor) => (event: React.MouseEvent<globalThis.Element, MouseEvent>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onContextMenuCapture?: ((editor: SPEditor) => (event: React.MouseEvent<globalThis.Element, MouseEvent>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onDoubleClick?: ((editor: SPEditor) => (event: React.MouseEvent<globalThis.Element, MouseEvent>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onDoubleClickCapture?: ((editor: SPEditor) => (event: React.MouseEvent<globalThis.Element, MouseEvent>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onDrag?: ((editor: SPEditor) => (event: React.DragEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onDragCapture?: ((editor: SPEditor) => (event: React.DragEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onDragEnd?: ((editor: SPEditor) => (event: React.DragEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onDragEndCapture?: ((editor: SPEditor) => (event: React.DragEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onDragEnter?: ((editor: SPEditor) => (event: React.DragEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onDragEnterCapture?: ((editor: SPEditor) => (event: React.DragEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onDragExit?: ((editor: SPEditor) => (event: React.DragEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onDragExitCapture?: ((editor: SPEditor) => (event: React.DragEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onDragLeave?: ((editor: SPEditor) => (event: React.DragEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onDragLeaveCapture?: ((editor: SPEditor) => (event: React.DragEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onDragOver?: ((editor: SPEditor) => (event: React.DragEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onDragOverCapture?: ((editor: SPEditor) => (event: React.DragEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onDragStart?: ((editor: SPEditor) => (event: React.DragEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onDragStartCapture?: ((editor: SPEditor) => (event: React.DragEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onDrop?: ((editor: SPEditor) => (event: React.DragEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onDropCapture?: ((editor: SPEditor) => (event: React.DragEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onMouseDown?: ((editor: SPEditor) => (event: React.MouseEvent<globalThis.Element, MouseEvent>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onMouseDownCapture?: ((editor: SPEditor) => (event: React.MouseEvent<globalThis.Element, MouseEvent>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onMouseEnter?: ((editor: SPEditor) => (event: React.MouseEvent<globalThis.Element, MouseEvent>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onMouseLeave?: ((editor: SPEditor) => (event: React.MouseEvent<globalThis.Element, MouseEvent>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onMouseMove?: ((editor: SPEditor) => (event: React.MouseEvent<globalThis.Element, MouseEvent>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onMouseMoveCapture?: ((editor: SPEditor) => (event: React.MouseEvent<globalThis.Element, MouseEvent>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onMouseOut?: ((editor: SPEditor) => (event: React.MouseEvent<globalThis.Element, MouseEvent>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onMouseOutCapture?: ((editor: SPEditor) => (event: React.MouseEvent<globalThis.Element, MouseEvent>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onMouseOver?: ((editor: SPEditor) => (event: React.MouseEvent<globalThis.Element, MouseEvent>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onMouseOverCapture?: ((editor: SPEditor) => (event: React.MouseEvent<globalThis.Element, MouseEvent>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onMouseUp?: ((editor: SPEditor) => (event: React.MouseEvent<globalThis.Element, MouseEvent>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onMouseUpCapture?: ((editor: SPEditor) => (event: React.MouseEvent<globalThis.Element, MouseEvent>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onSelect?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onSelectCapture?: ((editor: SPEditor) => (event: React.SyntheticEvent<globalThis.Element, Event>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onTouchCancel?: ((editor: SPEditor) => (event: React.TouchEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onTouchCancelCapture?: ((editor: SPEditor) => (event: React.TouchEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onTouchEnd?: ((editor: SPEditor) => (event: React.TouchEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onTouchEndCapture?: ((editor: SPEditor) => (event: React.TouchEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onTouchMove?: ((editor: SPEditor) => (event: React.TouchEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onTouchMoveCapture?: ((editor: SPEditor) => (event: React.TouchEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onTouchStart?: ((editor: SPEditor) => (event: React.TouchEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onTouchStartCapture?: ((editor: SPEditor) => (event: React.TouchEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onPointerDown?: ((editor: SPEditor) => (event: React.PointerEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onPointerDownCapture?: ((editor: SPEditor) => (event: React.PointerEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onPointerMove?: ((editor: SPEditor) => (event: React.PointerEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onPointerMoveCapture?: ((editor: SPEditor) => (event: React.PointerEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onPointerUp?: ((editor: SPEditor) => (event: React.PointerEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onPointerUpCapture?: ((editor: SPEditor) => (event: React.PointerEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onPointerCancel?: ((editor: SPEditor) => (event: React.PointerEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onPointerCancelCapture?: ((editor: SPEditor) => (event: React.PointerEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onPointerEnter?: ((editor: SPEditor) => (event: React.PointerEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onPointerEnterCapture?: ((editor: SPEditor) => (event: React.PointerEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onPointerLeave?: ((editor: SPEditor) => (event: React.PointerEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onPointerLeaveCapture?: ((editor: SPEditor) => (event: React.PointerEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onPointerOver?: ((editor: SPEditor) => (event: React.PointerEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onPointerOverCapture?: ((editor: SPEditor) => (event: React.PointerEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onPointerOut?: ((editor: SPEditor) => (event: React.PointerEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onPointerOutCapture?: ((editor: SPEditor) => (event: React.PointerEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onGotPointerCapture?: ((editor: SPEditor) => (event: React.PointerEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onGotPointerCaptureCapture?: ((editor: SPEditor) => (event: React.PointerEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onLostPointerCapture?: ((editor: SPEditor) => (event: React.PointerEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onLostPointerCaptureCapture?: ((editor: SPEditor) => (event: React.PointerEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onScroll?: ((editor: SPEditor) => (event: React.UIEvent<globalThis.Element, UIEvent>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onScrollCapture?: ((editor: SPEditor) => (event: React.UIEvent<globalThis.Element, UIEvent>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onWheel?: ((editor: SPEditor) => (event: React.WheelEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onWheelCapture?: ((editor: SPEditor) => (event: React.WheelEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onAnimationStart?: ((editor: SPEditor) => (event: React.AnimationEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onAnimationStartCapture?: ((editor: SPEditor) => (event: React.AnimationEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onAnimationEnd?: ((editor: SPEditor) => (event: React.AnimationEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onAnimationEndCapture?: ((editor: SPEditor) => (event: React.AnimationEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onAnimationIteration?: ((editor: SPEditor) => (event: React.AnimationEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onAnimationIterationCapture?: ((editor: SPEditor) => (event: React.AnimationEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onTransitionEnd?: ((editor: SPEditor) => (event: React.TransitionEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+    onTransitionEndCapture?: ((editor: SPEditor) => (event: React.TransitionEvent<globalThis.Element>) => import("@udecode/plate-core").HandlerReturnType) | undefined;
+};
+interface ToolbarTableButtonProps {
+    isDisabled: boolean | undefined;
+}
+export declare function ToolbarTableButton(props: ToolbarTableButtonProps): JSX.Element | null;
+export {};

package/dist/plugins/TrailingParagraph/index.d.ts

@@ -0,0 +1 @@
+export declare const createTrailingParagraphPlugin: () => import("@udecode/plate-core").PlatePlugin<import("@udecode/plate-core").SPEditor>;

package/dist/plugins/Underline/index.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import * as Slate from 'slate-react';
+import { PlatePlugin } from '@udecode/plate-core';
+import { CustomSlatePluginOptions } from 'types';
+interface ToolbarUnderlineButtonProps {
+    isDisabled?: boolean;
+}
+export declare function ToolbarUnderlineButton(props: ToolbarUnderlineButtonProps): JSX.Element | null;
+export declare function Underline(props: Slate.RenderLeafProps): JSX.Element;
+export declare function createUnderlinePlugin(): PlatePlugin;
+export declare const withUnderlineOptions: CustomSlatePluginOptions;
+export {};

package/dist/plugins/shared/EntityStatusIcon.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { Entry, Asset } from '@contentful/field-editor-shared';
+interface EntityStatusIconProps {
+    entity: Entry | Asset;
+    entityType: 'Entry' | 'Asset';
+}
+export declare function EntityStatusIcon({ entity, entityType }: EntityStatusIconProps): JSX.Element;
+export {};

package/dist/plugins/shared/FetchingWrappedAssetCard.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="react" />
+import { FieldExtensionSDK } from '@contentful/app-sdk';
+import { File } from '@contentful/field-editor-shared';
+interface FetchingWrappedAssetCardProps {
+    assetId: string;
+    isDisabled: boolean;
+    isSelected: boolean;
+    locale: string;
+    onEdit?: () => void;
+    onRemove?: () => unknown;
+    sdk: FieldExtensionSDK;
+}
+export declare function renderAssetInfo(props: {
+    entityFile: File;
+}): ("" | JSX.Element)[];
+export declare function renderActions(props: {
+    onEdit?: () => void;
+    onRemove?: () => void;
+    isDisabled: boolean;
+    entityFile?: File;
+}): (JSX.Element | null)[];
+export declare function FetchingWrappedAssetCard(props: FetchingWrappedAssetCardProps): JSX.Element;
+export {};

package/dist/plugins/shared/FetchingWrappedEntryCard.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import { FieldExtensionSDK } from '@contentful/app-sdk';
+interface FetchingWrappedEntryCardProps {
+    entryId: string;
+    isDisabled: boolean;
+    isSelected: boolean;
+    locale: string;
+    sdk: FieldExtensionSDK;
+    onEdit?: () => void;
+    onRemove?: () => void;
+}
+export declare function FetchingWrappedEntryCard(props: FetchingWrappedEntryCardProps): JSX.Element;
+export {};

package/dist/plugins/shared/ToolbarButton.d.ts

@@ -0,0 +1,15 @@
+import React, { Component } from 'react';
+interface ToolbarButtonProps {
+    onClick: React.MouseEventHandler;
+    isActive?: boolean;
+    isDisabled?: boolean;
+    children: any;
+    title: string;
+    className?: string;
+    testId?: string;
+}
+export declare class ToolbarButton extends Component<ToolbarButtonProps> {
+    handleClick: (event: any) => void;
+    render(): JSX.Element;
+}
+export {};

package/dist/types.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="react" />
+import { PlatePluginOptions } from '@udecode/plate-core';
+import { RenderElementProps, RenderLeafProps } from 'slate-react';
+export declare type TextElement = {
+    text: string;
+};
+export declare type TextOrCustomElement = CustomElement | TextElement;
+export declare type CustomElement<T = unknown> = {
+    type: string;
+    children: TextOrCustomElement[];
+    data: T;
+    isVoid?: boolean;
+};
+export declare type CustomRenderElementProps<T = any, O = any> = Omit<RenderElementProps, 'element'> & {
+    element: CustomElement<T>;
+} & O;
+export interface CustomPluginOptions extends Omit<PlatePluginOptions, 'component'> {
+    component?: React.FunctionComponent<CustomRenderElementProps> | React.FunctionComponent<RenderLeafProps>;
+}
+export declare type CustomSlatePluginOptions = Record<string, CustomPluginOptions>;
+declare module 'slate' {
+    interface CustomTypes {
+        Element: CustomElement;
+    }
+}