@atlaskit/renderer 108.15.10 → 108.15.12

package/dist/types-ts4.5/react/marks/em.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { MarkProps } from '../types';
+export default function Em(props: MarkProps): JSX.Element;

package/dist/types-ts4.5/react/marks/fragment.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { FragmentAttributes } from '@atlaskit/adf-schema';
+import { MarkProps } from '../types';
+export default function FragmentMark(props: MarkProps<FragmentAttributes>): JSX.Element;

package/dist/types-ts4.5/react/marks/indentation.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { IndentationMarkAttributes } from '@atlaskit/adf-schema';
+import { MarkProps } from '../types';
+export default function Indentation(props: MarkProps<IndentationMarkAttributes>): JSX.Element;

package/dist/types-ts4.5/react/marks/index.d.ts

@@ -0,0 +1,21 @@
+import { ComponentType } from 'react';
+import { Mark } from '@atlaskit/editor-prosemirror/model';
+import Code from './code';
+import Em from './em';
+import Link from './link';
+import Strike from './strike';
+import Strong from './strong';
+import Subsup from './subsup';
+import TextColor from './textColor';
+import Underline from './underline';
+import Breakout from './breakout';
+import UnsupportedMark from './unsupportedMark';
+import UnsupportedNodeAttribute from './unsupportedNodeAttribute';
+import DataConsumer from './data-consumer';
+import FragmentMark from './fragment';
+import Annotation, { isAnnotationMark } from './annotation';
+export declare const markToReact: {
+    [key: string]: ComponentType<any>;
+};
+export declare const toReact: (mark: Mark) => ComponentType<any>;
+export { Code, Em, Link, Strike, Strong, Subsup, TextColor, Underline, Breakout, Annotation, UnsupportedMark, isAnnotationMark, UnsupportedNodeAttribute, DataConsumer, FragmentMark, };

package/dist/types-ts4.5/react/marks/link.d.ts

@@ -0,0 +1,9 @@
+import { jsx } from '@emotion/react';
+import { LinkAttributes } from '@atlaskit/adf-schema';
+import { MarkProps } from '../types';
+interface LinkProps extends LinkAttributes {
+    target?: string;
+    isMediaLink?: boolean;
+}
+export default function Link(props: MarkProps<LinkProps>): jsx.JSX.Element;
+export {};

package/dist/types-ts4.5/react/marks/strike.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { MarkProps } from '../types';
+export default function Strike(props: MarkProps): JSX.Element;

package/dist/types-ts4.5/react/marks/strong.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { MarkProps } from '../types';
+export default function Strong(props: MarkProps): JSX.Element;

package/dist/types-ts4.5/react/marks/subsup.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { SubSupAttributes } from '@atlaskit/adf-schema';
+import { MarkProps } from '../types';
+export default function SubSup(props: MarkProps<SubSupAttributes>): JSX.Element;

package/dist/types-ts4.5/react/marks/textColor.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { TextColorAttributes } from '@atlaskit/adf-schema';
+import { MarkProps } from '../types';
+export default function TextColor(props: MarkProps<TextColorAttributes>): JSX.Element;

package/dist/types-ts4.5/react/marks/underline.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { MarkProps } from '../types';
+export default function Underline(props: MarkProps): JSX.Element;

package/dist/types-ts4.5/react/marks/unsupportedMark.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { MarkProps } from '../types';
+export default function UnsupportedMark(props: MarkProps): JSX.Element;

package/dist/types-ts4.5/react/marks/unsupportedNodeAttribute.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { MarkProps } from '../types';
+export default function UnsupportedNodeAttribute(props: MarkProps): JSX.Element;

package/dist/types-ts4.5/react/nodes/blockCard.d.ts

