@atlaskit/editor-core 188.7.0 → 188.7.5

package/dist/types-ts4.5/plugins/find-replace/ui/Find.d.ts

@@ -0,0 +1,71 @@
+/** @jsx jsx */
+import React from 'react';
+import type { WrappedComponentProps } from 'react-intl-next';
+import { TRIGGER_METHOD } from '../../analytics/types';
+import type { MatchCaseProps } from '../types';
+export declare const FIND_DEBOUNCE_MS = 100;
+export type FindProps = {
+    findText?: string;
+    count: {
+        index: number;
+        total: number;
+    };
+    shouldFocus: boolean;
+    onFindBlur: () => void;
+    onFind: (findText?: string) => void;
+    onFindNext: ({ triggerMethod, }: {
+        triggerMethod: TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.BUTTON;
+    }) => void;
+    onFindPrev: ({ triggerMethod, }: {
+        triggerMethod: TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.BUTTON;
+    }) => void;
+    onFindTextfieldRefSet: (ref: React.RefObject<HTMLInputElement>) => void;
+    onCancel: ({ triggerMethod, }: {
+        triggerMethod: TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.TOOLBAR | TRIGGER_METHOD.BUTTON;
+    }) => void;
+    onArrowDown: () => void;
+} & MatchCaseProps;
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<{
+    findText?: string | undefined;
+    count: {
+        index: number;
+        total: number;
+    };
+    shouldFocus: boolean;
+    onFindBlur: () => void;
+    onFind: (findText?: string | undefined) => void;
+    onFindNext: ({ triggerMethod, }: {
+        triggerMethod: TRIGGER_METHOD.BUTTON | TRIGGER_METHOD.KEYBOARD;
+    }) => void;
+    onFindPrev: ({ triggerMethod, }: {
+        triggerMethod: TRIGGER_METHOD.BUTTON | TRIGGER_METHOD.KEYBOARD;
+    }) => void;
+    onFindTextfieldRefSet: (ref: React.RefObject<HTMLInputElement>) => void;
+    onCancel: ({ triggerMethod, }: {
+        triggerMethod: TRIGGER_METHOD.BUTTON | TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.TOOLBAR;
+    }) => void;
+    onArrowDown: () => void;
+} & MatchCaseProps & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<{
+        findText?: string | undefined;
+        count: {
+            index: number;
+            total: number;
+        };
+        shouldFocus: boolean;
+        onFindBlur: () => void;
+        onFind: (findText?: string | undefined) => void;
+        onFindNext: ({ triggerMethod, }: {
+            triggerMethod: TRIGGER_METHOD.BUTTON | TRIGGER_METHOD.KEYBOARD;
+        }) => void;
+        onFindPrev: ({ triggerMethod, }: {
+            triggerMethod: TRIGGER_METHOD.BUTTON | TRIGGER_METHOD.KEYBOARD;
+        }) => void;
+        onFindTextfieldRefSet: (ref: React.RefObject<HTMLInputElement>) => void;
+        onCancel: ({ triggerMethod, }: {
+            triggerMethod: TRIGGER_METHOD.BUTTON | TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.TOOLBAR;
+        }) => void;
+        onArrowDown: () => void;
+    } & MatchCaseProps & WrappedComponentProps<"intl">>;
+};
+export default _default;

package/dist/types-ts4.5/plugins/find-replace/ui/FindReplace.d.ts

