@atlaskit/editor-core 188.7.0 → 188.7.3

package/dist/types-ts4.5/plugins/placeholder-text/index.d.ts

@@ -0,0 +1,22 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { ExtractInjectionAPI, NextEditorPlugin, OptionalPlugin } from '@atlaskit/editor-common/types';
+import type { Dispatch } from '../../event-dispatcher';
+import type { PlaceholderTextOptions, PluginState } from './types';
+import type { analyticsPlugin } from '@atlaskit/editor-plugin-analytics';
+import type { TypeAheadPlugin } from '@atlaskit/editor-plugin-type-ahead';
+export declare function createPlugin(dispatch: Dispatch<PluginState>, options: PlaceholderTextOptions, api: ExtractInjectionAPI<PlaceholderTextPlugin> | undefined): SafePlugin | undefined;
+type PlaceholderTextPlugin = NextEditorPlugin<'placeholderText', {
+    dependencies: [
+        OptionalPlugin<typeof analyticsPlugin>,
+        TypeAheadPlugin
+    ];
+    pluginConfiguration: PlaceholderTextOptions;
+}>;
+declare const placeholderTextPlugin: NextEditorPlugin<'placeholderText', {
+    dependencies: [
+        OptionalPlugin<typeof analyticsPlugin>,
+        TypeAheadPlugin
+    ];
+    pluginConfiguration: PlaceholderTextOptions;
+}>;
+export default placeholderTextPlugin;

package/dist/types-ts4.5/plugins/placeholder-text/placeholder-text-nodeview.d.ts

@@ -0,0 +1,17 @@
+import type { NodeView, EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { getPosHandler } from '../../nodeviews';
+type PmMutationRecord = MutationRecord | {
+    type: 'selection';
+    target: Element;
+};
+export declare class PlaceholderTextNodeView implements NodeView {
+    private readonly node;
+    private readonly view;
+    private readonly getPos;
+    readonly dom: Node;
+    constructor(node: PMNode, view: EditorView, getPos: getPosHandler);
+    stopEvent(e: Event): boolean;
+    ignoreMutation(record: PmMutationRecord): boolean;
+}
+export {};

package/dist/types-ts4.5/plugins/placeholder-text/plugin-key.d.ts

@@ -0,0 +1,3 @@
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+import type { PluginState } from './types';
+export declare const pluginKey: PluginKey<PluginState>;

package/dist/types-ts4.5/plugins/placeholder-text/selection-utils.d.ts

@@ -0,0 +1,2 @@
+import type { Selection } from '@atlaskit/editor-prosemirror/state';
+export declare const isSelectionAtPlaceholder: (selection: Selection) => boolean;

package/dist/types-ts4.5/plugins/placeholder-text/styles.d.ts

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

package/dist/types-ts4.5/plugins/placeholder-text/types.d.ts

@@ -0,0 +1,7 @@
+export interface PlaceholderTextOptions {
+    allowInserting?: boolean;
+}
+export interface PluginState {
+    showInsertPanelAt: number | null;
+    allowInserting: boolean;
+}

package/dist/types-ts4.5/plugins/placeholder-text/ui/PlaceholderFloatingToolbar/index.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import { WrappedComponentProps } from 'react-intl-next';
+import { Coordinates } from '../../../../ui/FloatingToolbar';
+export declare const messages: {
+    placeholderTextPlaceholder: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};
+export interface Props {
+    getNodeFromPos: (pos: number) => Node;
+    getFixedCoordinatesFromPos: (pos: number) => Coordinates;
+    insertPlaceholder: (value: string) => void;
+    hidePlaceholderFloatingToolbar: () => void;
+    setFocusInEditor: () => void;
+    showInsertPanelAt: number;
+    editorViewDOM: HTMLElement;
+    popupsMountPoint?: HTMLElement;
+    popupsBoundariesElement?: HTMLElement;
+}
+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/plugins/rank.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    plugins: string[];
+    nodes: string[];
+    marks: string[];
+};
+export default _default;

package/dist/types-ts4.5/plugins/save-on-enter/index.d.ts