@@ -0,0 +1,15 @@
+import { jsx } from '@emotion/react';
+import type { EventHandlers } from '@atlaskit/editor-common/ui';
+import type { RendererAppearance } from '../../ui/Renderer/types';
+import type { SmartLinksOptions } from '../../types/smartLinksOptions';
+import type { DatasourceAttributeProperties } from '@atlaskit/adf-schema/schema';
+export default function BlockCard(props: {
+    url?: string;
+    data?: object;
+    eventHandlers?: EventHandlers;
+    datasource?: DatasourceAttributeProperties;
+    portal?: HTMLElement;
+    rendererAppearance?: RendererAppearance;
+    smartLinks?: SmartLinksOptions;
+    layout?: string;
+}): jsx.JSX.Element;

package/dist/types-ts4.5/react/nodes/blockquote.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export default function Blockquote(props: React.Props<any>): JSX.Element;

package/dist/types-ts4.5/react/nodes/bodiedExtension.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import type { Mark as PMMark, Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { RendererContext } from '../types';
+import type { Serializer } from '../..';
+import type { ExtensionLayout } from '@atlaskit/adf-schema';
+import type { ExtensionHandlers } from '@atlaskit/editor-common/extensions';
+import type { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+export interface Props {
+    serializer: Serializer<any>;
+    extensionHandlers?: ExtensionHandlers;
+    rendererContext: RendererContext;
+    providers: ProviderFactory;
+    extensionType: string;
+    extensionKey: string;
+    path?: PMNode[];
+    originalContent?: any;
+    parameters?: any;
+    content?: any;
+    layout?: ExtensionLayout;
+    localId?: string;
+    marks?: PMMark[];
+}
+declare const BodiedExtension: React.FunctionComponent<Props>;
+export default BodiedExtension;

package/dist/types-ts4.5/react/nodes/bulletList.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { Node } from '@atlaskit/editor-prosemirror/model';
+export default function BulletList(props: {
+    path?: Node[];
+} & React.Props<any>): JSX.Element;

package/dist/types-ts4.5/react/nodes/caption.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { NodeProps } from '../types';
+declare const RenderCaption: ({ children, dataAttributes }: NodeProps) => JSX.Element;
+export default RenderCaption;

package/dist/types-ts4.5/react/nodes/codeBlock/codeBlock.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+import { WrappedComponentProps } from 'react-intl-next';
+import type { SupportedLanguages } from '@atlaskit/code';
+export interface Props {
+    text: string;
+    language: SupportedLanguages;
+    allowCopyToClipboard?: boolean;
+    allowWrapCodeBlock?: boolean;
+    codeBidiWarningTooltipEnabled: boolean;
+    className?: string;
+}
+declare const _default: import("react").FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: import("react").ComponentType<Props & WrappedComponentProps<"intl">>;
+};
+export default _default;

package/dist/types-ts4.5/react/nodes/codeBlock/components/codeBlockButtonContainer.d.ts

@@ -0,0 +1,12 @@
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+import type { Dispatch, SetStateAction } from 'react';
+export interface CodeBlockButtonContainerProps {
+    allowCopyToClipboard?: boolean;
+    allowWrapCodeBlock?: boolean;
+    setWrapLongLines: Dispatch<SetStateAction<boolean>>;
+    text: string;
+    wrapLongLines: boolean;
+}
+declare const CodeBlockButtonContainer: ({ allowCopyToClipboard, allowWrapCodeBlock, setWrapLongLines, text, wrapLongLines, }: CodeBlockButtonContainerProps) => jsx.JSX.Element;
+export default CodeBlockButtonContainer;

package/dist/types-ts4.5/react/nodes/codeBlock/components/codeBlockContainer.d.ts

@@ -0,0 +1,10 @@
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+import type { ReactNode } from 'react';
+import type { CodeBlockButtonContainerProps } from './codeBlockButtonContainer';
+interface ContainerProps extends CodeBlockButtonContainerProps {
+    children: ReactNode;
+    className?: string;
+}
+declare const CodeBlockContainer: ({ allowCopyToClipboard, allowWrapCodeBlock, children, className, setWrapLongLines, text, wrapLongLines, }: ContainerProps) => jsx.JSX.Element;
+export default CodeBlockContainer;

package/dist/types-ts4.5/react/nodes/codeBlock/components/codeBlockCopyButton.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { WrappedComponentProps } from 'react-intl-next';
+type Props = {
+    content: string;
+};
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<Props & WrappedComponentProps<"intl">>;
+};
+export default _default;

