@atlaskit/renderer 101.1.0 → 102.0.0

package/dist/types-ts4.0/react/nodes/layoutSection.d.ts

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

package/dist/types-ts4.0/react/nodes/listItem.d.ts

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

package/dist/types-ts4.0/react/nodes/media.d.ts

@@ -0,0 +1,27 @@
+/** @jsx jsx */
+import React from 'react';
+import { PureComponent } from 'react';
+import { jsx } from '@emotion/react';
+import type { EventHandlers } from '@atlaskit/editor-common/ui';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import { MediaCardProps } from '../../ui/MediaCard';
+import { LinkDefinition } from '@atlaskit/adf-schema';
+import type { MediaFeatureFlags } from '@atlaskit/media-common';
+import { AnalyticsEventPayload } from '../../analytics/events';
+export declare type MediaProps = MediaCardProps & {
+    providers?: ProviderFactory;
+    allowAltTextOnImages?: boolean;
+    children?: React.ReactNode;
+    isInsideOfBlockNode?: boolean;
+    marks: Array<LinkDefinition>;
+    isLinkMark: () => boolean;
+    fireAnalyticsEvent?: (event: AnalyticsEventPayload) => void;
+    featureFlags?: MediaFeatureFlags;
+    eventHandlers?: EventHandlers;
+    enableDownloadButton?: boolean;
+};
+export default class Media extends PureComponent<MediaProps, {}> {
+    private renderCard;
+    private handleMediaLinkClick;
+    render(): jsx.JSX.Element;
+}

package/dist/types-ts4.0/react/nodes/mediaGroup.d.ts

@@ -0,0 +1,29 @@
+import React from 'react';
+import { ReactElement, PureComponent } from 'react';
+import { CardEvent } from '@atlaskit/media-card';
+import type { EventHandlers, CardEventClickHandler } from '@atlaskit/editor-common/ui';
+import { Identifier } from '@atlaskit/media-client';
+import { MediaProps } from './media';
+import { MediaFeatureFlags } from '@atlaskit/media-common';
+export interface MediaGroupProps {
+    children?: React.ReactNode;
+    eventHandlers?: EventHandlers;
+    featureFlags?: MediaFeatureFlags;
+    enableDownloadButton?: boolean;
+}
+export interface MediaGroupState {
+    animate: boolean;
+    offset: number;
+}
+export default class MediaGroup extends PureComponent<MediaGroupProps, MediaGroupState> {
+    state: MediaGroupState;
+    private handleSize;
+    private handleScroll;
+    render(): JSX.Element;
+    renderSingleFile(child: ReactElement<MediaProps>): React.ReactElement<MediaProps, string | React.JSXElementConstructor<any>>;
+    renderSingleLink(child: ReactElement<MediaProps>): React.ReactElement<MediaProps, string | React.JSXElementConstructor<any>>;
+    onMediaClick: (cardClickHandler: CardEventClickHandler, child: ReactElement<MediaProps>, surroundingItems: Identifier[]) => (event: CardEvent, analyticsEvent?: any) => void;
+    cloneFileCard(child: ReactElement<MediaProps>, surroundingItems: Identifier[]): React.ReactElement<MediaProps, string | React.JSXElementConstructor<any>>;
+    renderStrip(): JSX.Element;
+    private mapMediaPropsToIdentifier;
+}

package/dist/types-ts4.0/react/nodes/mediaInline.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import { FileIdentifier } from '@atlaskit/media-client';
+import { MediaProvider } from '../../ui/MediaCard';
+import { WrappedComponentProps } from 'react-intl-next';
+export declare type RenderMediaInlineProps = {
+    identifier: FileIdentifier;
+    mediaProvider: Promise<MediaProvider>;
+    children?: React.ReactNode;
+};
+export declare type MediaInlineProps = {
+    id: string;
+    collection?: string;
+    providers: ProviderFactory;
+};
+export declare const RenderMediaInline: React.FC<RenderMediaInlineProps>;
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<MediaInlineProps & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<MediaInlineProps & WrappedComponentProps<"intl">>;
+};
+export default _default;

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