@@ -0,0 +1,10 @@
+import type { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { Dispatch } from '../../event-dispatcher';
+import type { NextEditorPlugin } from '@atlaskit/editor-common/types';
+export declare function createPlugin(eventDispatch: Dispatch, onSave?: (editorView: EditorView) => void): SafePlugin | undefined;
+type Config = (editorView: EditorView) => void;
+declare const saveOnEnterPlugin: NextEditorPlugin<'saveOnEnter', {
+    pluginConfiguration: Config | undefined;
+}>;
+export default saveOnEnterPlugin;

package/dist/types-ts4.5/plugins/scroll-into-view/index.d.ts

@@ -0,0 +1,14 @@
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+import type { NextEditorPlugin } from '@atlaskit/editor-common/types';
+/**
+ * Plugin to scroll the user's selection into view whenever the user updates
+ * the document eg. inserting, deleting, formatting
+ *
+ * Behaviour is on by default, can be explicitly opted out of for a transaction by
+ * setting scrollIntoView=false meta
+ * We ignore collab transactions, appended transactions, transactions without steps,
+ * transactions with addToHistory=false meta and typeahead trigger transactions
+ */
+export declare const scrollIntoViewPluginKey: PluginKey<any>;
+declare const scrollIntoViewPlugin: NextEditorPlugin<'scrollIntoView'>;
+export default scrollIntoViewPlugin;

package/dist/types-ts4.5/plugins/status/actions.d.ts

@@ -0,0 +1,16 @@
+import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { Command } from '@atlaskit/editor-common/types';
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import type { TOOLBAR_MENU_TYPE } from '@atlaskit/editor-common/types';
+import type { StatusType, ClosingPayload } from './types';
+export declare const DEFAULT_STATUS: StatusType;
+export declare const createStatus: (showStatusPickerAtOffset?: number) => (insert: (node: Node | Object | string, opts: {
+    selectInlineNode: boolean;
+}) => Transaction, state: EditorState) => Transaction;
+export declare const updateStatus: (status?: StatusType) => Command;
+export type UpdateStatus = (inputMethod: TOOLBAR_MENU_TYPE, status?: StatusType) => Command;
+export declare const updateStatusWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (inputMethod: TOOLBAR_MENU_TYPE, status?: StatusType) => Command;
+export declare const setStatusPickerAt: (showStatusPickerAt: number | null) => (state: EditorState, dispatch: (tr: Transaction) => void) => boolean;
+export declare const removeStatus: (showStatusPickerAt: number) => Command;
+export declare const commitStatusPicker: (closingPayload?: ClosingPayload) => (editorView: EditorView) => void;

package/dist/types-ts4.5/plugins/status/analytics.d.ts

@@ -0,0 +1,4 @@
+import { AnalyticsEventPayload, CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+export declare const FABRIC_CHANNEL = "fabric-elements";
+export declare const createStatusAnalyticsAndFire: (createAnalyticsEvent?: CreateUIAnalyticsEvent) => (payload: AnalyticsEventPayload) => void;
+export declare const analyticsState: (isNew: boolean | undefined) => "update" | "new";

package/dist/types-ts4.5/plugins/status/index.d.ts

@@ -0,0 +1,17 @@
+import type { NextEditorPlugin, OptionalPlugin } from '@atlaskit/editor-common/types';
+import type { UpdateStatus } from './actions';
+import { commitStatusPicker } from './actions';
+import type { StatusPluginOptions } from './types';
+import type { AnalyticsPlugin } from '@atlaskit/editor-plugin-analytics';
+export type StatusPlugin = NextEditorPlugin<'status', {
+    dependencies: [
+        OptionalPlugin<AnalyticsPlugin>
+    ];
+    pluginConfiguration: StatusPluginOptions | undefined;
+    actions: {
+        commitStatusPicker: typeof commitStatusPicker;
+        updateStatus: UpdateStatus;
+    };
+}>;
+declare const statusPlugin: StatusPlugin;
+export default statusPlugin;

package/dist/types-ts4.5/plugins/status/keymap.d.ts

@@ -0,0 +1,3 @@
+import type { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+export declare function keymapPlugin(): SafePlugin;
+export default keymapPlugin;

package/dist/types-ts4.5/plugins/status/nodeviews/messages.d.ts

@@ -0,0 +1,17 @@
+export declare const messages: {
+    placeholder: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    editText: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    editColor: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};

package/dist/types-ts4.5/plugins/status/nodeviews/status.d.ts

@@ -0,0 +1,24 @@
+/** @jsx jsx */
+import React from 'react';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { IntlShape } from 'react-intl-next';
+import type { Color, StatusStyle } from '@atlaskit/status/element';
+import type { EventDispatcher } from '@atlaskit/editor-common/event-dispatcher';
+import type { InlineNodeViewComponentProps } from '@atlaskit/editor-common/react-node-view';
+import type { StatusPluginOptions } from '../types';
+export interface ContainerProps {
+    view: EditorView;
+    intl: IntlShape;
+    text?: string;
+    color: Color;
+    style?: StatusStyle;
+    localId?: string;
+    eventDispatcher?: EventDispatcher;
+}
+export declare const IntlStatusContainerView: React.FC<import("react-intl-next").WithIntlProps<ContainerProps>> & {
+    WrappedComponent: React.ComponentType<ContainerProps>;
+};
+export type Props = InlineNodeViewComponentProps & {
+    options: StatusPluginOptions | undefined;
+};
+export declare const StatusNodeView: React.FC<Props>;

package/dist/types-ts4.5/plugins/status/plugin-key.d.ts

@@ -0,0 +1,4 @@
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+import type { StatusState } from './types';
+export declare const pluginKeyName = "statusPlugin";
+export declare const pluginKey: PluginKey<StatusState>;

package/dist/types-ts4.5/plugins/status/plugin.d.ts

@@ -0,0 +1,7 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { PMPluginFactoryParams } from '@atlaskit/editor-common/types';
+import type { StatusPluginOptions } from './types';
+export { pluginKey, pluginKeyName } from './plugin-key';
+export type { StatusState, StatusType, ClosingPayload } from './types';
+declare const createPlugin: (pmPluginFactoryParams: PMPluginFactoryParams, options?: StatusPluginOptions) => SafePlugin<any>;
+export default createPlugin;

package/dist/types-ts4.5/plugins/status/styles.d.ts

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

package/dist/types-ts4.5/plugins/status/types.d.ts

@@ -0,0 +1,18 @@
+import type { Color as ColorType } from '@atlaskit/status/element';
+import type { closingMethods } from './ui/statusPicker';
+export type StatusType = {
+    color: ColorType;
+    text: string;
+    localId?: string;
+};
+export type StatusState = {
+    isNew: boolean;
+    showStatusPickerAt: number | null;
+};
+export interface StatusPluginOptions {
+    menuDisabled: boolean;
+    allowZeroWidthSpaceAfter?: boolean;
+}
+export type ClosingPayload = {
+    closingMethod: closingMethods;
+};

package/dist/types-ts4.5/plugins/status/ui/statusPicker.d.ts

@@ -0,0 +1,63 @@
+import React from 'react';
+import { jsx } from '@emotion/react';
+import type { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import type { ColorType as Color } from '@atlaskit/status/picker';
+import type { StatusType, ClosingPayload } from '../plugin';
+export declare enum InputMethod {
+    blur = "blur",
+    escKey = "escKey",
+    enterKey = "enterKey"
+}
+export declare enum closingMethods {
+    ArrowLeft = "arrowLeft",
+    ArrowRight = "arrowRight"
+}
+export interface Props {
+    target: HTMLElement | null;
+    closeStatusPicker: (closingPayload?: ClosingPayload) => void;
+    onSelect: (status: StatusType) => void;
+    onTextChanged: (status: StatusType, isNew: boolean) => void;
+    onEnter: (status: StatusType) => void;
+    isNew?: boolean;
+    defaultText?: string;
+    defaultColor?: Color;
+    defaultLocalId?: string;
+    createAnalyticsEvent?: CreateUIAnalyticsEvent;
+    mountTo?: HTMLElement;
+    boundariesElement?: HTMLElement;
+    scrollableElement?: HTMLElement;
+}
+export interface State {
+    color: Color;
+    text: string;
+    localId?: string;
+    isNew?: boolean;
+}
+export declare class StatusPickerWithoutAnalytcs extends React.Component<Props, State> {
+    private startTime;
+    private inputMethod?;
+    private createStatusAnalyticsAndFireFunc;
+    private popupBodyWrapper;
+    private focusTimeout;
+    constructor(props: Props);
+    private fireStatusPopupOpenedAnalytics;
+    private fireStatusPopupClosedAnalytics;
+    private reset;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    componentDidUpdate(prevProps: Readonly<Props>, prevState: Readonly<State>, _snapshot?: any): void;
+    private extractStateFromProps;
+    handleClickOutside: (event: Event) => void;
+    private handleEscapeKeydown;
+    private handleTabPress;
+    private handleArrow;
+    private onKeyDown;
+    render(): jsx.JSX.Element | null;
+    private onColorHover;
+    private onColorClick;
+    private onTextChanged;
+    private onEnter;
+    private handlePopupClick;
+}
+declare const _default: React.ForwardRefExoticComponent<Omit<Props, keyof import("@atlaskit/analytics-next").WithAnalyticsEventsProps> & React.RefAttributes<any>>;
+export default _default;

package/dist/types-ts4.5/plugins/status/utils.d.ts

@@ -0,0 +1,5 @@
+import type { Selection, Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { StatusType } from './types';
+export declare const mayGetStatusAtSelection: (selection: Selection) => StatusType | null;
+export declare const isEmptyStatus: (node: StatusType) => boolean;
+export declare const setNodeSelectionNearPos: (tr: Transaction, pos: number) => Transaction;

package/dist/types-ts4.5/plugins/submit-editor/index.d.ts

@@ -0,0 +1,16 @@
+import type { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { Dispatch } from '../../event-dispatcher';
+import type { EditorProps } from '../../types/editor-props';
+import type { NextEditorPlugin, OptionalPlugin, ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { MediaPlugin } from '@atlaskit/editor-plugin-media';
+export declare function createPlugin(eventDispatch: Dispatch, api: ExtractInjectionAPI<SubmitEditorPlugin> | undefined, onSave?: (editorView: EditorView) => void): SafePlugin | undefined;
+type Config = EditorProps['onSave'];
+type SubmitEditorPlugin = NextEditorPlugin<'submitEditor', {
+    pluginConfiguration: Config | undefined;
+    dependencies: [
+        OptionalPlugin<MediaPlugin>
+    ];
+}>;
+declare const submitEditorPlugin: SubmitEditorPlugin;
+export default submitEditorPlugin;

package/dist/types-ts4.5/plugins/tasks-and-decisions/commands.d.ts

@@ -0,0 +1,16 @@
+import type { NodeType, ResolvedPos, Schema } from '@atlaskit/editor-prosemirror/model';
+import type { EditorState, Selection, Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { Command } from '../../types';
+import { INPUT_METHOD } from '../analytics';
+import type { TOOLBAR_MENU_TYPE } from '@atlaskit/editor-common/types';
+import type { AddItemAttrs, AddItemTransactionCreator, TaskDecisionInputMethod, TaskDecisionListType } from './types';
+export declare const getListTypes: (listType: TaskDecisionListType, schema: Schema) => {
+    list: NodeType;
+    item: NodeType;
+};
+export declare const insertTaskDecisionAction: (state: EditorState, listType: TaskDecisionListType, inputMethod?: INPUT_METHOD.FORMATTING | INPUT_METHOD.QUICK_INSERT | TOOLBAR_MENU_TYPE, addItem?: AddItemTransactionCreator, listLocalId?: string, itemLocalId?: string, itemAttrs?: AddItemAttrs) => Transaction;
+export declare const insertTaskDecisionCommand: (listType: TaskDecisionListType, inputMethod?: INPUT_METHOD.FORMATTING | INPUT_METHOD.QUICK_INSERT | TOOLBAR_MENU_TYPE, addItem?: AddItemTransactionCreator, listLocalId?: string, itemLocalId?: string) => Command;
+export declare const insertTaskDecisionWithAnalytics: (state: EditorState, listType: TaskDecisionListType, inputMethod: TaskDecisionInputMethod, addAndCreateList: AddItemTransactionCreator, addToList?: AddItemTransactionCreator, listLocalId?: string, itemLocalId?: string, itemAttrs?: AddItemAttrs) => Transaction | null;
+export declare const isSupportedSourceNode: (schema: Schema, selection: Selection) => boolean;
+export declare const changeInDepth: (before: ResolvedPos, after: ResolvedPos) => number;
+export declare const createListAtSelection: (tr: Transaction, list: any, item: any, schema: Schema, state: EditorState, listLocalId?: string, itemLocalId?: string, itemAttrs?: AddItemAttrs) => Transaction | null;

package/dist/types-ts4.5/plugins/tasks-and-decisions/index.d.ts

@@ -0,0 +1,6 @@
+import type { NextEditorPlugin } from '@atlaskit/editor-common/types';
+import type { TaskDecisionPluginOptions } from './types';
+declare const tasksAndDecisionsPlugin: NextEditorPlugin<'taskDecision', {
+    pluginConfiguration: TaskDecisionPluginOptions | undefined;
+}>;
+export default tasksAndDecisionsPlugin;

package/dist/types-ts4.5/plugins/tasks-and-decisions/nodeviews/decisionItem.d.ts

@@ -0,0 +1,5 @@
+import type { NodeView } from '@atlaskit/editor-prosemirror/view';
+import type { EventDispatcher } from '../../../event-dispatcher';
+import type { getPosHandler } from '../../../nodeviews';
+import type { PortalProviderAPI } from '@atlaskit/editor-common/portal-provider';
+export declare const decisionItemNodeView: (portalProviderAPI: PortalProviderAPI, eventDispatcher: EventDispatcher) => (node: any, view: any, getPos: getPosHandler) => NodeView;

package/dist/types-ts4.5/plugins/tasks-and-decisions/nodeviews/taskItem.d.ts

@@ -0,0 +1,9 @@
+import type { NodeView } from '@atlaskit/editor-prosemirror/view';
+import type { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import type { EventDispatcher } from '../../../event-dispatcher';
+import type { getPosHandler } from '../../../nodeviews';
+import type { PortalProviderAPI } from '@atlaskit/editor-common/portal-provider';
+export interface Props {
+    providerFactory: ProviderFactory;
+}
+export declare function taskItemNodeViewFactory(portalProviderAPI: PortalProviderAPI, eventDispatcher: EventDispatcher, providerFactory: ProviderFactory): (node: any, view: any, getPos: getPosHandler) => NodeView;

package/dist/types-ts4.5/plugins/tasks-and-decisions/pm-plugins/commands.d.ts

@@ -0,0 +1,15 @@
+import type { ResolvedPos } from '@atlaskit/editor-prosemirror/model';
+import type { Command } from '../../../types';
+export declare const liftSelection: Command;
+export declare const wrapSelectionInTaskList: Command;
+/**
+ * Tries to move the paragraph content near the given position into the taskItem or decisionItem
+ * before it.
+ *
+ * Looks backwards from the given position to find the "cut point" between the last taskItem and the
+ * following paragraph. Then tries to move the content from that paragraph into the taskItem.
+ *
+ * @param $pos Position at the end of, or anywhere in paragraph following, the last taskItem
+ * @see {joinToPreviousListItem}
+ */
+export declare const joinAtCut: ($pos: ResolvedPos) => Command;

package/dist/types-ts4.5/plugins/tasks-and-decisions/pm-plugins/helpers.d.ts

@@ -0,0 +1,76 @@
+import type { Node, NodeType, ResolvedPos } from '@atlaskit/editor-prosemirror/model';
+import { EditorState, Selection, Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import { TaskItemData } from './types';
+export declare const isInsideTaskOrDecisionItem: (state: EditorState) => boolean;
+export declare const isActionOrDecisionList: (node: Node) => boolean;
+export declare const isActionOrDecisionItem: (node: Node) => boolean;
+export declare const isInsideTask: (state: EditorState) => boolean;
+export declare const isInsideDecision: (state: EditorState) => boolean;
+export declare const isTable: (node?: Node | null) => Boolean;
+/**
+ * Creates a NodeRange around the given taskItem and the following
+ * ("nested") taskList, if one exists.
+ */
+export declare const getBlockRange: ($from: ResolvedPos, $to: ResolvedPos) => import("prosemirror-model").NodeRange | null;
+/**
+ * Finds the distance between the current $from and the root of the taskList.
+ */
+export declare const getCurrentIndentLevel: (selection: Selection) => number | null;
+/**
+ * Finds the index of the current task item in relation to the closest taskList
+ */
+export declare const getTaskItemIndex: (state: EditorState) => number;
+/**
+ * Walk outwards from a position until we encounter the (inside) start of
+ * the next node, or reach the end of the document.
+ *
+ * @param $startPos Position to start walking from.
+ */
+export declare const walkOut: ($startPos: ResolvedPos) => ResolvedPos;
+/**
+ * Finds the height of a tree-like structure, given any position inside it.
+ *
+ * Traverses from the top of the tree to all leaf nodes, and returns the length
+ * of the longest path.
+ *
+ * This means you can use it with things like taskList, which
+ * do not nest themselves inside taskItems but rather as adjacent children.
+ *
+ * @param $pos Any position inside the tree.
+ * @param types The node types to consider traversable
+ */
+export declare const subtreeHeight: ($from: ResolvedPos, $to: ResolvedPos, types: NodeType[]) => number;
+/**
+ * Returns `true` if the taskItem or decisionItem has no text.
+ */
+export declare const isEmptyTaskDecision: (state: EditorState) => boolean;
+/**
+ * Lifts a taskItem and any directly following taskList
+ * (taskItem and its "nested children") out one level.
+ *
+ * @param tr Transaction to base steps on
+ * @param $from Start of range you want to lift
+ * @param $to End of range you want to lift (can be same as `$from`)
+ */
+export declare const liftBlock: (tr: Transaction, $from: ResolvedPos, $to: ResolvedPos) => Transaction | null;
+export declare function getTaskItemDataAtPos(view: EditorView): {
+    pos: number;
+    localId: any;
+} | undefined;
+export declare function getAllTaskItemsDataInRootTaskList(view: EditorView): {
+    node: Node;
+    pos: number;
+    index: number;
+}[] | undefined;
+export declare function getCurrentTaskItemIndex(view: EditorView, allTaskItems: Array<{
+    node: Node;
+    pos: number;
+    index: number;
+}>): number;
+export declare function getTaskItemDataToFocus(view: EditorView, direction: 'next' | 'previous'): {
+    pos: number;
+    localId: any;
+} | undefined;
+export declare function focusCheckboxAndUpdateSelection(view: EditorView, taskItemData: TaskItemData): void;
+export declare function removeCheckboxFocus(view: EditorView): void;

package/dist/types-ts4.5/plugins/tasks-and-decisions/pm-plugins/input-rules.d.ts

@@ -0,0 +1,5 @@
+import type { FeatureFlags } from '../../../types/feature-flags';
+import type { Schema } from '@atlaskit/editor-prosemirror/model';
+import type { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+export declare function inputRulePlugin(schema: Schema, featureFlags: FeatureFlags): SafePlugin;
+export default inputRulePlugin;

package/dist/types-ts4.5/plugins/tasks-and-decisions/pm-plugins/keymaps.d.ts

@@ -0,0 +1,8 @@
+import type { Schema } from '@atlaskit/editor-prosemirror/model';
+import type { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { INPUT_METHOD } from '../../analytics';
+type IndentationInputMethod = INPUT_METHOD.KEYBOARD | INPUT_METHOD.TOOLBAR;
+export declare const getUnindentCommand: (inputMethod?: IndentationInputMethod) => import("@atlaskit/editor-common/types").Command;
+export declare const getIndentCommand: (inputMethod?: IndentationInputMethod) => import("@atlaskit/editor-common/types").Command;
+export declare function keymapPlugin(schema: Schema, allowNestedTasks?: boolean, consumeTabs?: boolean): SafePlugin | undefined;
+export default keymapPlugin;

package/dist/types-ts4.5/plugins/tasks-and-decisions/pm-plugins/main.d.ts

@@ -0,0 +1,5 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import type { Dispatch, EventDispatcher } from '../../../event-dispatcher';
+import type { PortalProviderAPI } from '@atlaskit/editor-common/portal-provider';
+export declare function createPlugin(portalProviderAPI: PortalProviderAPI, eventDispatcher: EventDispatcher, providerFactory: ProviderFactory, dispatch: Dispatch, useLongPressSelection?: boolean): SafePlugin<any>;

package/dist/types-ts4.5/plugins/tasks-and-decisions/pm-plugins/plugin-key.d.ts

@@ -0,0 +1,2 @@
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+export declare const stateKey: PluginKey<any>;

package/dist/types-ts4.5/plugins/tasks-and-decisions/pm-plugins/types.d.ts

@@ -0,0 +1,8 @@
+export declare enum ACTIONS {
+    SET_CONTEXT_PROVIDER = 0,
+    FOCUS_BY_LOCALID = 1
+}
+export type TaskItemData = {
+    pos: number;
+    localId: string | null;
+};

package/dist/types-ts4.5/plugins/tasks-and-decisions/styles.d.ts

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

package/dist/types-ts4.5/plugins/tasks-and-decisions/types.d.ts

@@ -0,0 +1,26 @@
+import type { DecisionItemDefinition, TaskItemDefinition } from '@atlaskit/adf-schema';
+import type { NodeType } from '@atlaskit/editor-prosemirror/model';
+import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { INPUT_METHOD, USER_CONTEXT } from '@atlaskit/editor-common/analytics';
+import type { LongPressSelectionPluginOptions } from '@atlaskit/editor-common/types';
+export type TaskDecisionListType = 'taskList' | 'decisionList';
+export type TaskDecisionInputMethod = INPUT_METHOD.TOOLBAR | INPUT_METHOD.INSERT_MENU | INPUT_METHOD.QUICK_INSERT | INPUT_METHOD.FORMATTING | INPUT_METHOD.KEYBOARD;
+export type ContextData = {
+    objectId: string;
+    containerId: string;
+    userContext: USER_CONTEXT;
+};
+export type AddItemAttrs = Partial<DecisionItemDefinition['attrs']> | Partial<TaskItemDefinition['attrs']>;
+export type AddItemTransactionCreator = (opts: {
+    state: EditorState;
+    tr: Transaction;
+    list: NodeType;
+    item: NodeType;
+    listLocalId: string;
+    itemLocalId: string;
+    itemAttrs?: AddItemAttrs;
+}) => Transaction | null;
+export interface TaskDecisionPluginOptions extends LongPressSelectionPluginOptions {
+    allowNestedTasks?: boolean;
+    consumeTabs?: boolean;
+}

package/dist/types-ts4.5/plugins/tasks-and-decisions/ui/Decision/index.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { WrappedComponentProps } from 'react-intl-next';
+interface Props {
+    contentRef: any;
+    showPlaceholder?: boolean;
+}
+export declare class Decision extends React.Component<Props & WrappedComponentProps, {}> {
+    static displayName: string;
+    render(): JSX.Element;
+}
+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/plugins/tasks-and-decisions/ui/Task/index.d.ts

@@ -0,0 +1,27 @@
+import React, { PureComponent, ReactElement } from 'react';
+import { WrappedComponentProps } from 'react-intl-next';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import { ContentRef } from '@atlaskit/task-decision';
+export interface TaskProps {
+    taskId: string;
+    isDone: boolean;
+    isFocused?: boolean;
+    contentRef?: ContentRef;
+    onChange?: (taskId: string, isChecked: boolean) => void;
+    showPlaceholder?: boolean;
+    children?: ReactElement<any>;
+    providers?: ProviderFactory;
+    disabled?: boolean;
+}
+export declare class TaskItem extends PureComponent<TaskProps & WrappedComponentProps, {}> {
+    static displayName: string;
+    private providerFactory;
+    constructor(props: TaskProps & WrappedComponentProps);
+    componentWillUnmount(): void;
+    private renderWithProvider;
+    render(): JSX.Element;
+}
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<TaskProps & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<TaskProps & WrappedComponentProps<"intl">>;
+};
+export default _default;

package/dist/types-ts4.5/plugins/tasks-and-decisions/ui/Task/task-item-with-providers.d.ts

@@ -0,0 +1,28 @@
+import { Component, ReactElement } from 'react';
+import type { ContextIdentifierProvider } from '@atlaskit/editor-common/provider-factory';
+import { ContentRef, TaskDecisionProvider } from '@atlaskit/task-decision';
+export interface Props {
+    taskId: string;
+    isDone: boolean;
+    isFocused?: boolean;
+    contentRef?: ContentRef;
+    onChange?: (taskId: string, isChecked: boolean) => void;
+    showPlaceholder?: boolean;
+    placeholder?: string;
+    children?: ReactElement<any>;
+    taskDecisionProvider?: Promise<TaskDecisionProvider>;
+    contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
+}
+export interface State {
+    resolvedContextProvider?: ContextIdentifierProvider;
+}
+export default class TaskItemWithProviders extends Component<Props, State> {
+    static displayName: string;
+    state: State;
+    private mounted;
+    UNSAFE_componentWillMount(): void;
+    componentWillUnmount(): void;
+    UNSAFE_componentWillReceiveProps(nextProps: Props): void;
+    private updateContextIdentifierProvider;
+    render(): JSX.Element;
+}