package/dist/types-ts4.5/react/nodes/codeBlock/components/codeBlockWrapButton.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { Dispatch, SetStateAction } from 'react';
+import { WrappedComponentProps } from 'react-intl-next';
+type Props = {
+    setWrapLongLines: Dispatch<SetStateAction<boolean>>;
+    wrapLongLines?: boolean;
+};
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<Props & WrappedComponentProps<"intl">>;
+};
+export default _default;

package/dist/types-ts4.5/react/nodes/codeBlock/components/lightWeightCodeBlock.d.ts

@@ -0,0 +1,9 @@
+/** @jsx jsx */
+import React from 'react';
+import type { Props as CodeBlockProps } from '../codeBlock';
+export declare const LightWeightCodeBlockCssClassName: {
+    CONTAINER: string;
+};
+export declare const getLightWeightCodeBlockStylesForRootRendererStyleSheet: () => import("@emotion/react").SerializedStyles;
+declare const LightWeightCodeBlock: React.ForwardRefExoticComponent<Pick<CodeBlockProps, "text" | "className" | "codeBidiWarningTooltipEnabled"> & React.RefAttributes<HTMLDivElement>>;
+export default LightWeightCodeBlock;

package/dist/types-ts4.5/react/nodes/codeBlock/windowedCodeBlock.d.ts

@@ -0,0 +1,4 @@
+import { jsx } from '@emotion/react';
+import type { Props as CodeBlockProps } from './codeBlock';
+declare const WindowedCodeBlock: ({ text, language, allowCopyToClipboard, allowWrapCodeBlock, codeBidiWarningTooltipEnabled, className: rootClassName, }: CodeBlockProps) => jsx.JSX.Element;
+export default WindowedCodeBlock;

package/dist/types-ts4.5/react/nodes/date.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { WrappedComponentProps } from 'react-intl-next';
+export interface Props {
+    timestamp: string;
+    parentIsIncompleteTask?: boolean;
+}
+export declare const DateComponent: React.FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<Props & WrappedComponentProps<"intl">>;
+};
+declare function DateWithFormatContext(props: Props): JSX.Element;
+export default DateWithFormatContext;

package/dist/types-ts4.5/react/nodes/decisionItem.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { NodeProps } from '../types';
+export default function DecisionItem({ children, dataAttributes }: NodeProps): JSX.Element;

package/dist/types-ts4.5/react/nodes/decisionList.d.ts

@@ -0,0 +1,7 @@
+import { PureComponent } from 'react';
+export interface Props {
+    children?: JSX.Element | JSX.Element[];
+}
+export default class DecisionList extends PureComponent<Props, {}> {
+    render(): JSX.Element | null;
+}

package/dist/types-ts4.5/react/nodes/doc.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+export default function Doc(props: any): JSX.Element;
+export declare function DocWithSelectAllTrap(props: any): JSX.Element;

package/dist/types-ts4.5/react/nodes/embedCard.d.ts

@@ -0,0 +1,19 @@
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+import type { SmartLinksOptions } from '../../types/smartLinksOptions';
+import type { EventHandlers } from '@atlaskit/editor-common/ui';
+import type { RichMediaLayout } from '@atlaskit/adf-schema';
+import type { RendererAppearance } from '../../ui/Renderer/types';
+export default function EmbedCard(props: {
+    url?: string;
+    data?: object;
+    eventHandlers?: EventHandlers;
+    portal?: HTMLElement;
+    originalHeight?: number;
+    originalWidth?: number;
+    width?: number;
+    layout: RichMediaLayout;
+    rendererAppearance?: RendererAppearance;
+    isInsideOfBlockNode?: boolean;
+    smartLinks?: SmartLinksOptions;
+}): jsx.JSX.Element;

