@atlaskit/renderer 108.15.10 → 108.15.12

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

@@ -0,0 +1,282 @@
+import React from 'react';
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { OverflowShadowProps } from '@atlaskit/editor-common/ui';
+import { SortOrder } from '@atlaskit/editor-common/types';
+import type { RendererAppearance, StickyHeaderConfig } from '../../ui/Renderer/types';
+import type { WithSmartCardStorageProps } from '../../ui/SmartCardStorage';
+import type { StickyMode } from './table/sticky';
+import { OverflowParent } from './table/sticky';
+import type { SharedTableProps } from './table/types';
+export declare const isTableResizingEnabled: (appearance: RendererAppearance) => boolean;
+export 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;
+    wrapperWidth: number;
+    headerRowHeight: number;
+}
+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;
+    private resizeObserver;
+    private applyResizerChange;
+    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;
+    render(): JSX.Element;
+    private grabFirstRowRef;
+}
+export 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: 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 | undefined;
+        rendererAppearance?: RendererAppearance;
+        allowColumnSorting?: boolean | undefined;
+        stickyHeaders?: StickyHeaderConfig | undefined;
+    } & WithSmartCardStorageProps, "renderWidth">, WithSmartCardStorageProps> | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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.5/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';
+type CellProps = CellAttributes & {
+    children?: React.ReactNode;
+    onClick?: () => void;
+    className?: string;
+    colGroupWidth?: string;
+    offsetTop?: number;
+    ariaSort?: string;
+};
+export 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: CellProps | 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.5/react/nodes/tableRow.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import { SortOrder } from '@atlaskit/editor-common/types';
+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>;
+};
+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 {};

package/dist/types-ts4.5/react/nodes/task-item-with-providers.d.ts

@@ -0,0 +1,29 @@
+import { Component, ReactNode } from 'react';
+import type { ContextIdentifierProvider } from '@atlaskit/editor-common/provider-factory';
+import { ContentRef, TaskDecisionProvider } from '@atlaskit/task-decision';
+export interface Props {
+    taskId: string;
+    objectAri: string;
+    isDone: boolean;
+    isRenderer?: boolean;
+    contentRef?: ContentRef;
+    onChange?: (taskId: string, isChecked: boolean) => void;
+    showPlaceholder?: boolean;
+    children?: ReactNode;
+    taskDecisionProvider?: Promise<TaskDecisionProvider>;
+    contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
+    disabled?: boolean;
+    dataAttributes?: {
+        [key: string]: string | number;
+    };
+}
+export interface State {
+    resolvedContextProvider?: ContextIdentifierProvider;
+}
+export default class TaskItemWithProviders extends Component<Props, State> {
+    state: State;
+    UNSAFE_componentWillMount(): void;
+    UNSAFE_componentWillReceiveProps(nextProps: Props): void;
+    private updateContextIdentifierProvider;
+    render(): JSX.Element;
+}

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

@@ -0,0 +1,19 @@
+import { PureComponent, ReactNode } from 'react';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import { RendererContext } from '../types';
+import { NodeProps } from '../types';
+export interface Props {
+    localId: string;
+    rendererContext?: RendererContext;
+    state?: string;
+    providers?: ProviderFactory;
+    children?: ReactNode;
+    disabled?: boolean;
+}
+export default class TaskItem extends PureComponent<NodeProps<Props>, {}> {
+    private providerFactory;
+    constructor(props: NodeProps<Props>);
+    componentWillUnmount(): void;
+    private renderWithProvider;
+    render(): JSX.Element;
+}

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

@@ -0,0 +1,8 @@
+import { PureComponent, ReactNode } from 'react';
+export interface Props {
+    localId?: string;
+    children?: ReactNode;
+}
+export default class TaskList extends PureComponent<Props, {}> {
+    render(): JSX.Element | null;
+}

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

@@ -0,0 +1,8 @@
+import { ReactNode } from 'react';
+type Props = {
+    startPos: number;
+    endPos: number;
+    children?: ReactNode | null;
+};
+declare const TextWrapper: (props: Props) => JSX.Element | null;
+export default TextWrapper;

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

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

package/dist/types-ts4.5/react/renderer-node.d.ts

@@ -0,0 +1,5 @@
+import type { Node, Schema } from '@atlaskit/editor-prosemirror/model';
+export declare const isLayoutNode: (node: Node) => boolean;
+export declare const hasBreakOutMark: (node: Node) => boolean;
+export declare const insideBreakoutLayout: (path: Node[]) => boolean;
+export declare const insideBlockNode: (path: Node[], schema: Schema) => boolean;

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