@@ -0,0 +1,43 @@
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+import { TRIGGER_METHOD, DispatchAnalyticsEvent } from '../../analytics/types';
+import { MatchCaseProps } from '../types';
+export type FindReplaceProps = {
+    findText?: string;
+    replaceText?: string;
+    count: {
+        index: number;
+        total: number;
+    };
+    shouldFocus: boolean;
+    onFindBlur: () => void;
+    onFind: (findText?: string) => void;
+    onFindNext: ({ triggerMethod, }: {
+        triggerMethod: TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.BUTTON;
+    }) => void;
+    onFindPrev: ({ triggerMethod, }: {
+        triggerMethod: TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.BUTTON;
+    }) => void;
+    onReplace: ({ triggerMethod, replaceText, }: {
+        triggerMethod: TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.BUTTON;
+        replaceText: string;
+    }) => void;
+    onReplaceAll: ({ replaceText }: {
+        replaceText: string;
+    }) => void;
+    onCancel: ({ triggerMethod, }: {
+        triggerMethod: TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.TOOLBAR | TRIGGER_METHOD.BUTTON;
+    }) => void;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+} & MatchCaseProps;
+declare class FindReplace extends React.PureComponent<FindReplaceProps> {
+    private findTextfield;
+    private replaceTextfield?;
+    setFindTextfieldRef: (findTextfieldRef: React.RefObject<HTMLInputElement>) => void;
+    setReplaceTextfieldRef: (replaceTextfieldRef: React.RefObject<HTMLInputElement>) => void;
+    setFocusToFind: () => void;
+    setFocusToReplace: () => void;
+    render(): jsx.JSX.Element;
+}
+export default FindReplace;

package/dist/types-ts4.5/plugins/find-replace/ui/FindReplaceToolbarButton.d.ts

@@ -0,0 +1,21 @@
+/** @jsx jsx */
+import React from 'react';
+import type { WrappedComponentProps } from 'react-intl-next';
+import type { FindReplaceProps } from './FindReplace';
+import type { DispatchAnalyticsEvent } from '../../analytics/types';
+export interface FindReplaceToolbarButtonProps extends Omit<FindReplaceProps, 'count'> {
+    index: number;
+    numMatches: number;
+    isActive: boolean;
+    onActivate: () => void;
+    isReducedSpacing?: boolean;
+    popupsMountPoint?: HTMLElement;
+    popupsBoundariesElement?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    takeFullWidth: boolean;
+}
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<FindReplaceToolbarButtonProps & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<FindReplaceToolbarButtonProps & WrappedComponentProps<"intl">>;
+};
+export default _default;

package/dist/types-ts4.5/plugins/find-replace/ui/FindReplaceTooltipButton.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+interface Props {
+    title: string;
+    icon: JSX.Element;
+    keymapDescription: string;
+    onClick: (ref: React.RefObject<HTMLButtonElement>) => void;
+    disabled?: boolean;
+    isPressed?: boolean;
+}
+export declare class FindReplaceTooltipButton extends React.PureComponent<Props> {
+    private buttonRef;
+    static defaultProps: {
+        keymapDescription: string;
+    };
+    handleClick: () => void;
+    render(): JSX.Element;
+}
+export {};

package/dist/types-ts4.5/plugins/find-replace/ui/Replace.d.ts

@@ -0,0 +1,26 @@
+/** @jsx jsx */
+import React from 'react';
+import { WrappedComponentProps } from 'react-intl-next';
+import { TRIGGER_METHOD, DispatchAnalyticsEvent } from '../../analytics/types';
+export type ReplaceProps = {
+    canReplace: boolean;
+    replaceText?: string;
+    onReplace: ({ triggerMethod, replaceText, }: {
+        triggerMethod: TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.BUTTON;
+        replaceText: string;
+    }) => void;
+    onReplaceAll: ({ replaceText }: {
+        replaceText: string;
+    }) => void;
+    onReplaceTextfieldRefSet: (ref: React.RefObject<HTMLInputElement>) => void;
+    onArrowUp: () => void;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+};
+export type ReplaceState = {
+    replaceText: string;
+    isComposing: boolean;
+};
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<ReplaceProps & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<ReplaceProps & WrappedComponentProps<"intl">>;
+};
+export default _default;

package/dist/types-ts4.5/plugins/find-replace/ui/styles.d.ts

@@ -0,0 +1,5 @@
+export declare const replaceSectionButtonStyles: import("@emotion/react").SerializedStyles;
+export declare const ruleStyles: import("@emotion/react").SerializedStyles;
+export declare const wrapperStyles: import("@emotion/react").SerializedStyles;
+export declare const sectionWrapperStyles: import("@emotion/react").SerializedStyles;
+export declare const countStyles: import("@emotion/react").SerializedStyles;

package/dist/types-ts4.5/plugins/find-replace/utils/batch-decorations.d.ts