package/dist/types-ts4.5/react/nodes/emoji.d.ts

@@ -0,0 +1,12 @@
+import { EmojiAttributes } from '@atlaskit/adf-schema';
+import { EmojiResourceConfig } from '@atlaskit/emoji/resource';
+import { PureComponent } from 'react';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+export interface EmojiProps extends EmojiAttributes {
+    providers?: ProviderFactory;
+    resourceConfig?: EmojiResourceConfig;
+    fitToHeight?: number;
+}
+export default class EmojiItem extends PureComponent<EmojiProps, {}> {
+    render(): JSX.Element;
+}

package/dist/types-ts4.5/react/nodes/extension.d.ts

@@ -0,0 +1,113 @@
+import React from 'react';
+import { Mark as PMMark, Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import { RendererContext } from '../types';
+import { ExtensionLayout } from '@atlaskit/adf-schema';
+import type { ExtensionHandlers } from '@atlaskit/editor-common/extensions';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import type { OverflowShadowProps } from '@atlaskit/editor-common/ui';
+export interface Props {
+    extensionHandlers?: ExtensionHandlers;
+    providers: ProviderFactory;
+    rendererContext: RendererContext;
+    extensionType: string;
+    extensionKey: string;
+    path?: PMNode[];
+    text?: string;
+    parameters?: any;
+    layout?: ExtensionLayout;
+    localId?: string;
+    marks?: PMMark[];
+}
+type AllOrNone<T> = T | {
+    [K in keyof T]?: never;
+};
+type RenderExtensionOptions = {
+    isTopLevel?: boolean;
+} & AllOrNone<OverflowShadowProps>;
+export declare const renderExtension: (content: any, layout: string, options?: RenderExtensionOptions, removeOverflow?: boolean) => JSX.Element;
+declare const _default: {
+    new (props: Props | Readonly<Props>): {
+        overflowContainer?: HTMLElement | null | undefined;
+        container?: HTMLElement | undefined;
+        shadowObserver?: import("@atlaskit/editor-common/ui").ShadowObserver | undefined;
+        overflowContainerWidth: number;
+        scrollable?: NodeList | undefined;
+        diff?: number | undefined;
+        state: {
+            showLeftShadow: boolean;
+            showRightShadow: boolean;
+        };
+        componentWillUnmount(): void;
+        componentDidUpdate(): void;
+        handleScroll: (event: Event) => void;
+        updateShadows: () => void;
+        showLeftShadow: (overflowContainer: HTMLElement | null | undefined) => boolean;
+        calcOverflowDiff: () => number;
+        calcScrollableWidth: () => number;
+        handleContainer: (container: HTMLElement | null) => void;
+        initShadowObserver(): void;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends keyof import("@atlaskit/editor-common/ui").OverflowShadowState>(state: import("@atlaskit/editor-common/ui").OverflowShadowState | ((prevState: Readonly<import("@atlaskit/editor-common/ui").OverflowShadowState>, props: Readonly<Props>) => import("@atlaskit/editor-common/ui").OverflowShadowState | Pick<import("@atlaskit/editor-common/ui").OverflowShadowState, K> | null) | Pick<import("@atlaskit/editor-common/ui").OverflowShadowState, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<Props> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<Props>, nextState: Readonly<import("@atlaskit/editor-common/ui").OverflowShadowState>, nextContext: any): boolean;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Props>, prevState: Readonly<import("@atlaskit/editor-common/ui").OverflowShadowState>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Props>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Props>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Props>, nextState: Readonly<import("@atlaskit/editor-common/ui").OverflowShadowState>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Props>, nextState: Readonly<import("@atlaskit/editor-common/ui").OverflowShadowState>, nextContext: any): void;
+    };
+    new (props: Props, context: any): {
+        overflowContainer?: HTMLElement | null | undefined;
+        container?: HTMLElement | undefined;
+        shadowObserver?: import("@atlaskit/editor-common/ui").ShadowObserver | undefined;
+        overflowContainerWidth: number;
+        scrollable?: NodeList | undefined;
+        diff?: number | undefined;
+        state: {
+            showLeftShadow: boolean;
+            showRightShadow: boolean;
+        };
+        componentWillUnmount(): void;
+        componentDidUpdate(): void;
+        handleScroll: (event: Event) => void;
+        updateShadows: () => void;
+        showLeftShadow: (overflowContainer: HTMLElement | null | undefined) => boolean;
+        calcOverflowDiff: () => number;
+        calcScrollableWidth: () => number;
+        handleContainer: (container: HTMLElement | null) => void;
+        initShadowObserver(): void;
+        render(): JSX.Element;
+        context: any;
+        setState<K_1 extends keyof import("@atlaskit/editor-common/ui").OverflowShadowState>(state: import("@atlaskit/editor-common/ui").OverflowShadowState | ((prevState: Readonly<import("@atlaskit/editor-common/ui").OverflowShadowState>, props: Readonly<Props>) => import("@atlaskit/editor-common/ui").OverflowShadowState | Pick<import("@atlaskit/editor-common/ui").OverflowShadowState, K_1> | null) | Pick<import("@atlaskit/editor-common/ui").OverflowShadowState, K_1> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<Props> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<Props>, nextState: Readonly<import("@atlaskit/editor-common/ui").OverflowShadowState>, nextContext: any): boolean;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Props>, prevState: Readonly<import("@atlaskit/editor-common/ui").OverflowShadowState>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Props>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Props>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Props>, nextState: Readonly<import("@atlaskit/editor-common/ui").OverflowShadowState>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Props>, nextState: Readonly<import("@atlaskit/editor-common/ui").OverflowShadowState>, nextContext: any): void;
+    };
+    contextType?: React.Context<any> | undefined;
+};
+export default _default;