@@ -0,0 +1,23 @@
+/** @jsx jsx */
+import { default as React } from 'react';
+import { WrappedComponentProps } from 'react-intl-next';
+import { RichMediaLayout as MediaSingleLayout } from '@atlaskit/adf-schema';
+import { MediaFeatureFlags } from '@atlaskit/media-common';
+import type { EventHandlers } from '@atlaskit/editor-common/ui';
+import { AnalyticsEventPayload } from '../../../analytics/events';
+import { RendererAppearance } from '../../../ui/Renderer/types';
+export interface Props {
+    children: React.ReactNode;
+    layout: MediaSingleLayout;
+    eventHandlers?: EventHandlers;
+    width?: number;
+    isInsideOfBlockNode?: boolean;
+    rendererAppearance: RendererAppearance;
+    fireAnalyticsEvent?: (event: AnalyticsEventPayload) => void;
+    featureFlags?: MediaFeatureFlags;
+}
+export declare const getMediaContainerWidth: (currentContainerWidth: number, layout: MediaSingleLayout) => number;
+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.0/react/nodes/mediaSingle/styles.d.ts

@@ -0,0 +1,2 @@
+export declare const uiMediaSingleBaseStyles: import("@emotion/react").SerializedStyles;
+export declare const uiMediaSingleLayoutStyles: import("@emotion/react").SerializedStyles;

package/dist/types-ts4.0/react/nodes/mention.d.ts

@@ -0,0 +1,13 @@
+import { PureComponent } from 'react';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import type { EventHandlers } from '@atlaskit/editor-common/ui';
+export interface Props {
+    id: string;
+    providers?: ProviderFactory;
+    eventHandlers?: EventHandlers;
+    text: string;
+    accessLevel?: string;
+}
+export default class MentionItem extends PureComponent<Props, {}> {
+    render(): JSX.Element;
+}

package/dist/types-ts4.0/react/nodes/orderedList.d.ts

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

package/dist/types-ts4.0/react/nodes/panel.d.ts

@@ -0,0 +1,17 @@
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+import { PanelType } from '@atlaskit/adf-schema';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+export interface Props {
+    children?: React.ReactNode;
+    providers?: ProviderFactory;
+    panelType: PanelType;
+    allowCustomPanels?: boolean;
+    panelIcon?: string;
+    panelIconId?: string;
+    panelIconText?: string;
+    panelColor?: string;
+}
+declare const Panel: (props: Props) => jsx.JSX.Element;
+export default Panel;

package/dist/types-ts4.0/react/nodes/paragraph.d.ts

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

package/dist/types-ts4.0/react/nodes/placeholder.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+export interface Props {
+    text: string;
+    allowPlaceholderText?: boolean;
+}
+export default function Placeholder(props: Props): JSX.Element;

package/dist/types-ts4.0/react/nodes/rule.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export default function Rule(): JSX.Element;

package/dist/types-ts4.0/react/nodes/status.d.ts

@@ -0,0 +1,10 @@
+import { PureComponent } from 'react';
+import { Color } from '@atlaskit/status/element';
+export interface Props {
+    text: string;
+    color: Color;
+    localId?: string;
+}
+export default class Status extends PureComponent<Props, {}> {
+    render(): JSX.Element;
+}

package/dist/types-ts4.0/react/nodes/table/colgroup.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { SharedTableProps } from './types';
+export declare const Colgroup: (props: SharedTableProps) => JSX.Element | null;

package/dist/types-ts4.0/react/nodes/table/sticky.d.ts

@@ -0,0 +1,38 @@
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+import type { OverflowShadowProps } from '@atlaskit/editor-common/ui';
+import { TableLayout } from '@atlaskit/adf-schema';
+export declare type StickyMode = 'none' | 'stick' | 'pin-bottom';
+export declare const tableStickyPadding = 8;
+interface FixedProps {
+    top?: number;
+    wrapperWidth: number;
+    mode: StickyMode;
+}
+export declare const FixedTableDiv: React.FC<FixedProps>;
+export declare type StickyTableProps = {
+    left?: number;
+    top?: number;
+    mode: StickyMode;
+    innerRef: React.RefObject<HTMLDivElement>;
+    rowHeight: number;
+    wrapperWidth: number;
+    tableWidth: string;
+    isNumberColumnEnabled: boolean;
+    children: React.ReactNode[];
+    layout: TableLayout;
+    columnWidths?: number[];
+    renderWidth: number;
+} & OverflowShadowProps;
+export declare const StickyTable: ({ top, left, mode, shadowClassNames, innerRef, wrapperWidth, tableWidth, isNumberColumnEnabled, layout, children, columnWidths, renderWidth, rowHeight, }: StickyTableProps) => jsx.JSX.Element;
+export declare class OverflowParent {
+    private ref;
+    private constructor();
+    static fromElement(el: HTMLElement | null): OverflowParent;
+    get isElement(): boolean;
+    get top(): number;
+    addEventListener(type: string, cb: EventListenerOrEventListenerObject, ...args: any[]): void;
+    removeEventListener(type: string, cb: EventListenerOrEventListenerObject, ...args: any[]): void;
+}
+export {};