@@ -0,0 +1,36 @@
+import type { EditorView, Decoration } from '@atlaskit/editor-prosemirror/view';
+/**
+ * Provides support for applying search match highlight decorations in batches
+ */
+declare class BatchDecorations {
+    private rafId?;
+    private addDecorations?;
+    private removeDecorations?;
+    stop(): void;
+    /**
+     * Applies the decorations needed for the current search results
+     * It does so async, splitting them up into batches to help with performance
+     */
+    applyAllSearchDecorations(editorView: EditorView, containerElement: HTMLElement | null, addDecorations: (decorations: Decoration[]) => void, removeDecorations: (decorations: Decoration[]) => void): Promise<void>;
+    private updateDecorationsBetween;
+    private addDecorationsBetween;
+    private removeDecorationsBetween;
+    /**
+     * Calculates Prosemirror start and end positions we want to apply the decorations
+     * between
+     * Also calculates the positions the are the start and end of the user's viewport
+     * so we can apply decorations there first and work outwards
+     */
+    private calcDecorationPositions;
+    private getStartPos;
+    private getEndPos;
+    /**
+     * Util to batch function calls by animation frames
+     * A counter will start at 0 and increment by provided value until reaches limit
+     * Passed in fn receives the counter as a param, return false to skip waiting
+     * for the animation frame for the next call
+     */
+    private batchRequests;
+}
+declare const batchDecorations: BatchDecorations;
+export default batchDecorations;

package/dist/types-ts4.5/plugins/find-replace/utils/index.d.ts

@@ -0,0 +1,49 @@
+import type { Fragment, Node as PmNode, Slice } from '@atlaskit/editor-prosemirror/model';
+import type { DecorationSet } from '@atlaskit/editor-prosemirror/view';
+import { Decoration } from '@atlaskit/editor-prosemirror/view';
+import type { ReadonlyTransaction, Selection } from '@atlaskit/editor-prosemirror/state';
+import { TextSelection } from '@atlaskit/editor-prosemirror/state';
+import type { Step } from '@atlaskit/editor-prosemirror/transform';
+import type { Match } from '../types';
+export declare function getSelectedText(selection: TextSelection): string;
+export declare const createDecorations: (selectedIndex: number, matches: {
+    start: number;
+    end: number;
+}[]) => Decoration[];
+export declare const createDecoration: (start: number, end: number, isSelected?: boolean) => Decoration;
+export declare function findMatches(content: PmNode | Fragment, searchText: string, shouldMatchCase: boolean, contentIndex?: number): Match[];
+/**
+ * Finds index of first item in matches array that comes after user's cursor pos.
+ * If `backward` is `true`, finds index of first item that comes before instead.
+ */
+export declare function findSearchIndex(selectionPos: number, matches: Match[], backward?: boolean): number;
+export declare const nextIndex: (currentIndex: number, total: number) => number;
+export declare const prevIndex: (currentIndex: number, total: number) => number;
+export declare const getSelectionForMatch: (selection: Selection, doc: PmNode, index: number, matches: Match[], offset?: number) => Selection;
+export declare const findDecorationFromMatch: (decorationSet: DecorationSet, match: Match) => Decoration | undefined;
+export declare const removeDecorationsFromSet: (decorationSet: DecorationSet, decorationsToRemove: Decoration[], doc: PmNode) => DecorationSet;
+export declare const removeMatchesFromSet: (decorationSet: DecorationSet, matches: Match[], doc: PmNode) => DecorationSet;
+/**
+ * Finds decorations in prevDecorations that are not in newDecorations or decorationsToRemove
+ * These decorations have been lost by Prosemirror during an over eager decoration removal
+ * We need to be smart to cope with thousands of decorations without crashing everything
+ */
+export declare const findLostAdjacentDecorations: (decorationsToRemove: Decoration[], prevDecorations: Decoration[], newDecorations: Decoration[]) => Decoration[];
+/**
+ * Searches through array in bumps of 100 to return the index of the first
+ * decoration whose 'from' value is before or equal to the position
+ */
+export declare const findIndexBeforePosition: (items: Decoration[], position: number) => number;
+/**
+ * Determines whether a find/replace text Match will be changed as a result
+ * of a Step modification to the document. This is evaluated by checking
+ * both mapped and unmapped versions of the Step as in different cases the
+ * matches will match.
+ *
+ * **Note:** Match state received here is after step has been applied.
+ */
+export declare const isMatchAffectedByStep: (match: Match, step: Step & {
+    from: number;
+    to: number;
+    slice: Slice;
+}, tr: ReadonlyTransaction) => boolean;

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