@@ -0,0 +1,58 @@
+import { PropsWithChildren } from 'react';
+import { Node as PMNode, NodeType, Schema } from '@atlaskit/editor-prosemirror/model';
+import type { ExtensionHandlers } from '@atlaskit/editor-common/extensions';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import type { EventHandlers } from '@atlaskit/editor-common/ui';
+import { AnalyticsEventPayload } from '../analytics/events';
+import { Serializer } from '../index';
+import { RendererAppearance, HeadingAnchorLinksProps } from '../ui/Renderer/types';
+import { AnnotationId, AnnotationTypes } from '@atlaskit/adf-schema';
+export interface RendererContext {
+    objectAri?: string;
+    containerAri?: string;
+    adDoc?: any;
+    schema?: Schema;
+}
+export interface NodeMeta {
+    text?: PMNode['text'];
+    providers?: ProviderFactory | undefined;
+    eventHandlers?: EventHandlers | undefined;
+    extensionHandlers?: ExtensionHandlers | undefined;
+    portal?: HTMLElement | undefined;
+    rendererContext?: RendererContext;
+    serializer: Serializer<JSX.Element>;
+    content?: {
+        [key: string]: any;
+    } | null;
+    allowHeadingAnchorLinks?: HeadingAnchorLinksProps;
+    allowCopyToClipboard?: boolean;
+    allowWrapCodeBlock?: boolean;
+    allowPlaceholderText?: boolean;
+    allowCustomPanels?: boolean;
+    rendererAppearance?: RendererAppearance;
+    fireAnalyticsEvent?: (event: AnalyticsEventPayload) => void;
+    nodeType: NodeType['name'];
+    marks: PMNode['marks'];
+    dataAttributes: {
+        'data-renderer-start-pos': number;
+    };
+    [key: string]: any;
+}
+export interface MarkMeta {
+    dataAttributes: {
+        'data-renderer-mark': true;
+    };
+    eventHandlers?: EventHandlers;
+    fireAnalyticsEvent?: (event: AnalyticsEventPayload) => void;
+    markKey?: any;
+    isInline?: boolean;
+    [key: string]: any;
+}
+export interface AnnotationMarkMeta extends MarkMeta {
+    id: AnnotationId;
+    annotationType: AnnotationTypes;
+    annotationParentIds: string[];
+    allowAnnotations: boolean;
+}
+export type NodeProps<NodeAttrs = {}> = NodeAttrs & PropsWithChildren<NodeMeta>;
+export type MarkProps<MarkAttrs = {}> = MarkAttrs & PropsWithChildren<MarkMeta>;

package/dist/types-ts4.5/react/utils/appearance.d.ts

@@ -0,0 +1,4 @@
+import { RendererAppearance } from '../../ui/Renderer/types';
+export declare const isFullWidthAppearance: (appearance: RendererAppearance) => boolean;
+export declare const isFullPageAppearance: (appearance: RendererAppearance) => boolean;
+export declare const isFullWidthOrFullPageAppearance: (appearance: RendererAppearance) => boolean;

package/dist/types-ts4.5/react/utils/clipboard.d.ts

@@ -0,0 +1 @@
+export declare const copyTextToClipboard: (text: string) => Promise<void>;

package/dist/types-ts4.5/react/utils/element-selection.d.ts

@@ -0,0 +1,9 @@
+export declare class ElementSelection {
+    readonly type: string;
+    readonly range?: Range;
+    private constructor();
+    eq(selection?: ElementSelection): boolean;
+    inside(el: HTMLElement): boolean;
+    select(el: HTMLElement): ElementSelection;
+    static fromWindow(win?: Window): ElementSelection;
+}

package/dist/types-ts4.5/react/utils/getCardClickHandler.d.ts

@@ -0,0 +1,2 @@
+import type { EventHandlers } from '@atlaskit/editor-common/ui';
+export declare const getCardClickHandler: (eventHandlers?: EventHandlers, url?: string) => ((e: React.MouseEvent<HTMLElement>) => any) | undefined;

package/dist/types-ts4.5/react/utils/inject-props.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+/**
+ * Helper function to recursively injects props to
+ * all valid children react nodes.
+ */
+export declare function recursivelyInjectProps(children: ReactNode[], propsToInject: Object): ReactNode[];

package/dist/types-ts4.5/react/utils/links.d.ts