package/dist/types-ts4.0/react/nodes/table/table.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { SharedTableProps } from './types';
+export declare type TableProps = SharedTableProps & {
+    innerRef?: React.RefObject<HTMLTableElement>;
+    children: React.ReactNode[];
+};
+export declare const Table: React.MemoExoticComponent<({ innerRef, isNumberColumnEnabled, columnWidths, layout, renderWidth, children, }: TableProps) => JSX.Element>;

package/dist/types-ts4.0/react/nodes/table/types.d.ts

@@ -0,0 +1,7 @@
+import { TableLayout } from '@atlaskit/adf-schema';
+export declare type SharedTableProps = {
+    columnWidths?: Array<number>;
+    layout: TableLayout;
+    isNumberColumnEnabled: boolean;
+    renderWidth: number;
+};

package/dist/types-ts4.0/react/nodes/table.d.ts

@@ -0,0 +1,269 @@
+import React from 'react';
+import { Node as PMNode } from 'prosemirror-model';
+import type { OverflowShadowProps } from '@atlaskit/editor-common/ui';
+import { SortOrder } from '@atlaskit/editor-common/types';
+import { RendererAppearance, StickyHeaderConfig } from '../../ui/Renderer/types';
+import { WithSmartCardStorageProps } from '../../ui/SmartCardStorage';
+import { StickyMode, OverflowParent } from './table/sticky';
+import { SharedTableProps } from './table/types';
+export declare type TableProps = SharedTableProps & {
+    children: React.ReactElement<any> | Array<React.ReactElement<any>>;
+    tableNode?: PMNode;
+    rendererAppearance?: RendererAppearance;
+    allowColumnSorting?: boolean;
+    stickyHeaders?: StickyHeaderConfig;
+};
+interface TableOrderStatus {
+    columnIndex: number;
+    order: SortOrder;
+}
+interface TableState {
+    stickyMode: StickyMode;
+}
+export declare class TableContainer extends React.Component<TableProps & OverflowShadowProps & WithSmartCardStorageProps, TableState> {
+    state: TableState;
+    tableRef: React.RefObject<HTMLTableElement>;
+    stickyHeaderRef: React.RefObject<HTMLElement>;
+    stickyWrapperRef: React.RefObject<HTMLDivElement>;
+    wrapperRef: React.RefObject<HTMLDivElement>;
+    nextFrame: number | undefined;
+    overflowParent: OverflowParent | null;
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: TableProps, prevState: TableState): void;
+    componentWillUnmount: () => void;
+    getScrollTop: () => number;
+    updateSticky: () => void;
+    onScroll: () => void;
+    onWrapperScrolled: () => void;
+    get pinTop(): number | undefined;
+    get stickyTop(): number | undefined;
+    get headerRowHeight(): number;
+    render(): JSX.Element;
+    private grabFirstRowRef;
+}
+export declare type TableProcessorState = {
+    tableOrderStatus?: TableOrderStatus;
+};
+export declare class TableProcessor extends React.Component<TableProps & OverflowShadowProps & WithSmartCardStorageProps, TableProcessorState> {
+    state: {
+        tableOrderStatus: undefined;
+    };
+    render(): JSX.Element | null;
+    private addSortableColumn;
+    private changeSortOrder;
+    private addNumberColumnIndexes;
+}
+declare const _default: {
+    new (props: Readonly<import("@atlaskit/editor-common/utils").Diff<{
+        renderWidth?: number | undefined;
+    } & Omit<SharedTableProps & {
+        children: React.ReactElement<any, string | React.JSXElementConstructor<any>> | React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
+        tableNode?: PMNode<any> | undefined;
+        rendererAppearance?: RendererAppearance;
+        allowColumnSorting?: boolean | undefined;
+        stickyHeaders?: StickyHeaderConfig | undefined;
+    } & WithSmartCardStorageProps, "renderWidth">, WithSmartCardStorageProps>>): {
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("@atlaskit/editor-common/utils").Diff<{
+            renderWidth?: number | undefined;
+        } & Omit<SharedTableProps & {
+            children: React.ReactElement<any, string | React.JSXElementConstructor<any>> | React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
+            tableNode?: PMNode<any> | undefined;
+            rendererAppearance?: RendererAppearance;
+            allowColumnSorting?: boolean | undefined;
+            stickyHeaders?: StickyHeaderConfig | undefined;
+        } & WithSmartCardStorageProps, "renderWidth">, WithSmartCardStorageProps>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callBack?: (() => void) | undefined): void;
+        readonly props: Readonly<import("@atlaskit/editor-common/utils").Diff<{
+            renderWidth?: number | undefined;
+        } & Omit<SharedTableProps & {
+            children: React.ReactElement<any, string | React.JSXElementConstructor<any>> | React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
+            tableNode?: PMNode<any> | undefined;
+            rendererAppearance?: RendererAppearance;
+            allowColumnSorting?: boolean | undefined;
+            stickyHeaders?: StickyHeaderConfig | undefined;
+        } & WithSmartCardStorageProps, "renderWidth">, WithSmartCardStorageProps>> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<import("@atlaskit/editor-common/utils").Diff<{
+            renderWidth?: number | undefined;
+        } & Omit<SharedTableProps & {
+            children: React.ReactElement<any, string | React.JSXElementConstructor<any>> | React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
+            tableNode?: PMNode<any> | undefined;
+            rendererAppearance?: RendererAppearance;
+            allowColumnSorting?: boolean | undefined;
+            stickyHeaders?: StickyHeaderConfig | undefined;
+        } & WithSmartCardStorageProps, "renderWidth">, WithSmartCardStorageProps>>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<import("@atlaskit/editor-common/utils").Diff<{
+            renderWidth?: number | undefined;
+        } & Omit<SharedTableProps & {
+            children: React.ReactElement<any, string | React.JSXElementConstructor<any>> | React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
+            tableNode?: PMNode<any> | undefined;
+            rendererAppearance?: RendererAppearance;
+            allowColumnSorting?: boolean | undefined;
+            stickyHeaders?: StickyHeaderConfig | undefined;
+        } & WithSmartCardStorageProps, "renderWidth">, WithSmartCardStorageProps>>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<import("@atlaskit/editor-common/utils").Diff<{
+            renderWidth?: number | undefined;
+        } & Omit<SharedTableProps & {
+            children: React.ReactElement<any, string | React.JSXElementConstructor<any>> | React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
+            tableNode?: PMNode<any> | undefined;
+            rendererAppearance?: RendererAppearance;
+            allowColumnSorting?: boolean | undefined;
+            stickyHeaders?: StickyHeaderConfig | undefined;
+        } & WithSmartCardStorageProps, "renderWidth">, WithSmartCardStorageProps>>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<import("@atlaskit/editor-common/utils").Diff<{
+            renderWidth?: number | undefined;
+        } & Omit<SharedTableProps & {
+            children: React.ReactElement<any, string | React.JSXElementConstructor<any>> | React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
+            tableNode?: PMNode<any> | undefined;
+            rendererAppearance?: RendererAppearance;
+            allowColumnSorting?: boolean | undefined;
+            stickyHeaders?: StickyHeaderConfig | undefined;
+        } & WithSmartCardStorageProps, "renderWidth">, WithSmartCardStorageProps>>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("@atlaskit/editor-common/utils").Diff<{
+            renderWidth?: number | undefined;
+        } & Omit<SharedTableProps & {
+            children: React.ReactElement<any, string | React.JSXElementConstructor<any>> | React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
+            tableNode?: PMNode<any> | undefined;
+            rendererAppearance?: RendererAppearance;
+            allowColumnSorting?: boolean | undefined;
+            stickyHeaders?: StickyHeaderConfig | undefined;
+        } & WithSmartCardStorageProps, "renderWidth">, WithSmartCardStorageProps>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<import("@atlaskit/editor-common/utils").Diff<{
+            renderWidth?: number | undefined;
+        } & Omit<SharedTableProps & {
+            children: React.ReactElement<any, string | React.JSXElementConstructor<any>> | React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
+            tableNode?: PMNode<any> | undefined;
+            rendererAppearance?: RendererAppearance;
+            allowColumnSorting?: boolean | undefined;
+            stickyHeaders?: StickyHeaderConfig | undefined;
+        } & WithSmartCardStorageProps, "renderWidth">, WithSmartCardStorageProps>>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<import("@atlaskit/editor-common/utils").Diff<{
+            renderWidth?: number | undefined;
+        } & Omit<SharedTableProps & {
+            children: React.ReactElement<any, string | React.JSXElementConstructor<any>> | React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
+            tableNode?: PMNode<any> | undefined;
+            rendererAppearance?: RendererAppearance;
+            allowColumnSorting?: boolean | undefined;
+            stickyHeaders?: StickyHeaderConfig | undefined;
+        } & WithSmartCardStorageProps, "renderWidth">, WithSmartCardStorageProps>>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: import("@atlaskit/editor-common/utils").Diff<{
+        renderWidth?: number | undefined;
+    } & Omit<SharedTableProps & {
+        children: React.ReactElement<any, string | React.JSXElementConstructor<any>> | React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
+        tableNode?: PMNode<any> | undefined;
+        rendererAppearance?: RendererAppearance;
+        allowColumnSorting?: boolean | undefined;
+        stickyHeaders?: StickyHeaderConfig | undefined;
+    } & WithSmartCardStorageProps, "renderWidth">, WithSmartCardStorageProps>, context?: any): {
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("@atlaskit/editor-common/utils").Diff<{
+            renderWidth?: number | undefined;
+        } & Omit<SharedTableProps & {
+            children: React.ReactElement<any, string | React.JSXElementConstructor<any>> | React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
+            tableNode?: PMNode<any> | undefined;
+            rendererAppearance?: RendererAppearance;
+            allowColumnSorting?: boolean | undefined;
+            stickyHeaders?: StickyHeaderConfig | undefined;
+        } & WithSmartCardStorageProps, "renderWidth">, WithSmartCardStorageProps>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callBack?: (() => void) | undefined): void;
+        readonly props: Readonly<import("@atlaskit/editor-common/utils").Diff<{
+            renderWidth?: number | undefined;
+        } & Omit<SharedTableProps & {
+            children: React.ReactElement<any, string | React.JSXElementConstructor<any>> | React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
+            tableNode?: PMNode<any> | undefined;
+            rendererAppearance?: RendererAppearance;
+            allowColumnSorting?: boolean | undefined;
+            stickyHeaders?: StickyHeaderConfig | undefined;
+        } & WithSmartCardStorageProps, "renderWidth">, WithSmartCardStorageProps>> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<import("@atlaskit/editor-common/utils").Diff<{
+            renderWidth?: number | undefined;
+        } & Omit<SharedTableProps & {
+            children: React.ReactElement<any, string | React.JSXElementConstructor<any>> | React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
+            tableNode?: PMNode<any> | undefined;
+            rendererAppearance?: RendererAppearance;
+            allowColumnSorting?: boolean | undefined;
+            stickyHeaders?: StickyHeaderConfig | undefined;
+        } & WithSmartCardStorageProps, "renderWidth">, WithSmartCardStorageProps>>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<import("@atlaskit/editor-common/utils").Diff<{
+            renderWidth?: number | undefined;
+        } & Omit<SharedTableProps & {
+            children: React.ReactElement<any, string | React.JSXElementConstructor<any>> | React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
+            tableNode?: PMNode<any> | undefined;
+            rendererAppearance?: RendererAppearance;
+            allowColumnSorting?: boolean | undefined;
+            stickyHeaders?: StickyHeaderConfig | undefined;
+        } & WithSmartCardStorageProps, "renderWidth">, WithSmartCardStorageProps>>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<import("@atlaskit/editor-common/utils").Diff<{
+            renderWidth?: number | undefined;
+        } & Omit<SharedTableProps & {
+            children: React.ReactElement<any, string | React.JSXElementConstructor<any>> | React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
+            tableNode?: PMNode<any> | undefined;
+            rendererAppearance?: RendererAppearance;
+            allowColumnSorting?: boolean | undefined;
+            stickyHeaders?: StickyHeaderConfig | undefined;
+        } & WithSmartCardStorageProps, "renderWidth">, WithSmartCardStorageProps>>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<import("@atlaskit/editor-common/utils").Diff<{
+            renderWidth?: number | undefined;
+        } & Omit<SharedTableProps & {
+            children: React.ReactElement<any, string | React.JSXElementConstructor<any>> | React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
+            tableNode?: PMNode<any> | undefined;
+            rendererAppearance?: RendererAppearance;
+            allowColumnSorting?: boolean | undefined;
+            stickyHeaders?: StickyHeaderConfig | undefined;
+        } & WithSmartCardStorageProps, "renderWidth">, WithSmartCardStorageProps>>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("@atlaskit/editor-common/utils").Diff<{
+            renderWidth?: number | undefined;
+        } & Omit<SharedTableProps & {
+            children: React.ReactElement<any, string | React.JSXElementConstructor<any>> | React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
+            tableNode?: PMNode<any> | undefined;
+            rendererAppearance?: RendererAppearance;
+            allowColumnSorting?: boolean | undefined;
+            stickyHeaders?: StickyHeaderConfig | undefined;
+        } & WithSmartCardStorageProps, "renderWidth">, WithSmartCardStorageProps>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<import("@atlaskit/editor-common/utils").Diff<{
+            renderWidth?: number | undefined;
+        } & Omit<SharedTableProps & {
+            children: React.ReactElement<any, string | React.JSXElementConstructor<any>> | React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
+            tableNode?: PMNode<any> | undefined;
+            rendererAppearance?: RendererAppearance;
+            allowColumnSorting?: boolean | undefined;
+            stickyHeaders?: StickyHeaderConfig | undefined;
+        } & WithSmartCardStorageProps, "renderWidth">, WithSmartCardStorageProps>>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<import("@atlaskit/editor-common/utils").Diff<{
+            renderWidth?: number | undefined;
+        } & Omit<SharedTableProps & {
+            children: React.ReactElement<any, string | React.JSXElementConstructor<any>> | React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
+            tableNode?: PMNode<any> | undefined;
+            rendererAppearance?: RendererAppearance;
+            allowColumnSorting?: boolean | undefined;
+            stickyHeaders?: StickyHeaderConfig | undefined;
+        } & WithSmartCardStorageProps, "renderWidth">, WithSmartCardStorageProps>>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    contextType?: React.Context<any> | undefined;
+};
+export default _default;