@@ -0,0 +1,3 @@
+import { NextEditorPlugin } from '@atlaskit/editor-common/types';
+declare const fragmentMarkPlugin: NextEditorPlugin<'fragmentPlugin'>;
+export default fragmentMarkPlugin;

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

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

package/dist/types-ts4.5/plugins/fragment/pm-plugins/fragment-consistency.d.ts

@@ -0,0 +1,15 @@
+/**
+ * This plugin ensures that certain nodes (such as tables, and various extension ones)
+ * have a unique `localId` attribute value for `fragment` marks.
+ * It also ensures the preservation of these IDs when nodes are being cut-and-pasted
+ * around the document.
+ *
+ * The implementation has been _heavily_ borrowed from
+ * - packages/editor/editor-core/src/plugins/table/pm-plugins/table-local-id.ts
+ */
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { Dispatch } from '../../../event-dispatcher';
+/**
+ * Ensures presence of `fragment` mark on certain node types and the uniqueness of their `localId` attributes
+ */
+export declare const createPlugin: (dispatch: Dispatch) => SafePlugin<any>;

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

@@ -0,0 +1,8 @@
+export declare enum HistoryActionTypes {
+    UPDATE = "UPDATE"
+}
+export interface HistoryAction {
+    type: HistoryActionTypes.UPDATE;
+    canUndo: boolean;
+    canRedo: boolean;
+}

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

@@ -0,0 +1,13 @@
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+import type { NextEditorPlugin } from '@atlaskit/editor-common/types';
+import type { HistoryPluginState } from './types';
+/**
+ * Plugin that keeps track of whether undo and redo are currently available
+ * This is needed so we can enable/disable controls appropriately
+ *
+ * Actual undo/redo functionality is handled by prosemirror-history:
+ * https://github.com/ProseMirror/prosemirror-history
+ */
+export declare const historyPluginKey: PluginKey<HistoryPluginState>;
+declare const historyPlugin: NextEditorPlugin<'history'>;
+export default historyPlugin;

package/dist/types-ts4.5/plugins/history/pm-history-types.d.ts

@@ -0,0 +1,17 @@
+import type { StepMap, Step } from '@atlaskit/editor-prosemirror/transform';
+export interface PmHistoryItem {
+    map: StepMap;
+    step: Step;
+}
+export interface PmHistoryLeaf {
+    values: PmHistoryItem[];
+    length: number;
+}
+export interface PmHistoryBranch {
+    items: PmHistoryLeaf;
+    eventCount: number;
+}
+export interface PmHistoryPluginState {
+    done: PmHistoryBranch;
+    undone: PmHistoryBranch;
+}

package/dist/types-ts4.5/plugins/history/reducer.d.ts

@@ -0,0 +1,4 @@
+import { HistoryAction } from './actions';
+import { HistoryPluginState } from './types';
+declare const reducer: (state: HistoryPluginState, action: HistoryAction) => HistoryPluginState;
+export default reducer;

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

@@ -0,0 +1,4 @@
+export interface HistoryPluginState {
+    canUndo: boolean;
+    canRedo: boolean;
+}

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

@@ -0,0 +1,4 @@
+import type { Plugin, EditorState } from '@atlaskit/editor-prosemirror/state';
+import type { PmHistoryPluginState } from './pm-history-types';
+export declare const getPmHistoryPlugin: (state: EditorState) => Plugin | undefined;
+export declare const getPmHistoryPluginState: (state: EditorState) => PmHistoryPluginState | undefined;

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