package/dist/types-ts4.5/react/nodes/fallback.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+export type CardErrorBoundaryProps = {
+    unsupportedComponent: React.ComponentType;
+};
+export declare class CardErrorBoundary extends React.PureComponent<{
+    url?: string;
+    onClick?: (e: React.MouseEvent<HTMLElement>, url?: string) => void;
+    isDatasource?: boolean;
+} & CardErrorBoundaryProps> {
+    state: {
+        isError: boolean;
+    };
+    onClickFallback: (e: React.MouseEvent<HTMLElement>) => void;
+    static getDerivedStateFromError(): {
+        isError: boolean;
+    };
+    render(): React.ReactNode;
+    componentDidCatch(_error: Error): void;
+}

package/dist/types-ts4.5/react/nodes/hardBreak.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface Props {
+    forceNewLine?: boolean;
+}
+declare const HardBreak: React.FunctionComponent<Props>;
+export default HardBreak;

package/dist/types-ts4.5/react/nodes/heading-anchor.d.ts

@@ -0,0 +1,14 @@
+/** @jsx jsx */
+import React from 'react';
+import { WrappedComponentProps } from 'react-intl-next';
+export declare const HeadingAnchorWrapperClassName = "heading-anchor-wrapper";
+type Props = {
+    onCopyText: () => Promise<void>;
+    enableNestedHeaderLinks?: boolean;
+    level: number;
+};
+type HeadingAnchorProps = Props & React.Props<any> & WrappedComponentProps;
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<HeadingAnchorProps>> & {
+    WrappedComponent: React.ComponentType<HeadingAnchorProps>;
+};
+export default _default;