@@ -0,0 +1,3 @@
+import { HeadingAnchorLinksProps } from '../../ui/Renderer/types';
+export declare function isNestedHeaderLinksEnabled(allowHeadingAnchorLinks?: HeadingAnchorLinksProps): boolean;
+export declare function getActiveHeadingId(allowHeadingAnchorLinks?: HeadingAnchorLinksProps): string | undefined;

package/dist/types-ts4.5/react/utils/lists.d.ts

@@ -0,0 +1,2 @@
+import { Node } from '@atlaskit/editor-prosemirror/model';
+export declare function getListIndentLevel(path: Node[]): number;

package/dist/types-ts4.5/react/utils/performance/RenderTracking.d.ts

@@ -0,0 +1,15 @@
+import type { AnalyticsEventPayload } from '../../../analytics/events';
+import { ACTION_SUBJECT, ACTION } from '@atlaskit/editor-common/analytics';
+export type FireAnalyticsCallback = <T = void>(payload: AnalyticsEventPayload<T>) => void | undefined;
+type RenderActions = ACTION.RE_RENDERED;
+type RenderActionSubjects = ACTION_SUBJECT.RENDERER;
+export type RenderTrackingProps<ComponentProps> = {
+    componentProps: ComponentProps;
+    action: RenderActions;
+    actionSubject: RenderActionSubjects;
+    handleAnalyticsEvent: FireAnalyticsCallback;
+    propsToIgnore?: Array<keyof ComponentProps>;
+    useShallow?: boolean;
+};
+export declare function RenderTracking<Props>(props: RenderTrackingProps<Props>): null;
+export {};

package/dist/types-ts4.5/react/utils/use-select-all-trap.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const useSelectAllTrap: <T extends HTMLElement>() => React.MutableRefObject<T | null>;

package/dist/types-ts4.5/render-document.d.ts

@@ -0,0 +1,23 @@
+import { Serializer } from './serializer';
+import type { ADFStage } from '@atlaskit/editor-common/validator';
+import type { UnsupportedContentLevelsTracking } from '@atlaskit/editor-common/utils';
+import { Node as PMNode, Schema } from '@atlaskit/editor-prosemirror/model';
+import { AnalyticsEventPayload } from './analytics/events';
+import { RendererAppearance } from './ui/Renderer/types';
+export interface RenderOutput<T> {
+    result: T;
+    stat: RenderOutputStat;
+    pmDoc?: PMNode;
+}
+export interface RenderOutputStat {
+    buildTreeTime?: number;
+    sanitizeTime: number;
+    serializeTime?: number;
+}
+export interface ResultWithTime<T> {
+    output: T;
+    time: number;
+}
+type DispatchAnalyticsEvent = (event: AnalyticsEventPayload) => void;
+export declare const renderDocument: <T>(doc: any, serializer: Serializer<T>, schema?: Schema, adfStage?: ADFStage, useSpecBasedValidator?: boolean, rendererId?: string, dispatchAnalyticsEvent?: DispatchAnalyticsEvent, unsupportedContentLevelsTracking?: UnsupportedContentLevelsTracking, appearance?: RendererAppearance) => RenderOutput<T | null>;
+export {};

package/dist/types-ts4.5/renderer-context.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { FeatureFlags } from '@atlaskit/editor-common/types';
+export type RendererContextProps = {
+    featureFlags?: FeatureFlags;
+};
+export declare const useRendererContext: () => RendererContextProps;
+export declare const RendererContextProvider: React.Provider<{}>;

package/dist/types-ts4.5/serializer.d.ts

@@ -0,0 +1,4 @@
+import { Fragment } from '@atlaskit/editor-prosemirror/model';
+export interface Serializer<T> {
+    serializeFragment(fragment: Fragment, props?: any, target?: any, key?: string): T | null;
+}

package/dist/types-ts4.5/steps/index.d.ts

@@ -0,0 +1,14 @@
+import { Schema } from '@atlaskit/editor-prosemirror/model';
+import { AddMarkStep } from '@atlaskit/editor-prosemirror/transform';
+export declare function resolvePos(node: Node | null, offset: number): number | false;
+interface AnnotationStepOptions {
+    schema: Schema;
+    annotationId: string;
+    annotationType: 'inlineComment';
+}
+export declare function getPosFromRange(range: Range): {
+    from: number;
+    to: number;
+} | false;
+export declare function createAnnotationStep(from: number, to: number, opts: AnnotationStepOptions): AddMarkStep;
+export {};