@@ -0,0 +1,8 @@
+import type { Node as PmNode, Schema } from '@atlaskit/editor-prosemirror/model';
+import type { Command } from '../../../types/command';
+import type { IndentationInputMethod } from './utils';
+export declare const MAX_INDENTATION_LEVEL = 6;
+export declare const isIndentationAllowed: (schema: Schema, node: PmNode) => boolean;
+export declare const getIndentCommand: (inputMethod?: IndentationInputMethod) => Command;
+export declare const getOutdentCommand: (inputMethod?: IndentationInputMethod) => Command;
+export declare const removeIndentation: Command;

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

@@ -0,0 +1,36 @@
+import type { IndentationMarkAttributes } from '@atlaskit/adf-schema';
+import type { INDENT_DIRECTION, INPUT_METHOD } from '../../analytics';
+import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { GetAttrsChange } from '../../../utils/getAttrsWithChangesRecorder';
+export type PrevAttributes = IndentationMarkAttributes | undefined;
+export type NewAttributes = IndentationMarkAttributes | undefined | false;
+export type IndentationChangesOptions = {
+    direction: INDENT_DIRECTION;
+};
+export type IndentationInputMethod = INPUT_METHOD.KEYBOARD | INPUT_METHOD.TOOLBAR;
+/**
+ * Get the current indentation level given prev and new attributes
+ * @param prevAttrs - Previous attributes from indentation
+ * @param newAttrs - New attributes from indentation
+ */
+export declare function getNewIndentLevel(prevAttrs: PrevAttributes, newAttrs: NewAttributes): number;
+/**
+ * Get the previous indentation level  prev attributes
+ * @param prevAttrs - Previous attributes from indentation
+ */
+export declare function getPrevIndentLevel(prevAttrs: PrevAttributes): number;
+/**
+ * Create a new dispatch function who add analytics events given a list of attributes changes
+ *
+ * @export
+ * @param {*} getAttrsChanges
+ * @param {*} state
+ * @param dispatch
+ * @returns
+ */
+export declare function createAnalyticsDispatch({ getAttrsChanges, inputMethod, state, dispatch, }: {
+    getAttrsChanges: () => GetAttrsChange<IndentationMarkAttributes, IndentationChangesOptions>[];
+    inputMethod: IndentationInputMethod;
+    state: EditorState;
+    dispatch?: (tr: Transaction) => void;
+}): (tr: Transaction) => void;

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

@@ -0,0 +1,3 @@
+import { NextEditorPlugin } from '@atlaskit/editor-common/types';
+declare const indentationPlugin: NextEditorPlugin<'indentation'>;
+export default indentationPlugin;

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

@@ -0,0 +1,12 @@
+export declare const messages: {
+    indent: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    outdent: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};

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

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

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

@@ -0,0 +1,43 @@
+export { default as betterTypeHistoryPlugin } from './better-type-history';
+export { default as clearMarksOnChangeToEmptyDocumentPlugin } from './clear-marks-on-change-to-empty-document';
+export { default as codeBlockPlugin } from './code-block';
+export { default as collabEditPlugin } from './collab-edit';
+export { datePlugin } from './date';
+export { default as extensionPlugin } from './extension';
+export { default as fakeTextCursorPlugin } from './fake-text-cursor';
+export { default as insertBlockPlugin } from './insert-block';
+export { default as jiraIssuePlugin } from './jira-issue';
+export { default as layoutPlugin } from './layout';
+export { default as toolbarListsIndentationPlugin } from './toolbar-lists-indentation';
+export { default as macroPlugin } from './macro';
+export { default as maxContentSizePlugin } from './max-content-size';
+export { default as mentionsPlugin } from './mentions';
+export { default as panelPlugin } from './panel';
+export { default as pastePlugin } from './paste';
+export { default as placeholderTextPlugin } from './placeholder-text';
+export { default as saveOnEnterPlugin } from './save-on-enter';
+export { default as submitEditorPlugin } from './submit-editor';
+export { default as tasksAndDecisionsPlugin } from './tasks-and-decisions';
+export { default as textColorPlugin } from './text-color';
+export { default as typeAheadPlugin } from './type-ahead';
+export { default as statusPlugin } from './status';
+export { default as breakoutPlugin } from './breakout';
+export { default as alignmentPlugin } from './alignment';
+export { default as dataConsumerMarkPlugin } from './data-consumer';
+export { default as fragmentMarkPlugin } from './fragment';
+export { default as indentationPlugin } from './indentation';
+export { default as annotationPlugin } from './annotation';
+export { default as analyticsPlugin } from './analytics';
+export { default as customAutoformatPlugin } from './custom-autoformat';
+export { default as feedbackDialogPlugin } from './feedback-dialog';
+export { default as historyPlugin } from './history';
+export { default as expandPlugin, isExpandInsertionEnabled } from './expand';
+export { default as scrollIntoViewPlugin } from './scroll-into-view';
+export { default as mobileDimensionsPlugin } from './mobile-dimensions';
+export { default as findReplacePlugin } from './find-replace';
+export { default as mobileSelectionPlugin } from './mobile-selection';
+export { default as undoRedoPlugin } from './undo-redo';
+export { default as avatarGroupPlugin } from './avatar-group';
+export { default as viewUpdateSubscriptionPlugin } from './view-update-subscription';
+export { default as beforePrimaryToolbarPlugin } from './before-primaryToolbar';
+export { default as codeBidiWarningPlugin } from './code-bidi-warning';

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