package/dist/types-ts4.5/react/nodes/heading.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+import { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import { NodeProps } from '../types';
+import { HeadingAnchorLinksProps } from '../../ui/Renderer/types';
+export type HeadingLevels = 1 | 2 | 3 | 4 | 5 | 6;
+declare function Heading(props: NodeProps<{
+    level: HeadingLevels;
+    headingId?: string;
+    showAnchorLink?: boolean;
+    allowHeadingAnchorLinks?: HeadingAnchorLinksProps;
+    marks?: PMNode['marks'];
+    invisible?: boolean;
+}>): JSX.Element;
+export default Heading;

package/dist/types-ts4.5/react/nodes/index.d.ts

@@ -0,0 +1,98 @@
+import React from 'react';
+import Loadable from 'react-loadable';
+import { Fragment, Node, Mark } from '@atlaskit/editor-prosemirror/model';
+import Blockquote from './blockquote';
+import BodiedExtension, { Props as BodiedExtensionProps } from './bodiedExtension';
+import BulletList from './bulletList';
+import Doc, { DocWithSelectAllTrap } from './doc';
+import Extension, { Props as ExtensionProps } from './extension';
+import HardBreak from './hardBreak';
+import Heading from './heading';
+import InlineExtension, { Props as InlineExtensionProps } from './inlineExtension';
+import LayoutSection from './layoutSection';
+import LayoutColumn from './layoutColumn';
+import ListItem from './listItem';
+import Caption from './caption';
+import OrderedList from './orderedList';
+import Paragraph from './paragraph';
+import Placeholder from './placeholder';
+import Rule from './rule';
+import Table from './table';
+import { TableCell } from './tableCell';
+import TableRow from './tableRow';
+import UnknownBlock from './unknownBlock';
+import { NodeComponentsProps } from '../../ui/Renderer/types';
+declare const WindowedCodeBlock: React.ComponentType<import("./codeBlock/codeBlock").Props> & Loadable.LoadableComponent;
+declare const CodeBlock: React.ComponentType<import("react-intl-next").WithIntlProps<import("./codeBlock/codeBlock").Props & import("react-intl-next").WrappedComponentProps<"intl">>> & Loadable.LoadableComponent;
+declare const TaskList: React.ComponentType<import("./taskList").Props> & Loadable.LoadableComponent;
+declare const TaskItem: React.ComponentType<import("../types").NodeProps<import("./taskItem").Props>> & Loadable.LoadableComponent;
+declare const DecisionList: React.ComponentType<import("./decisionList").Props> & Loadable.LoadableComponent;
+declare const DecisionItem: React.ComponentType<import("../types").NodeMeta> & Loadable.LoadableComponent;
+declare const Date: React.ComponentType<import("./date").Props> & Loadable.LoadableComponent;
+declare const Status: React.ComponentType<import("./status").Props> & Loadable.LoadableComponent;
+declare const Emoji: React.ComponentType<import("./emoji").EmojiProps> & Loadable.LoadableComponent;
+declare const Panel: React.ComponentType<import("./panel").Props> & Loadable.LoadableComponent;
+declare const EmbedCard: React.ComponentType<{
+    url?: string | undefined;
+    data?: object | undefined;
+    eventHandlers?: import("@atlaskit/editor-common/ui").EventHandlers | undefined;
+    portal?: HTMLElement | undefined;
+    originalHeight?: number | undefined;
+    originalWidth?: number | undefined;
+    width?: number | undefined;
+    layout: import("@atlaskit/adf-schema").RichMediaLayout;
+    rendererAppearance?: import("../../ui/Renderer/types").RendererAppearance;
+    isInsideOfBlockNode?: boolean | undefined;
+    smartLinks?: import("../../types/smartLinksOptions").SmartLinksOptions | undefined;
+}> & Loadable.LoadableComponent;
+declare const InlineCard: React.ComponentType<import("@atlaskit/editor-common/utils").Diff<import("./inlineCard").InlineCardProps & import("../../ui/SmartCardStorage").WithSmartCardStorageProps, import("../../ui/SmartCardStorage").WithSmartCardStorageProps>> & Loadable.LoadableComponent;
+declare const BlockCard: React.ComponentType<{
+    url?: string | undefined;
+    data?: object | undefined;
+    eventHandlers?: import("@atlaskit/editor-common/ui").EventHandlers | undefined;
+    datasource?: import("@atlaskit/adf-schema").DatasourceAttributeProperties | undefined;
+    portal?: HTMLElement | undefined;
+    rendererAppearance?: import("../../ui/Renderer/types").RendererAppearance;
+    smartLinks?: import("../../types/smartLinksOptions").SmartLinksOptions | undefined;
+    layout?: string | undefined;
+}> & Loadable.LoadableComponent;
+declare const Media: React.ComponentType<import("./media").MediaProps> & Loadable.LoadableComponent;
+declare const MediaGroup: React.ComponentType<import("./mediaGroup").MediaGroupProps> & Loadable.LoadableComponent;
+declare const MediaInline: React.ComponentType<import("react-intl-next").WithIntlProps<import("./mediaInline").MediaInlineProps & import("react-intl-next").WrappedComponentProps<"intl">>> & Loadable.LoadableComponent;
+declare const MediaSingle: React.ComponentType<import("react-intl-next").WithIntlProps<import("./mediaSingle").Props & import("react-intl-next").WrappedComponentProps<"intl">>> & Loadable.LoadableComponent;
+declare const Mention: React.ComponentType<import("./mention").Props> & Loadable.LoadableComponent;
+declare const Expand: React.ComponentType<import("react-intl-next").WithIntlProps<import("../../ui/Expand").ExpandProps & import("react-intl-next").WrappedComponentProps<"intl">>> & Loadable.LoadableComponent;
+export declare const nodeToReact: {
+    [key: string]: React.ComponentType<any>;
+};
+export interface ToReactFlags {
+    allowSelectAllTrap?: boolean;
+    allowWindowedCodeBlock?: boolean;
+}
+export declare const toReact: (node: Node, flags?: ToReactFlags, nodeComponents?: NodeComponentsProps) => React.ComponentType<any>;
+export interface TextWrapper {
+    type: {
+        name: 'textWrapper';
+    };
+    content: Node[];
+    nodeSize: number;
+}
+export interface NodeSimple {
+    type: {
+        name: string;
+    };
+    attrs?: any;
+    text?: string;
+    nodeSize: number;
+}
+export declare const mergeTextNodes: (nodes: (Node | NodeSimple)[]) => (Node | TextWrapper | NodeSimple)[];
+export declare const isText: (type: string) => type is "text";
+export declare const isTextWrapper: (node: Node | TextWrapper | NodeSimple) => node is TextWrapper;
+export declare function isTextNode(node: Node | Mark): node is Node;
+/**
+ * Detects whether a fragment contains a single paragraph node
+ * whose content satisfies the condition for an emoji block
+ */
+export declare const isEmojiDoc: (doc: Fragment) => boolean;
+export { Blockquote, BodiedExtension, BulletList, BlockCard, Caption, CodeBlock, WindowedCodeBlock, Date, DecisionItem, DecisionList, Doc, DocWithSelectAllTrap, Emoji, Extension, Expand, HardBreak, Heading, ListItem, InlineCard, InlineExtension, LayoutSection, LayoutColumn, Media, MediaGroup, MediaInline, MediaSingle, Mention, OrderedList, Panel, Paragraph, Placeholder, Rule, Status, TaskItem, TaskList, Table, TableCell, TableRow, UnknownBlock, EmbedCard, };
+export type { BodiedExtensionProps, ExtensionProps, InlineExtensionProps };

package/dist/types-ts4.5/react/nodes/inline.d.ts

@@ -0,0 +1 @@
+export default function Inline(props: any): any;