package/dist/types-ts4.0/react/nodes/tableCell.d.ts

@@ -0,0 +1,81 @@
+import React from 'react';
+import { CellAttributes } from '@atlaskit/adf-schema';
+import { SortOrder } from '@atlaskit/editor-common/types';
+import { AnalyticsEventPayload } from '../../analytics/events';
+import { WrappedComponentProps } from 'react-intl-next';
+declare type CellProps = CellAttributes & {
+    children?: React.ReactNode;
+    onClick?: () => void;
+    className?: string;
+    colGroupWidth?: string;
+    offsetTop?: number;
+    ariaSort?: string;
+};
+export declare type CellWithSortingProps = CellProps & {
+    isHeaderRow?: boolean;
+    allowColumnSorting?: boolean;
+    onSorting?: (columnIndex?: number, currentSortOrdered?: SortOrder) => void;
+    columnIndex?: number;
+    sortOrdered?: SortOrder;
+    fireAnalyticsEvent?: (event: AnalyticsEventPayload) => void;
+} & WrappedComponentProps;
+export declare const withSortableColumn: (WrapperComponent: React.ElementType) => React.FC<import("react-intl-next").WithIntlProps<CellWithSortingProps>> & {
+    WrappedComponent: React.ComponentType<CellWithSortingProps>;
+};
+export declare const TableHeader: React.FC<import("react-intl-next").WithIntlProps<CellWithSortingProps>> & {
+    WrappedComponent: React.ComponentType<CellWithSortingProps>;
+};
+export declare const TableCell: {
+    new (props: Readonly<CellProps>): {
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<CellProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callBack?: (() => void) | undefined): void;
+        readonly props: Readonly<CellProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<CellProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<CellProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<CellProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<CellProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<CellProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<CellProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<CellProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: CellProps, context?: any): {
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<CellProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callBack?: (() => void) | undefined): void;
+        readonly props: Readonly<CellProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<CellProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<CellProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<CellProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<CellProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<CellProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<CellProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<CellProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    contextType?: React.Context<any> | undefined;
+};
+export {};

package/dist/types-ts4.0/react/nodes/tableRow.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import { SortOrder } from '@atlaskit/editor-common/types';
+declare type Props = {
+    isNumberColumnEnabled?: number;
+    index?: number;
+    children?: React.ReactNode;
+    onSorting?: (columnIndex?: number, currentSortOrdered?: SortOrder) => void;
+    allowColumnSorting?: boolean;
+    tableOrderStatus?: {
+        columnIndex: number;
+        order: SortOrder;
+    };
+    innerRef?: React.Ref<HTMLTableRowElement>;
+};
+declare type State = {
+    colGroupWidths: string[];
+};
+export default class TableRow extends React.Component<Props, State> {
+    state: State;
+    addSortableColumn: (childrenArray: React.ReactNode[]) => React.ReactNode[];
+    addColGroupWidth: (childrenArray: React.ReactNode[]) => React.ReactNode[];
+    render(): JSX.Element;
+}
+export {};