@@ -0,0 +1,16 @@
+import type { NextEditorPlugin } from '@atlaskit/editor-common/types';
+import type { InsertBlockPluginDependencies } from './types';
+export interface InsertBlockOptions {
+    allowTables?: boolean;
+    allowExpand?: boolean;
+    insertMenuItems?: any;
+    horizontalRuleEnabled?: boolean;
+    nativeStatusSupported?: boolean;
+    replacePlusMenuWithElementBrowser?: boolean;
+    showElementBrowserLink?: boolean;
+}
+declare const insertBlockPlugin: NextEditorPlugin<'insertBlock', {
+    pluginConfiguration: InsertBlockOptions | undefined;
+    dependencies: InsertBlockPluginDependencies;
+}>;
+export default insertBlockPlugin;

package/dist/types-ts4.5/plugins/insert-block/types.d.ts

@@ -0,0 +1,35 @@
+import type { OptionalPlugin } from '@atlaskit/editor-common/types';
+import type { ImageUploadPlugin } from '@atlaskit/editor-plugin-image-upload';
+import type { EmojiPlugin } from '@atlaskit/editor-plugin-emoji';
+import type { DatePlugin } from '../date';
+import type { tablesPlugin } from '@atlaskit/editor-plugin-table';
+import type { hyperlinkPlugin } from '@atlaskit/editor-plugin-hyperlink';
+import type { FeatureFlagsPlugin } from '@atlaskit/editor-plugin-feature-flags';
+import type { analyticsPlugin } from '@atlaskit/editor-plugin-analytics';
+import type mentionsPlugin from '../mentions';
+import type { QuickInsertPlugin } from '@atlaskit/editor-plugin-quick-insert';
+import type { BlockTypePlugin } from '@atlaskit/editor-plugin-block-type';
+import type codeBlockPlugin from '../code-block';
+import type panelPlugin from '../panel';
+import type { RulePlugin } from '@atlaskit/editor-plugin-rule';
+import type { MediaPlugin } from '@atlaskit/editor-plugin-media';
+import type { MentionPlugin } from '../mentions';
+import type { StatusPlugin } from '../status';
+export type InsertBlockPluginDependencies = [
+    FeatureFlagsPlugin,
+    OptionalPlugin<typeof tablesPlugin>,
+    OptionalPlugin<typeof hyperlinkPlugin>,
+    OptionalPlugin<DatePlugin>,
+    OptionalPlugin<BlockTypePlugin>,
+    OptionalPlugin<typeof analyticsPlugin>,
+    OptionalPlugin<ImageUploadPlugin>,
+    OptionalPlugin<typeof mentionsPlugin>,
+    OptionalPlugin<EmojiPlugin>,
+    OptionalPlugin<QuickInsertPlugin>,
+    OptionalPlugin<RulePlugin>,
+    OptionalPlugin<typeof codeBlockPlugin>,
+    OptionalPlugin<typeof panelPlugin>,
+    OptionalPlugin<MediaPlugin>,
+    OptionalPlugin<MentionPlugin>,
+    OptionalPlugin<StatusPlugin>
+];

package/dist/types-ts4.5/plugins/insert-block/ui/ToolbarInsertBlock/block-insert-element-browser.d.ts

@@ -0,0 +1,28 @@
+import React from 'react';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { BlockMenuItem } from './create-items';
+import type { OnInsert } from '../../../../ui/ElementBrowser/types';
+import type { PluginInjectionAPIWithDependencies } from '@atlaskit/editor-common/types';
+import type { InsertBlockPluginDependencies } from '../../types';
+type SimpleEventHandler<T> = (event?: T) => void;
+export interface BlockInsertElementBrowserProps {
+    disabled: boolean;
+    editorView: EditorView;
+    items: BlockMenuItem[];
+    spacing: 'none' | 'default';
+    label: string;
+    open: boolean;
+    popupsBoundariesElement?: HTMLElement;
+    popupsMountPoint?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    plusButtonRef?: HTMLElement;
+    showElementBrowserLink: boolean;
+    onRef(el: HTMLElement): void;
+    onClick: React.MouseEventHandler;
+    onKeyDown?: React.KeyboardEventHandler;
+    onInsert: OnInsert;
+    togglePlusMenuVisibility: SimpleEventHandler<MouseEvent | KeyboardEvent>;
+    pluginInjectionApi: PluginInjectionAPIWithDependencies<InsertBlockPluginDependencies> | undefined;
+}
+export declare const BlockInsertElementBrowser: React.FC<BlockInsertElementBrowserProps>;
+export {};

package/dist/types-ts4.5/plugins/insert-block/ui/ToolbarInsertBlock/block-insert-menu-legacy.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import type { BlockMenuItem } from './create-items';
+export interface BlockInsertMenuLegacyProps {
+    disabled: boolean;
+    spacing: 'none' | 'default';
+    label: string;
+    open: boolean;
+    items: BlockMenuItem[];
+    popupsMountPoint?: HTMLElement;
+    popupsBoundariesElement?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    onClick: React.MouseEventHandler;
+    onKeyDown?: React.KeyboardEventHandler;
+    onRef(el: HTMLElement): void;
+    onItemActivated(attrs: any): void;
+    onOpenChange(attrs: any): void;
+}
+export declare const BlockInsertMenuLegacy: React.FC<BlockInsertMenuLegacyProps>;

package/dist/types-ts4.5/plugins/insert-block/ui/ToolbarInsertBlock/block-insert-menu.d.ts

@@ -0,0 +1,30 @@
+import React from 'react';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { OnInsert } from '../../../../ui/ElementBrowser/types';
+import type { BlockMenuItem } from './create-items';
+import type { PluginInjectionAPIWithDependencies } from '@atlaskit/editor-common/types';
+import type { InsertBlockPluginDependencies } from '../../types';
+export interface BlockInsertMenuProps {
+    disabled: boolean;
+    editorView: EditorView;
+    items: BlockMenuItem[];
+    label: string;
+    open: boolean;
+    plusButtonRef?: HTMLElement;
+    popupsBoundariesElement?: HTMLElement;
+    popupsMountPoint?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    replacePlusMenuWithElementBrowser: boolean;
+    spacing: 'none' | 'default';
+    showElementBrowserLink: boolean;
+    onRef(el: HTMLElement): void;
+    onPlusButtonRef(el: HTMLElement): void;
+    onClick: React.MouseEventHandler;
+    onItemActivated(attrs: any): void;
+    onInsert: OnInsert;
+    onOpenChange(attrs: any): void;
+    togglePlusMenuVisibility(): void;
+    onKeyDown?: React.KeyboardEventHandler;
+    pluginInjectionApi: PluginInjectionAPIWithDependencies<InsertBlockPluginDependencies> | undefined;
+}
+export declare const BlockInsertMenu: React.FC<BlockInsertMenuProps>;