@atlaskit/editor-core 187.31.5 → 187.31.6

package/tmp/api-report-tmp.d.ts

@@ -0,0 +1,1897 @@
+## API Report File for "@atlaskit/editor-core"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+/// <reference types="node" />
+/// <reference types="react" />
+
+import { AbstractMentionResource } from '@atlaskit/mention/resource';
+import { ACTION } from '@atlaskit/editor-common/analytics';
+import { ACTION_SUBJECT } from '@atlaskit/editor-common/analytics';
+import { ACTION_SUBJECT_ID } from '@atlaskit/editor-common/analytics';
+import type { ActivityProvider } from '@atlaskit/activity-provider';
+import type { AllEditorPresetPluginTypes } from '@atlaskit/editor-common/types';
+import type { AllowedBlockTypes } from '@atlaskit/editor-common/types';
+import { AnalyticsEventPayload } from '@atlaskit/editor-common/analytics';
+import type { AnalyticsEventPayload as AnalyticsEventPayload_2 } from '@atlaskit/analytics-next/AnalyticsEvent';
+import type { AnalyticsPlugin } from '@atlaskit/editor-plugin-analytics';
+import type { AnnotationTypes } from '@atlaskit/adf-schema';
+import { BrowserFreezetracking } from '@atlaskit/editor-common/types';
+import type { CardOptions } from '@atlaskit/editor-common/card';
+import { CardProvider } from '@atlaskit/editor-common/provider-factory';
+import { clearEditorContent } from '@atlaskit/editor-common/commands';
+import type { CollabEditOptions } from '@atlaskit/editor-common/collab';
+import { Color } from '@atlaskit/status/element';
+import { Command as Command_2 } from '@atlaskit/editor-common/types';
+import { ComponentType } from 'react';
+import type { ConfigWithNodeInfo } from '@atlaskit/editor-plugin-floating-toolbar';
+import type { ContextIdentifierProvider } from '@atlaskit/editor-common/provider-factory';
+import type { ContextUpdateHandler } from '@atlaskit/editor-common/types';
+import { createTable } from '@atlaskit/editor-plugin-table/commands';
+import type { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { darkModeStatusColorPalette } from '@atlaskit/editor-common/ui-color';
+import type { DecorationSet } from '@atlaskit/editor-prosemirror/view';
+import type { DecorationsPlugin } from '@atlaskit/editor-plugin-decorations';
+import { dedupe } from '@atlaskit/editor-common/utils';
+import { DEFAULT_BORDER_COLOR } from '@atlaskit/editor-common/ui-color';
+import type { DirectEditorProps } from '@atlaskit/editor-prosemirror/view';
+import { Dispatch } from '@atlaskit/editor-common/event-dispatcher';
+import type { DispatchAnalyticsEvent } from '@atlaskit/editor-common/analytics';
+import type { EditorActionsOptions } from '@atlaskit/editor-common/types';
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import { EditorAppearance } from '@atlaskit/editor-common/types';
+import type { EditorDisabledPlugin } from '@atlaskit/editor-plugin-editor-disabled';
+import { FeatureFlags as EditorFeatureFlags } from '@atlaskit/editor-common/types';
+import { EditorPlugin } from '@atlaskit/editor-common/types';
+import type { EditorPresetBuilder } from '@atlaskit/editor-common/preset';
+import { EditorReactContext } from '@atlaskit/editor-common/types';
+import type { EditorSelectionAPI } from '@atlaskit/editor-common/selection';
+import { EditorState } from '@atlaskit/editor-prosemirror/state';
+import { EditorView } from '@atlaskit/editor-prosemirror/view';
+import { EmojiResource } from '@atlaskit/emoji/resource';
+import { EmptyStateHandler } from '@atlaskit/editor-common/types';
+import type { ErrorReporter } from '@atlaskit/editor-common/utils';
+import type { ErrorReportingHandler } from '@atlaskit/editor-common/utils';
+import { EVENT_TYPE } from '@atlaskit/editor-common/analytics';
+import { EventDispatcher } from '@atlaskit/editor-common/event-dispatcher';
+import { EventEmitter as EventEmitter_2 } from 'events';
+import { ExperienceStore } from '@atlaskit/editor-common/ufo';
+import type { ExtensionHandlers } from '@atlaskit/editor-common/extensions';
+import type { ExtensionProvider } from '@atlaskit/editor-common/extensions';
+import { ExtensionType } from '@atlaskit/editor-common/provider-factory';
+import { FC } from 'react';
+import type { FeatureFlagsPlugin } from '@atlaskit/editor-plugin-feature-flags';
+import type { FireAnalyticsCallback } from '@atlaskit/editor-common/analytics';
+import type { FloatingToolbarPlugin } from '@atlaskit/editor-plugin-floating-toolbar';
+import type { FocusPlugin } from '@atlaskit/editor-plugin-focus';
+import { FULL_WIDTH_MODE } from '@atlaskit/editor-common/analytics';
+import { GapCursorSelection } from '@atlaskit/editor-common/selection';
+import { Side as GapCursorSide } from '@atlaskit/editor-common/selection';
+import type { GetEditorFeatureFlags } from '@atlaskit/editor-common/types';
+import type { GridPlugin } from '@atlaskit/editor-plugin-grid';
+import type { GuidelinePlugin } from '@atlaskit/editor-plugin-guideline';
+import type { HeadingLevelsAndNormalText } from '@atlaskit/editor-common/types';
+import type { HyperlinkPluginOptions } from '@atlaskit/editor-common/types';
+import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import type { InputMethodInsertMedia } from '@atlaskit/editor-common/analytics';
+import { InputTracking } from '@atlaskit/editor-common/types';
+import { JSONDocNode } from '@atlaskit/editor-json-transformer/types';
+import { jsx } from '@emotion/react';
+import { lightModeStatusColorPalette } from '@atlaskit/editor-common/ui-color';
+import type { LinkingOptions } from '@atlaskit/editor-common/types';
+import type { LongPressSelectionPluginOptions } from '@atlaskit/editor-common/types';
+import { MacroAttributes } from '@atlaskit/editor-common/provider-factory';
+import { MacroProvider } from '@atlaskit/editor-common/provider-factory';
+import { MarkConfig } from '@atlaskit/editor-common/types';
+import { MediaClientConfig } from '@atlaskit/media-core';
+import type { MediaFeatureFlags } from '@atlaskit/media-common';
+import { MediaFeatureFlags as MediaFeatureFlags_2 } from '@atlaskit/media-common/mediaFeatureFlags';
+import type { MediaFile } from '@atlaskit/media-picker/types';
+import type { MediaProvider as MediaProvider_2 } from '@atlaskit/editor-common/provider-factory';
+import type { MentionDescription } from '@atlaskit/mention';
+import { MentionProvider } from '@atlaskit/mention/resource';
+import type { MentionProvider as MentionProvider_2 } from '@atlaskit/mention';
+import { MentionResource } from '@atlaskit/mention/resource';
+import type { MenuItem } from '@atlaskit/editor-common/ui-menu';
+import type { MessageDescriptor } from 'react-intl-next';
+import { default as messages } from '@atlaskit/editor-common/messages';
+import type { NextEditorPlugin } from '@atlaskit/editor-common/types';
+import { Node as Node_2 } from '@atlaskit/editor-prosemirror/model';
+import { NodeConfig } from '@atlaskit/editor-common/types';
+import type { NodeType } from '@atlaskit/editor-prosemirror/model';
+import type { NodeView } from '@atlaskit/editor-prosemirror/view';
+import type { OptionalPlugin } from '@atlaskit/editor-common/types';
+import { PaletteColor } from '@atlaskit/editor-common/ui-color';
+import { PerformanceTracking } from '@atlaskit/editor-common/types';
+import type { PluginConfig } from '@atlaskit/editor-plugin-table/types';
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+import { PMPlugin } from '@atlaskit/editor-common/types';
+import { PortalProvider } from '@atlaskit/editor-common/portal-provider';
+import { PortalProviderAPI } from '@atlaskit/editor-common/portal-provider';
+import { PortalRenderer } from '@atlaskit/editor-common/portal-provider';
+import { PositionType } from '@atlaskit/tooltip/types';
+import { PresenceProvider } from '@atlaskit/mention/resource';
+import { PresenceResource } from '@atlaskit/mention/resource';
+import PropTypes from 'prop-types';
+import type { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import type { Providers } from '@atlaskit/editor-common/provider-factory';
+import type { PublicPluginAPI } from '@atlaskit/editor-common/types';
+import { QuickInsertItem } from '@atlaskit/editor-common/provider-factory';
+import type { QuickInsertOptions } from '@atlaskit/editor-common/types';
+import type { QuickInsertPluginOptions } from '@atlaskit/editor-common/types';
+import { QuickInsertProvider } from '@atlaskit/editor-common/provider-factory';
+import { default as React_2 } from 'react';
+import type { ReactElement } from 'react';
+import type { ReactHookFactory } from '@atlaskit/editor-common/types';
+import type { ReplaceRawValue } from '@atlaskit/editor-common/types';
+import type { ResolvedEditorState } from '@atlaskit/editor-common/collab';
+import type { RichMediaLayout } from '@atlaskit/adf-schema';
+import type { Schema } from '@atlaskit/editor-prosemirror/model';
+import type { SearchProvider } from '@atlaskit/editor-common/provider-factory';
+import { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
+import { setTextSelection } from '@atlaskit/editor-common/utils';
+import type { SEVERITY } from '@atlaskit/editor-common/utils';
+import type { TaskDecisionProvider } from '@atlaskit/task-decision';
+import { TeamMentionResource } from '@atlaskit/mention/team-resource';
+import { InputMethodBasic as TextFormattingInputMethodBasic } from '@atlaskit/editor-common/types';
+import { InputMethodToolbar as TextFormattingInputMethodToolbar } from '@atlaskit/editor-common/types';
+import type { TextFormattingOptions } from '@atlaskit/editor-common/types';
+import { ToolbarUIComponentFactory } from '@atlaskit/editor-common/types';
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+import { TransactionTracking } from '@atlaskit/editor-common/types';
+import type { Transformer as Transformer_2 } from '@atlaskit/editor-common/types';
+import type { TypeAheadHandler } from '@atlaskit/editor-common/types';
+import type { TypeAheadInputMethod } from '@atlaskit/editor-plugin-type-ahead';
+import { TypeAheadItem } from '@atlaskit/editor-common/provider-factory';
+import type { TypeAheadItem as TypeAheadItem_2 } from '@atlaskit/editor-common/types';
+import type { TypeAheadPluginOptions } from '@atlaskit/editor-plugin-type-ahead';
+import type { TypeAheadStats } from '@atlaskit/editor-common/types';
+import { UIComponentFactory } from '@atlaskit/editor-common/types';
+import { UploadEndEventPayload } from '@atlaskit/media-picker/types';
+import { UploadErrorEventPayload } from '@atlaskit/media-picker/types';
+import { UploadParams } from '@atlaskit/media-picker/types';
+import { UploadPreviewUpdateEventPayload } from '@atlaskit/media-picker/types';
+import type { UseStickyToolbarType } from '@atlaskit/editor-common/ui';
+import type { WeekDay } from '@atlaskit/calendar/types';
+import type { WidthPlugin } from '@atlaskit/editor-plugin-width';
+import type { WidthPluginState } from '@atlaskit/editor-plugin-width';
+import { WithIntlProps } from 'react-intl-next';
+import { WithPluginState } from '@atlaskit/editor-common/with-plugin-state';
+import { WrappedComponentProps } from 'react-intl-next';
+
+export { AbstractMentionResource }
+
+export { ACTION }
+
+export { ACTION_SUBJECT }
+
+export { ACTION_SUBJECT_ID }
+
+// @public (undocumented)
+type AddItemTransactionCreator = (opts: {
+    state: EditorState;
+    tr: Transaction;
+    list: NodeType;
+    item: NodeType;
+    listLocalId: string;
+    itemLocalId: string;
+}) => Transaction | null;
+
+// @public (undocumented)
+interface AllSelectionData {
+    // (undocumented)
+    type: 'all';
+}
+
+export { AnalyticsEventPayload }
+
+// @public (undocumented)
+type AnnotationComponentProps = {
+    textSelection?: string;
+    dom?: HTMLElement;
+    onClose?: () => void;
+};
+
+// @public (undocumented)
+export type AnnotationInfo = {
+    id: string;
+    type: AnnotationTypes.INLINE_COMMENT;
+};
+
+// @public (undocumented)
+export interface AnnotationProviders {
+    // (undocumented)
+    inlineComment: InlineCommentAnnotationProvider;
+}
+
+// @public (undocumented)
+export interface AnnotationState<Type, State> {
+    // (undocumented)
+    annotationType: Type;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    state: State;
+}
+
+// @public (undocumented)
+export interface AnnotationTypeProvider<Type, State> {
+    // (undocumented)
+    disallowOnWhitespace?: boolean;
+    // (undocumented)
+    getState: (annotationIds: string[]) => Promise<AnnotationState<Type, State>[]>;
+    // (undocumented)
+    updateSubscriber?: AnnotationUpdateEmitter;
+}
+
+// @public (undocumented)
+export class AnnotationUpdateEmitter extends EventEmitter_2 {
+    // (undocumented)
+    on(event: VisibilityEvent, listener: (isVisible: boolean) => void): this;
+    // (undocumented)
+    on(event: UpdateEvent, listener: (annotationId: string) => void): this;
+}
+
+// @public (undocumented)
+interface BasePluginOptions {
+    // (undocumented)
+    allowInlineCursorTarget?: boolean;
+    // (undocumented)
+    allowScrollGutter?: ScrollGutterPluginOptions;
+    // (undocumented)
+    browserFreezeTracking?: BrowserFreezetracking;
+    // (undocumented)
+    inputTracking?: InputTracking;
+    // (undocumented)
+    ufo?: boolean;
+}
+
+// @public (undocumented)
+export class BaseReactEditorView<T = {}> extends ReactEditorView_2<T> {
+}
+
+// @public (undocumented)
+type BeforeAndAfterToolbarComponents = {
+    before: ReactComponents;
+    after: ReactComponents;
+};
+
+// @public (undocumented)
+export const blockPluginStateKey: PluginKey<BlockTypeState>;
+
+// @public (undocumented)
+interface BlockType {
+    // (undocumented)
+    level?: HeadingLevelsAndNormalText;
+    // (undocumented)
+    name: string;
+    // (undocumented)
+    nodeName: string;
+    // (undocumented)
+    tagName?: string;
+    // (undocumented)
+    title: MessageDescriptor;
+}
+
+// @public (undocumented)
+export type BlockTypeInputMethod = INPUT_METHOD.FORMATTING | INPUT_METHOD.INSERT_MENU | INPUT_METHOD.KEYBOARD | INPUT_METHOD.SHORTCUT | INPUT_METHOD.TOOLBAR;
+
+// @public (undocumented)
+interface BlockTypePluginOptions {
+    // (undocumented)
+    allowBlockType?: {
+        exclude?: Array<AllowedBlockTypes>;
+    };
+    // (undocumented)
+    isUndoRedoButtonsEnabled?: boolean;
+    // (undocumented)
+    lastNodeMustBeParagraph?: boolean;
+}
+
+// @public (undocumented)
+export type BlockTypeState = {
+    currentBlockType: BlockType;
+    blockTypesDisabled: boolean;
+    availableBlockTypes: BlockType[];
+    availableWrapperBlockTypes: BlockType[];
+};
+
+export { CardProvider }
+
+// @public (undocumented)
+interface CellSelectionData {
+    // (undocumented)
+    anchor: number;
+    // (undocumented)
+    head: number;
+    // (undocumented)
+    type: 'cell';
+}
+
+// @public (undocumented)
+export const changeColor: (color: string) => Command;
+
+export { clearEditorContent }
+
+// @public (undocumented)
+type CloseOptions = {
+    insertCurrentQueryAsRawText: boolean;
+    attachCommand?: Command;
+};
+
+// @public (undocumented)
+interface CodeBlockOptions extends LongPressSelectionPluginOptions {
+    // (undocumented)
+    allowCompositionInputOverride?: boolean;
+    // (undocumented)
+    allowCopyToClipboard?: boolean;
+    // (undocumented)
+    appearance?: EditorAppearance | undefined;
+}
+
+// @public (undocumented)
+export class CollapsedEditor extends React_2.Component<Props, State> {
+    // (undocumented)
+    componentDidUpdate(): void;
+    // (undocumented)
+    editorComponent?: Editor;
+    // (undocumented)
+    functionalEditor?: boolean;
+    // (undocumented)
+    handleEditorRef: (editorRef?: Editor, editorRefCallback?: any) => void;
+    // (undocumented)
+    previouslyExpanded?: boolean;
+    // (undocumented)
+    render(): any;
+}
+
+// @public (undocumented)
+export type Command = (state: EditorState, dispatch?: CommandDispatch, view?: EditorView) => boolean;
+
+// @public (undocumented)
+export type CommandDispatch = (tr: Transaction) => void;
+
+// @public (undocumented)
+export const commitStatusPicker: () => (editorView: EditorView) => void;
+
+// @public (undocumented)
+export function ContextPanel(props: Props_4): jsx.JSX.Element;
+
+// @public (undocumented)
+interface CreateEditorStateOptions {
+    // (undocumented)
+    context: EditorReactContext;
+    // (undocumented)
+    doc?: Object | Node_2 | string;
+    // (undocumented)
+    props: EditorViewProps;
+    // (undocumented)
+    resetting?: boolean;
+    // (undocumented)
+    selectionAtStart?: boolean;
+}
+
+export { createTable }
+
+// @public (undocumented)
+export const createTypeAheadTools: (editorView: EditorView) => {
+    isOpen: () => TypeAheadHandler | false;
+    currentQuery: () => string | undefined;
+    close: (options?: CloseOptions) => boolean;
+    openMention: (inputMethod: TypeAheadInputMethod) => boolean;
+    searchMention: (query?: string) => {
+        type: (appendValue: string) => Promise<TypeAheadItem[]> | undefined;
+        result: () => Promise<TypeAheadItem[] | undefined>;
+        close: (options?: CloseOptions) => boolean;
+        insert: ({ index, mode }: {
+            index: number;
+            mode?: SelectItemMode | undefined;
+        }) => Promise<void>;
+    };
+    openQuickInsert: (inputMethod: TypeAheadInputMethod) => boolean;
+    searchQuickInsert: (query?: string) => {
+        type: (appendValue: string) => Promise<TypeAheadItem[]> | undefined;
+        result: () => Promise<TypeAheadItem[] | undefined>;
+        close: (options?: CloseOptions) => boolean;
+        insert: ({ index, mode }: {
+            index: number;
+            mode?: SelectItemMode | undefined;
+        }) => Promise<void>;
+    };
+    openEmoji: (inputMethod: TypeAheadInputMethod) => boolean;
+    searchEmoji: (query?: string) => {
+        type: (appendValue: string) => Promise<TypeAheadItem[]> | undefined;
+        result: () => Promise<TypeAheadItem[] | undefined>;
+        close: (options?: CloseOptions) => boolean;
+        insert: ({ index, mode }: {
+            index: number;
+            mode?: SelectItemMode | undefined;
+        }) => Promise<void>;
+    };
+    insertItemMention: ({ contentItem, query, sourceListItem }: InsertItemProps) => boolean;
+    insertItemEmoji: ({ contentItem, query, sourceListItem }: InsertItemProps) => boolean;
+    insertItemQuickInsert: ({ contentItem, query, sourceListItem }: InsertItemProps) => boolean;
+};
+
+// @public (undocumented)
+export interface CustomMediaPicker {
+    // (undocumented)
+    destroy(): void;
+    // (undocumented)
+    emit(event: string, data: any): void;
+    // (undocumented)
+    on(event: string, cb: Listener): void;
+    // (undocumented)
+    removeAllListeners(event: any): void;
+    // (undocumented)
+    setUploadParams(uploadParams: UploadParams): void;
+}
+
+export { darkModeStatusColorPalette }
+
+// @public (undocumented)
+export const dateMessages: {
+    editText: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};
+
+// @public (undocumented)
+interface DatePluginConfig {
+    // (undocumented)
+    weekStartDay?: WeekDay;
+}
+
+// @public (undocumented)
+export const datePluginKey: PluginKey<DatePluginState>;
+
+// @public (undocumented)
+export type DatePluginState = {
+    isQuickInsertAction?: boolean;
+    isNew: boolean;
+    showDatePickerAt: null | number;
+    isDateEmpty: boolean;
+    focusDateInput: boolean;
+};
+
+// @public
+export function dateToDateType(date: Date): DateType;
+
+// @public (undocumented)
+type DateType = {
+    year: number;
+    month: number;
+    day?: number;
+};
+
+export { dedupe }
+
+export { DEFAULT_BORDER_COLOR }
+
+// @public (undocumented)
+type DefaultPresetPluginOptions = {
+    paste: PastePluginOptions;
+    base?: BasePluginOptions;
+    blockType?: BlockTypePluginOptions;
+    placeholder?: PlaceholderPluginOptions;
+    textFormatting?: TextFormattingOptions;
+    submitEditor?: EditorProps['onSave'];
+    annotationProviders?: AnnotationProviders;
+    quickInsert?: QuickInsertPluginOptions;
+    codeBlock?: CodeBlockOptions;
+    selection?: SelectionPluginOptions;
+    cardOptions?: CardOptions;
+    hyperlinkOptions?: HyperlinkPluginOptions;
+    createAnalyticsEvent?: CreateUIAnalyticsEvent;
+    typeAhead?: TypeAheadPluginOptions;
+    allowAnalyticsGASV3?: boolean;
+    performanceTracking?: EditorProps['performanceTracking'];
+};
+
+// @public
+export const deleteDate: () => Command;
+
+// @public (undocumented)
+export class Editor extends React_2.Component<EditorProps> {
+    constructor(props: EditorProps);
+    // (undocumented)
+    static defaultProps: EditorProps;
+    // (undocumented)
+    render(): jsx.JSX.Element;
+}
+
+// @public (undocumented)
+export class EditorActions<T = any> implements EditorActionsOptions<T> {
+    // (undocumented)
+    __temporaryFixForConfigPanel(): Promise<void>;
+    // (undocumented)
+    appendText(text: string): boolean;
+    // (undocumented)
+    blur(): boolean;
+    // (undocumented)
+    clear(): boolean;
+    // (undocumented)
+    dispatchAnalyticsEvent: (payload: AnalyticsEventPayload_2) => void;
+    // (undocumented)
+    focus(): boolean;
+    // (undocumented)
+    static from<T>(view: EditorView, eventDispatcher: EventDispatcher, transformer?: Transformer_2<T>): EditorActions<T>;
+    // (undocumented)
+    getNodeByFragmentLocalId(id: string): Node_2 | undefined;
+    // (undocumented)
+    getNodeByLocalId(id: string): Node_2 | undefined;
+    getResolvedEditorState: () => Promise<ResolvedEditorState | undefined>;
+    getSelectedNode(): Node_2 | undefined;
+    // (undocumented)
+    getValue(): Promise<T | JSONDocNode | undefined>;
+    // (undocumented)
+    isDocumentEmpty(): boolean;
+    // (undocumented)
+    _privateGetEditorView(): EditorView | undefined;
+    // (undocumented)
+    _privateGetEventDispatcher(): EventDispatcher | undefined;
+    // (undocumented)
+    _privateRegisterEditor(editorView: EditorView, eventDispatcher: EventDispatcher, contentTransformer?: Transformer_2<T>, getFeatureFlags?: () => EditorFeatureFlags): void;
+    // (undocumented)
+    _privateSubscribe(cb: ContextUpdateHandler): void;
+    // (undocumented)
+    _privateUnregisterEditor(): void;
+    // (undocumented)
+    _privateUnsubscribe(cb: ContextUpdateHandler): void;
+    // (undocumented)
+    replaceDocument(rawValue: any, shouldScrollToBottom?: boolean,
+    shouldAddToHistory?: boolean): boolean;
+    // (undocumented)
+    replaceSelection(rawValue: Array<ReplaceRawValue> | ReplaceRawValue, tryToReplace?: boolean): boolean;
+}
+
+// @public (undocumented)
+interface EditorBaseProps {
+    // (undocumented)
+    appearance?: EditorAppearance;
+    // (undocumented)
+    assistiveLabel?: string;
+    // (undocumented)
+    contentComponents?: ReactComponents;
+    // (undocumented)
+    contentTransformerProvider?: (schema: Schema) => Transformer_2<string>;
+    // (undocumented)
+    contextPanel?: ReactComponents;
+    // (undocumented)
+    defaultValue?: Node_2 | Object | string;
+    // (undocumented)
+    disabled?: boolean;
+    // (undocumented)
+    editorActions?: EditorActions;
+    // (undocumented)
+    errorReporterHandler?: ErrorReportingHandler;
+    // (undocumented)
+    extensionProviders?: ExtensionProvidersProp;
+    featureFlags?: {
+        [featureFlag: string]: boolean | string;
+    };
+    // @deprecated
+    inputSamplingLimit?: number;
+    // (undocumented)
+    maxHeight?: number;
+    // (undocumented)
+    minHeight?: number;
+    // (undocumented)
+    onCancel?: (editorView: EditorView) => void;
+    // (undocumented)
+    onChange?: EditorOnChangeHandler;
+    // (undocumented)
+    onDestroy?: () => void;
+    // (undocumented)
+    onEditorReady?: (editorActions: EditorActions) => void;
+    // (undocumented)
+    persistScrollGutter?: boolean;
+    // (undocumented)
+    placeholder?: string;
+    // (undocumented)
+    placeholderBracketHint?: string;
+    // (undocumented)
+    popupsBoundariesElement?: HTMLElement;
+    // (undocumented)
+    popupsMountPoint?: HTMLElement;
+    // (undocumented)
+    popupsScrollableElement?: HTMLElement;
+    // (undocumented)
+    primaryToolbarIconBefore?: ReactElement;
+    // (undocumented)
+    quickInsert?: QuickInsertOptions;
+    // (undocumented)
+    secondaryToolbarComponents?: ReactComponents;
+    // (undocumented)
+    shouldFocus?: boolean;
+    trackValidTransactions?: boolean | {
+        samplingRate: number;
+    };
+    // (undocumented)
+    UNSAFE_useAnalyticsContext?: boolean;
+    useStickyToolbar?: UseStickyToolbarType;
+}
+
+// @public (undocumented)
+interface EditorConfig {
+    // (undocumented)
+    contentComponents: UIComponentFactory[];
+    // (undocumented)
+    marks: MarkConfig[];
+    // (undocumented)
+    nodes: NodeConfig[];
+    // (undocumented)
+    onEditorViewStateUpdatedCallbacks: Array<{
+        pluginName: string;
+        callback: (props: EditorViewStateUpdatedCallbackProps) => void;
+    }>;
+    // (undocumented)
+    pluginHooks: ReactHookFactory[];
+    // (undocumented)
+    pmPlugins: Array<PMPlugin>;
+    // (undocumented)
+    primaryToolbarComponents: ToolbarUIComponentFactory[];
+    // (undocumented)
+    secondaryToolbarComponents: UIComponentFactory[];
+}
+
+// @public (undocumented)
+export class EditorContext extends React_2.Component<EditorContextProps, {}> {
+    constructor(props: EditorContextProps);
+    // (undocumented)
+    static childContextTypes: {
+        editorActions: PropTypes.Requireable<object>;
+    };
+    // (undocumented)
+    getChildContext(): {
+        editorActions: EditorActions<any>;
+    };
+    // (undocumented)
+    render(): JSX.Element;
+}
+
+// @public (undocumented)
+type EditorContextProps = {
+    editorActions?: EditorActions;
+};
+
+export { EditorFeatureFlags }
+
+// @public (undocumented)
+export interface EditorInstance {
+    // (undocumented)
+    contentComponents: UIComponentFactory[];
+    // (undocumented)
+    contentTransformer?: Transformer<string>;
+    // (undocumented)
+    editorView: EditorView;
+    // (undocumented)
+    eventDispatcher: EventDispatcher;
+    // (undocumented)
+    insertMenuItems?: MenuItem[];
+    // (undocumented)
+    onEditorViewStateUpdatedCallbacks: {
+        pluginName: string;
+        callback: OnEditorViewStateUpdated;
+    }[];
+    // (undocumented)
+    primaryToolbarComponents: ToolbarUIComponentFactory[];
+    // (undocumented)
+    secondaryToolbarComponents: UIComponentFactory[];
+}
+
+// @public (undocumented)
+interface EditorNextProps extends EditorBaseProps, EditorSharedPropsWithPlugins, EditorProviderProps {
+    // (undocumented)
+    preset: EditorPresetBuilder<string[], AllEditorPresetPluginTypes[]>;
+}
+
+// @public (undocumented)
+type EditorOnChangeHandler = (editorView: EditorView, meta: {
+    source: 'local' | 'remote';
+}) => void;
+
+export { EditorPlugin }
+
+// @public (undocumented)
+interface EditorPluginFeatureProps {
+    // (undocumented)
+    allowAnalyticsGASV3?: boolean;
+    // (undocumented)
+    allowBlockType?: BlockTypePluginOptions['allowBlockType'];
+    // (undocumented)
+    allowBreakout?: boolean;
+    // (undocumented)
+    allowConfluenceInlineComment?: boolean;
+    // (undocumented)
+    allowDate?: DatePluginConfig | boolean;
+    // (undocumented)
+    allowExpand?: boolean | {
+        allowInsertion?: boolean;
+        allowInteractiveExpand?: boolean;
+    };
+    // (undocumented)
+    allowExtension?: ExtensionConfig | boolean;
+    // (undocumented)
+    allowFindReplace?: FindReplaceOptions | boolean;
+    allowFragmentMark?: boolean;
+    // (undocumented)
+    allowHelpDialog?: boolean;
+    // (undocumented)
+    allowIndentation?: boolean;
+    // (undocumented)
+    allowJiraIssue?: boolean;
+    // (undocumented)
+    allowLayouts?: LayoutPluginOptions | boolean;
+    // (undocumented)
+    allowNestedTasks?: boolean;
+    allowNewInsertionBehaviour?: boolean;
+    // (undocumented)
+    allowPanel?: PanelPluginConfig | boolean;
+    // (undocumented)
+    allowRule?: boolean;
+    // (undocumented)
+    allowStatus?: boolean | {
+        menuDisabled: boolean;
+    };
+    // (undocumented)
+    allowTables?: PluginConfig | boolean;
+    // (undocumented)
+    allowTasksAndDecisions?: boolean;
+    // (undocumented)
+    allowTemplatePlaceholders?: PlaceholderTextOptions | boolean;
+    // (undocumented)
+    allowTextAlignment?: boolean;
+    // (undocumented)
+    allowTextColor?: TextColorPluginConfig | boolean;
+    autoScrollIntoView?: boolean;
+    // (undocumented)
+    codeBlock?: CodeBlockOptions;
+    // (undocumented)
+    elementBrowser?: {
+        showModal?: boolean;
+        replacePlusMenu?: boolean;
+        helpUrl?: string;
+        emptyStateHandler?: EmptyStateHandler;
+    };
+    // (undocumented)
+    extensionHandlers?: ExtensionHandlers;
+    // (undocumented)
+    feedbackInfo?: FeedbackInfo;
+    // (undocumented)
+    insertMenuItems?: MenuItem[];
+    // (undocumented)
+    maxContentSize?: number;
+    // (undocumented)
+    mention?: MentionPluginConfig;
+    // @deprecated
+    mentionInsertDisplayName?: boolean;
+    // (undocumented)
+    saveOnEnter?: boolean;
+    // @deprecated (undocumented)
+    smartLinks?: CardOptions;
+    // (undocumented)
+    textFormatting?: TextFormattingOptions;
+    UNSAFE_allowBorderMark?: boolean;
+    // @deprecated (undocumented)
+    UNSAFE_cards?: CardOptions;
+    // (undocumented)
+    uploadErrorHandler?: (state: MediaState) => void;
+    // (undocumented)
+    waitForMediaUpload?: boolean;
+}
+
+// @public (undocumented)
+interface EditorPresetProps {
+    // (undocumented)
+    excludes?: Set<string>;
+    // (undocumented)
+    experimental?: Array<string>;
+    // (undocumented)
+    featureFlags?: EditorFeatureFlags;
+}
+
+// @public (undocumented)
+type EditorProduct = 'bitbucket' | 'confluence' | 'jira' | 'stride' | undefined;
+
+// @public (undocumented)
+export interface EditorProps extends EditorBaseProps, EditorPluginFeatureProps, EditorSharedPropsWithPlugins, EditorProviderProps {
+    // @deprecated (undocumented)
+    dangerouslyAppendPlugins?: {
+        __plugins: EditorPlugin[];
+    };
+}
+
+// @public (undocumented)
+interface EditorProviderProps {
+    // (undocumented)
+    activityProvider?: Promise<ActivityProvider>;
+    // (undocumented)
+    annotationProviders?: AnnotationProviders;
+    // (undocumented)
+    autoformattingProvider?: Providers['autoformattingProvider'];
+    // (undocumented)
+    collabEditProvider?: Providers['collabEditProvider'];
+    // (undocumented)
+    contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
+    // (undocumented)
+    emojiProvider?: Providers['emojiProvider'];
+    // (undocumented)
+    legacyImageUploadProvider?: Providers['imageUploadProvider'];
+    // (undocumented)
+    macroProvider?: Providers['macroProvider'];
+    // (undocumented)
+    mentionProvider?: Promise<MentionProvider>;
+    // (undocumented)
+    presenceProvider?: Promise<any>;
+    // (undocumented)
+    searchProvider?: Promise<SearchProvider>;
+    // (undocumented)
+    taskDecisionProvider?: Promise<TaskDecisionProvider>;
+}
+
+// @public (undocumented)
+interface EditorSharedPropsWithPlugins {
+    // (undocumented)
+    allowUndoRedoButtons?: boolean;
+    // (undocumented)
+    collabEdit?: CollabEditOptions;
+    linking?: LinkingOptions;
+    // (undocumented)
+    media?: MediaOptions;
+    // (undocumented)
+    onSave?: (editorView: EditorView) => void;
+    performanceTracking?: PerformanceTracking;
+    // (undocumented)
+    primaryToolbarComponents?: PrimaryToolbarComponents;
+    // (undocumented)
+    sanitizePrivateContent?: boolean;
+}
+
+// @public (undocumented)
+interface EditorViewProps {
+    // (undocumented)
+    createAnalyticsEvent?: CreateUIAnalyticsEvent;
+    // (undocumented)
+    disabled?: boolean;
+    // (undocumented)
+    editorProps: EditorNextProps | EditorProps;
+    // (undocumented)
+    experienceStore?: ExperienceStore;
+    // (undocumented)
+    onEditorCreated: (instance: {
+        view: EditorView;
+        config: EditorConfig;
+        eventDispatcher: EventDispatcher;
+        transformer?: Transformer_2<string>;
+    }) => void;
+    // (undocumented)
+    onEditorDestroyed: (instance: {
+        view: EditorView;
+        config: EditorConfig;
+        eventDispatcher: EventDispatcher;
+        transformer?: Transformer_2<string>;
+    }) => void;
+    // (undocumented)
+    portalProviderAPI: PortalProviderAPI;
+    // (undocumented)
+    preset: EditorPresetBuilder<string[], AllEditorPresetPluginTypes[]>;
+    // (undocumented)
+    providerFactory: ProviderFactory;
+    // (undocumented)
+    render?: (props: {
+        editor: JSX.Element;
+        view?: EditorView;
+        config: EditorConfig;
+        eventDispatcher: EventDispatcher;
+        transformer?: Transformer_2<string>;
+        dispatchAnalyticsEvent: DispatchAnalyticsEvent;
+        editorRef: React_2.RefObject<HTMLDivElement>;
+    }) => JSX.Element;
+    // (undocumented)
+    setEditorApi?: SetEditorAPI;
+}
+
+// @public (undocumented)
+type EditorViewStateUpdatedCallbackProps = {
+    readonly originalTransaction: Readonly<Transaction>;
+    readonly transactions: readonly Transaction[];
+    readonly oldEditorState: Readonly<EditorState>;
+    readonly newEditorState: Readonly<EditorState>;
+};
+
+export { EmojiResource }
+
+export { EVENT_TYPE }
+
+export { EventDispatcher }
+
+// @public (undocumented)
+interface ExtensionConfig {
+    // (undocumented)
+    allowAutoSave?: boolean;
+    // (undocumented)
+    allowBreakout?: boolean;
+    // (undocumented)
+    allowExtendFloatingToolbars?: boolean;
+}
+
+// @public (undocumented)
+type ExtensionProviders = (ExtensionProvider | Promise<ExtensionProvider>)[];
+
+// @public (undocumented)
+type ExtensionProvidersProp = ExtensionProviders | ExtensionProvidersWithEditorAction;
+
+// @public (undocumented)
+type ExtensionProvidersWithEditorAction = (editorActions?: EditorActions) => ExtensionProviders;
+
+export { ExtensionType }
+
+// @public (undocumented)
+type FeedbackInfo = {
+    product?: string;
+    packageVersion?: string;
+    packageName?: string;
+    labels?: Array<string>;
+    sessionId?: string;
+    contentId?: string;
+    tabId?: string;
+};
+
+// @public (undocumented)
+type FindReplaceOptions = {
+    allowMatchCase?: boolean;
+};
+
+export { GapCursorSelection }
+
+export { GapCursorSide }
+
+// @public (undocumented)
+interface GapSelectionData {
+    // (undocumented)
+    pos: number;
+    // (undocumented)
+    type: 'gapcursor';
+}
+
+// @public (undocumented)
+export function getDefaultPresetOptionsFromEditorProps(props: EditorProps, createAnalyticsEvent?: CreateUIAnalyticsEvent): EditorPresetProps & DefaultPresetPluginOptions & EditorPluginFeatureProps;
+
+// @public (undocumented)
+export function getNodesCount(node: Node_2): Record<string, number>;
+
+// @public (undocumented)
+type getPosHandler = boolean | getPosHandlerNode;
+
+// @public (undocumented)
+type getPosHandlerNode = () => number | undefined;
+
+// @public
+export const historyPluginKey: PluginKey<HistoryPluginState>;
+
+// @public (undocumented)
+export interface HistoryPluginState {
+    // (undocumented)
+    canRedo: boolean;
+    // (undocumented)
+    canUndo: boolean;
+}
+
+// @public (undocumented)
+export type InlineCommentAnnotationProvider = AnnotationTypeProvider<AnnotationTypes.INLINE_COMMENT, InlineCommentState> & {
+    createComponent?: React_2.ComponentType<InlineCommentCreateComponentProps>;
+    viewComponent?: React_2.ComponentType<InlineCommentViewComponentProps>;
+    isToolbarAbove?: boolean;
+};
+
+// @public (undocumented)
+export type InlineCommentCreateComponentProps = AnnotationComponentProps & {
+    onCreate: (id: string) => void;
+};
+
+// @public (undocumented)
+export type InlineCommentState = {
+    resolved: boolean;
+};
+
+// @public (undocumented)
+export type InlineCommentViewComponentProps = AnnotationComponentProps & {
+    annotations: Array<AnnotationInfo>;
+    onResolve: (id: string) => void;
+    onDelete?: (id: string) => void;
+    annotationsList?: string[];
+};
+
+export { INPUT_METHOD }
+
+// @public (undocumented)
+export type InsertBlockInputMethodToolbar = INPUT_METHOD.INSERT_MENU | INPUT_METHOD.TOOLBAR;
+
+// @public (undocumented)
+export function insertBlockType(name: string): Command_2;
+
+// @public (undocumented)
+export const insertBlockTypesWithAnalytics: (name: string, inputMethod: BlockTypeInputMethod, editorAnalyticsApi: EditorAnalyticsAPI | undefined) => Command_2;
+
+// @public (undocumented)
+export const insertDate: (date?: DateType, inputMethod?: InsertBlockInputMethodToolbar, commitMethod?: INPUT_METHOD.KEYBOARD | INPUT_METHOD.PICKER, enterPressed?: boolean) => Command;
+
+// @public (undocumented)
+export const insertExpand: Command;
+
+// @public (undocumented)
+export const insertHorizontalRule: (inputMethod: INPUT_METHOD.FORMATTING | INPUT_METHOD.INSERT_MENU | INPUT_METHOD.QUICK_INSERT | INPUT_METHOD.SHORTCUT | INPUT_METHOD.TOOLBAR, featureFlags: EditorFeatureFlags) => Command;
+
+// @public (undocumented)
+type InsertItemProps = {
+    contentItem: TypeAheadItem;
+    query: string;
+    sourceListItem: TypeAheadItem[];
+};
+
+// @public (undocumented)
+export const insertMediaSingleNode: (view: EditorView, mediaState: MediaState, inputMethod?: InputMethodInsertMedia, collection?: string, alignLeftOnInsert?: boolean, newInsertionBehaviour?: boolean, widthPluginState?: WidthPluginState | undefined, editorAnalyticsAPI?: EditorAnalyticsAPI | undefined) => boolean;
+
+// @public (undocumented)
+export const insertTaskDecisionCommand: (listType: TaskDecisionListType, inputMethod?: INPUT_METHOD.FORMATTING | INPUT_METHOD.QUICK_INSERT | InsertBlockInputMethodToolbar, addItem?: AddItemTransactionCreator, listLocalId?: string, itemLocalId?: string) => Command;
+
+// @public (undocumented)
+interface LayoutPluginOptions extends LongPressSelectionPluginOptions {
+    // (undocumented)
+    allowBreakout?: boolean;
+    // (undocumented)
+    UNSAFE_addSidebarLayouts?: boolean;
+    // (undocumented)
+    UNSAFE_allowSingleColumnLayout?: boolean;
+}
+
+export { lightModeStatusColorPalette }
+
+// @public (undocumented)
+type Listener = (data: any) => void;
+
+export { MacroAttributes }
+
+export { MacroProvider }
+
+// @public (undocumented)
+interface MeasureHelpers {
+    // (undocumented)
+    startMeasure: (measureName: string) => void;
+    // (undocumented)
+    stopMeasure: (measureName: string, onMeasureComplete?: (duration: number, startTime: number) => void) => void;
+}
+
+// @public (undocumented)
+type MeasureListener = (entry: SimpleEntry) => void;
+
+// @public (undocumented)
+export const measurements: {
+    EDITOR_MOUNTED: string;
+    PROSEMIRROR_RENDERED: string;
+    PROSEMIRROR_CONTENT_RENDERED: string;
+    ON_EDITOR_READY_CALLBACK: string;
+    PASTE: string;
+};
+
+// @public (undocumented)
+type MediaNextEditorPluginType = NextEditorPlugin<'media', {
+    pluginConfiguration: MediaOptions | undefined;
+    dependencies: [
+    FeatureFlagsPlugin,
+    OptionalPlugin<AnalyticsPlugin>,
+    GuidelinePlugin,
+    GridPlugin,
+    WidthPlugin,
+    DecorationsPlugin,
+    FloatingToolbarPlugin,
+    EditorDisabledPlugin,
+    FocusPlugin
+    ];
+    sharedState: MediaPluginState | null;
+}>;
+
+// @public (undocumented)
+interface MediaNodeWithPosHandler {
+    // (undocumented)
+    getPos: ProsemirrorGetPosHandler;
+    // (undocumented)
+    node: Node_2;
+}
+
+// @public (undocumented)
+export interface MediaOptions {
+    // (undocumented)
+    alignLeftOnInsert?: boolean;
+    // (undocumented)
+    allowAdvancedToolBarOptions?: boolean;
+    // (undocumented)
+    allowAltTextOnImages?: boolean;
+    // (undocumented)
+    allowBreakoutSnapPoints?: boolean;
+    // (undocumented)
+    allowDropzoneDropLine?: boolean;
+    // (undocumented)
+    allowLazyLoading?: boolean;
+    // (undocumented)
+    allowLinking?: boolean;
+    // (undocumented)
+    allowMarkingUploadsAsIncomplete?: boolean;
+    // (undocumented)
+    allowMediaGroup?: boolean;
+    // (undocumented)
+    allowMediaSingle?: MediaSingleOptions | boolean;
+    // (undocumented)
+    allowMediaSingleEditable?: boolean;
+    // (undocumented)
+    allowRemoteDimensionsFetch?: boolean;
+    // (undocumented)
+    allowResizing?: boolean;
+    // (undocumented)
+    allowResizingInTables?: boolean;
+    // (undocumented)
+    allowTemplatePlaceholders?: PlaceholderTextOptions | boolean;
+    // (undocumented)
+    altTextValidator?: (value: string) => string[];
+    // (undocumented)
+    customDropzoneContainer?: HTMLElement;
+    // (undocumented)
+    customMediaPicker?: CustomMediaPicker;
+    // (undocumented)
+    editorSelectionAPI?: EditorSelectionAPI;
+    // (undocumented)
+    enableDownloadButton?: boolean;
+    // (undocumented)
+    featureFlags?: MediaFeatureFlags;
+    // (undocumented)
+    fullWidthEnabled?: boolean;
+    // (undocumented)
+    getEditorFeatureFlags?: GetEditorFeatureFlags;
+    // (undocumented)
+    isCopyPasteEnabled?: boolean;
+    // (undocumented)
+    provider?: Providers['mediaProvider'];
+    // (undocumented)
+    uploadErrorHandler?: (state: MediaState) => void;
+    // (undocumented)
+    useForgePlugins?: boolean;
+    // (undocumented)
+    waitForMediaUpload?: boolean;
+}
+
+// @public (undocumented)
+export const mediaPlugin: MediaNextEditorPluginType;
+
+// @public (undocumented)
+export const mediaPluginKey: PluginKey<MediaPluginState>;
+
+// @public (undocumented)
+type MediaPluginOptions = {
+    providerFactory: ProviderFactory;
+    nodeViews: {
+        [name: string]: (node: Node_2, view: EditorView, getPos: getPosHandler) => NodeView;
+    };
+    errorReporter?: ErrorReporter;
+    uploadErrorHandler?: (state: MediaState) => void;
+    waitForMediaUpload?: boolean;
+    customDropzoneContainer?: HTMLElement;
+    customMediaPicker?: CustomMediaPicker;
+    allowResizing: boolean;
+};
+
+// @public (undocumented)
+interface MediaPluginState {
+    // (undocumented)
+    addPendingTask: (promise: Promise<any>) => void;
+    // (undocumented)
+    allowsUploads: boolean;
+    // (undocumented)
+    allUploadsFinished: boolean;
+    // (undocumented)
+    destroy(): void;
+    // (undocumented)
+    dispatch?: Dispatch;
+    // (undocumented)
+    editingMediaSinglePos?: number;
+    // (undocumented)
+    element?: HTMLElement;
+    // (undocumented)
+    findMediaNode: (id: string) => MediaNodeWithPosHandler | null;
+    // (undocumented)
+    getMediaOptions: () => MediaPluginOptions;
+    // (undocumented)
+    handleDrag: (dragState: 'enter' | 'leave') => void;
+    // (undocumented)
+    handleMediaGroupUpdate: (oldNodes: Node_2[], newNodes: Node_2[]) => void;
+    // (undocumented)
+    handleMediaNodeMount: (node: Node_2, getPos: ProsemirrorGetPosHandler) => void;
+    // (undocumented)
+    handleMediaNodeRemoval: (node: Node_2 | undefined, getPos: ProsemirrorGetPosHandler) => void;
+    // (undocumented)
+    handleMediaNodeUnmount: (oldNode: Node_2) => void;
+    // (undocumented)
+    ignoreLinks: boolean;
+    // (undocumented)
+    insertFile: (mediaState: MediaState, onMediaStateChanged: MediaStateEventSubscriber, pickerType?: string) => void;
+    // (undocumented)
+    isFullscreen: boolean;
+    // (undocumented)
+    isResizing: boolean;
+    // (undocumented)
+    layout: RichMediaLayout;
+    // (undocumented)
+    mediaClientConfig?: MediaClientConfig;
+    // (undocumented)
+    mediaNodes: MediaNodeWithPosHandler[];
+    // (undocumented)
+    mediaOptions?: MediaOptions;
+    // (undocumented)
+    mediaProvider?: MediaProvider_2;
+    // (undocumented)
+    onContextIdentifierProvider: (_name: string, provider?: Promise<ContextIdentifierProvider>) => Promise<void>;
+    // (undocumented)
+    onPopupPickerClose: () => void;
+    // (undocumented)
+    onPopupToggle: (onPopupToogleCallback: (isOpen: boolean) => void) => void;
+    // (undocumented)
+    options: MediaPluginOptions;
+    // (undocumented)
+    pickerPromises: Array<Promise<PickerFacade>>;
+    // (undocumented)
+    pickers: PickerFacade[];
+    // (undocumented)
+    removeSelectedMediaContainer: () => boolean;
+    // (undocumented)
+    resizingWidth: number;
+    // (undocumented)
+    selectedMediaContainerNode: () => Node_2 | undefined;
+    // (undocumented)
+    setBrowseFn: (browseFn: () => void) => void;
+    // (undocumented)
+    setIsResizing(isResizing: boolean): void;
+    // (undocumented)
+    setMediaProvider: (mediaProvider?: Promise<MediaProvider_2>) => Promise<void>;
+    // (undocumented)
+    setResizingWidth(width: number): void;
+    // (undocumented)
+    setView(view: EditorView): void;
+    // (undocumented)
+    showDropzone: boolean;
+    // (undocumented)
+    showEditingDialog?: boolean;
+    // (undocumented)
+    showMediaPicker: () => void;
+    // (undocumented)
+    splitMediaGroup: () => boolean;
+    // (undocumented)
+    updateAndDispatch(props: Partial<Pick<this, 'allUploadsFinished' | 'allowsUploads' | 'isFullscreen'>>): void;
+    // (undocumented)
+    updateElement(): void;
+    // (undocumented)
+    updateMediaSingleNodeAttrs: (id: string, attrs: object) => boolean | undefined;
+    // (undocumented)
+    uploadMediaClientConfig?: MediaClientConfig;
+    // (undocumented)
+    waitForMediaUpload: boolean;
+    // (undocumented)
+    waitForPendingTasks: (timeout?: number, lastTask?: Promise<MediaState | null>) => Promise<MediaState | null>;
+}
+
+export { MediaProvider_2 as MediaProvider }
+
+// @public (undocumented)
+interface MediaSingleOptions {
+    // (undocumented)
+    disableLayout?: boolean;
+}
+
+// @public (undocumented)
+export interface MediaState {
+    // (undocumented)
+    collection?: string;
+    // (undocumented)
+    contextId?: string;
+    // (undocumented)
+    dimensions?: {
+        width: number | undefined;
+        height: number | undefined;
+    };
+    // (undocumented)
+    error?: {
+        name: string;
+        description: string;
+    };
+    // (undocumented)
+    fileMimeType?: string;
+    // (undocumented)
+    fileName?: string;
+    // (undocumented)
+    fileSize?: number;
+    // (undocumented)
+    id: string;
+    publicId?: string;
+    // (undocumented)
+    scaleFactor?: number;
+    // (undocumented)
+    status?: MediaStateStatus;
+}
+
+// @public (undocumented)
+type MediaStateEvent = MediaState;
+
+// @public (undocumented)
+type MediaStateEventListener = (evt: MediaStateEvent) => void;
+
+// @public (undocumented)
+type MediaStateEventSubscriber = (listener: MediaStateEventListener) => void;
+
+// @public (undocumented)
+type MediaStateStatus = 'cancelled' | 'error' | 'mobile-upload-end' | 'preview' | 'ready' | 'unknown';
+
+// @public (undocumented)
+interface MentionPluginConfig {
+    // (undocumented)
+    HighlightComponent?: React.ComponentType;
+    // (undocumented)
+    insertDisplayName?: boolean;
+}
+
+// @public (undocumented)
+export const mentionPluginKey: PluginKey<MentionPluginState>;
+
+// @public (undocumented)
+export type MentionPluginState = {
+    mentionProvider?: MentionProvider_2;
+    contextIdentifierProvider?: ContextIdentifierProvider;
+    mentions?: Array<MentionDescription>;
+    canInsertMention?: boolean;
+};
+
+export { MentionProvider }
+
+export { MentionResource }
+
+export { messages }
+
+// @public (undocumented)
+type MobileUploadEndEventPayload = {
+    readonly file: MediaFile & {
+        readonly collectionName?: string;
+        readonly publicId?: string;
+    };
+};
+
+// @public (undocumented)
+const name_2: string;
+export { name_2 as name }
+
+// @public (undocumented)
+type NewMediaEvent = (state: MediaState, onStateChanged: MediaStateEventSubscriber, pickerType?: string) => void;
+
+// @public (undocumented)
+interface NodeSelectionData {
+    // (undocumented)
+    anchor: number;
+    // (undocumented)
+    type: 'node';
+}
+
+// @public (undocumented)
+type OnEditorViewStateUpdated = (props: {
+    readonly originalTransaction: Readonly<Transaction>;
+    readonly transactions: ReadonlyArray<Transaction>;
+    readonly oldEditorState: Readonly<EditorState>;
+    readonly newEditorState: Readonly<EditorState>;
+}) => void;
+
+// @public (undocumented)
+export const openDatePicker: () => Command;
+
+export { PaletteColor }
+
+// @public (undocumented)
+interface PanelPluginConfig {
+    // (undocumented)
+    allowCustomPanel?: boolean;
+    // (undocumented)
+    allowCustomPanelEdit?: boolean;
+}
+
+// @public (undocumented)
+type PastePluginOptions = {
+    cardOptions?: CardOptions;
+    sanitizePrivateContent?: boolean;
+};
+
+// @public (undocumented)
+class PickerFacade {
+    constructor(pickerType: PickerType, config: PickerFacadeConfig, pickerConfig?: CustomMediaPicker | null | undefined, analyticsName?: string);
+    // (undocumented)
+    readonly config: PickerFacadeConfig;
+    // (undocumented)
+    destroy(): void;
+    // (undocumented)
+    erroredFiles: Set<string>;
+    // (undocumented)
+    handleMobileUploadEnd: (event: MobileUploadEndEventPayload) => void;
+    // (undocumented)
+    handleReady: (event: UploadEndEventPayload) => void;
+    // (undocumented)
+    handleUploadError: ({ error, fileId }: UploadErrorEventPayload) => void;
+    // (undocumented)
+    handleUploadPreviewUpdate: (event: UploadPreviewUpdateEventPayload) => void;
+    // (undocumented)
+    init(): Promise<PickerFacade>;
+    // (undocumented)
+    get mediaPicker(): CustomMediaPicker | undefined;
+    // (undocumented)
+    onDrag(cb: (state: 'enter' | 'leave') => any): void;
+    // (undocumented)
+    onNewMedia(cb: NewMediaEvent): void;
+    // (undocumented)
+    readonly pickerConfig?: CustomMediaPicker | null | undefined;
+    // (undocumented)
+    setUploadParams(params: UploadParams): void;
+    // (undocumented)
+    get type(): PickerType;
+}
+
+// @public (undocumented)
+type PickerFacadeConfig = {
+    mediaClientConfig: MediaClientConfig;
+    errorReporter: ErrorReportingHandler;
+    featureFlags?: MediaFeatureFlags_2;
+};
+
+// @public (undocumented)
+type PickerType = 'clipboard' | 'customMediaPicker' | 'dropzone';
+
+// @public (undocumented)
+interface PlaceholderPluginOptions {
+    // (undocumented)
+    placeholder?: string;
+    // (undocumented)
+    placeholderBracketHint?: string;
+}
+
+// @public (undocumented)
+interface PlaceholderTextOptions {
+    // (undocumented)
+    allowInserting?: boolean;
+}
+
+export { PortalProvider }
+
+export { PortalProviderAPI }
+
+export { PortalRenderer }
+
+export { PresenceProvider }
+
+export { PresenceResource }
+
+// @public (undocumented)
+type PrimaryToolbarComponents = BeforeAndAfterToolbarComponents | ReactComponents;
+
+// @public (undocumented)
+interface Props {
+    // (undocumented)
+    children?: any;
+    // (undocumented)
+    isExpanded?: boolean;
+    // (undocumented)
+    onExpand?: () => void;
+    // (undocumented)
+    onFocus?: (e: React_2.FocusEvent<HTMLInputElement>) => void;
+    // (undocumented)
+    placeholder?: string;
+}
+
+// @public (undocumented)
+interface Props_2 {
+    // (undocumented)
+    title?: string;
+    // (undocumented)
+    titlePosition?: PositionType;
+}
+
+// @public (undocumented)
+interface Props_3 {
+    // @deprecated (undocumented)
+    labels?: string[];
+    // @deprecated (undocumented)
+    packageName?: string;
+    // @deprecated (undocumented)
+    packageVersion?: string;
+    // (undocumented)
+    popupsBoundariesElement?: HTMLElement;
+    // (undocumented)
+    popupsMountPoint?: HTMLElement;
+    // (undocumented)
+    popupsScrollableElement?: HTMLElement;
+    // (undocumented)
+    product?: EditorProduct;
+}
+
+// @public (undocumented)
+type Props_4 = {
+    visible: boolean;
+    children?: React_2.ReactElement;
+};
+
+// @public (undocumented)
+type Props_5 = {
+    oldPluginState: TypeAheadPluginState;
+    newPluginState: TypeAheadPluginState;
+};
+
+// @public (undocumented)
+type ProsemirrorGetPosHandler = () => number | undefined;
+
+export { QuickInsertItem }
+
+export { QuickInsertProvider }
+
+// @public (undocumented)
+type ReactComponents = ReactElement<any> | ReactElement<any>[];
+
+// @public (undocumented)
+export const ReactEditorView: FC<WithIntlProps<EditorViewProps & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: ComponentType<EditorViewProps & WrappedComponentProps<"intl">>;
+};
+
+// @public (undocumented)
+class ReactEditorView_2<T = {}> extends React_2.Component<EditorViewProps & WrappedComponentProps & T, {}, EditorReactContext> {
+    constructor(props: EditorViewProps & WrappedComponentProps & T, context: EditorReactContext);
+    // (undocumented)
+    blur: () => void;
+    // (undocumented)
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    // (undocumented)
+    config: EditorConfig;
+    // (undocumented)
+    contentTransformer?: Transformer_2<string>;
+    // (undocumented)
+    static contextTypes: {
+        getAtlaskitAnalyticsEventHandlers: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+    // (undocumented)
+    createEditorState: (options: CreateEditorStateOptions) => EditorState;
+    // (undocumented)
+    dispatch: Dispatch;
+    // (undocumented)
+    dispatchAnalyticsEvent: (payload: AnalyticsEventPayload) => void;
+    // (undocumented)
+    editorRef: React_2.RefObject<HTMLDivElement>;
+    // (undocumented)
+    editorState: EditorState;
+    // (undocumented)
+    errorReporter: ErrorReporter;
+    // (undocumented)
+    eventDispatcher: EventDispatcher;
+    // (undocumented)
+    experienceStore?: ExperienceStore;
+    // (undocumented)
+    formatFullWidthAppearance: (appearance: EditorAppearance | undefined) => FULL_WIDTH_MODE;
+    // (undocumented)
+    getDirectEditorProps: (state?: EditorState) => DirectEditorProps;
+    // (undocumented)
+    getEditorState: () => EditorState | undefined;
+    // (undocumented)
+    getEditorView: () => EditorView | undefined;
+    // (undocumented)
+    getPlugins(preset: EditorPresetBuilder<string[], AllEditorPresetPluginTypes[]>): EditorPlugin[];
+    // (undocumented)
+    handleAnalyticsEvent: FireAnalyticsCallback;
+    // (undocumented)
+    handleEditorViewRef: (node: HTMLDivElement) => void;
+    // (undocumented)
+    proseMirrorRenderedSeverity?: SEVERITY;
+    // (undocumented)
+    reconfigureState(props: EditorViewProps): void;
+    // (undocumented)
+    render(): JSX.Element;
+    // (undocumented)
+    resetEditorState: ({ doc, shouldScrollToBottom, }: {
+        doc: string;
+        shouldScrollToBottom: boolean;
+    }) => void;
+    // (undocumented)
+    transactionTracker: TransactionTracker;
+    // (undocumented)
+    get transactionTracking(): TransactionTracking;
+    // (undocumented)
+    UNSAFE_componentWillReceiveProps(nextProps: EditorViewProps): void;
+    // (undocumented)
+    validTransactionCount: number;
+    // (undocumented)
+    view?: EditorView;
+}
+
+// @public (undocumented)
+interface RectData {
+    // (undocumented)
+    left: number;
+    // (undocumented)
+    top: number;
+}
+
+// @public (undocumented)
+export const removeStatus: (showStatusPickerAt: number) => Command;
+
+// @public (undocumented)
+type ScrollGutterPluginOptions = {
+    getScrollElement?: (view: EditorView) => HTMLElement | null;
+    allowCustomScrollHandler?: boolean;
+    persistScrollGutter?: boolean;
+    gutterSize?: number;
+};
+
+// @public (undocumented)
+export type SelectionData = AllSelectionData | CellSelectionData | GapSelectionData | NodeSelectionData | TextSelectionData;
+
+// @public (undocumented)
+export interface SelectionDataState {
+    // (undocumented)
+    markTypes: string[];
+    // (undocumented)
+    nodeTypes: string[];
+    // (undocumented)
+    rect: RectData;
+    // (undocumented)
+    selection: SelectionData;
+}
+
+// @public (undocumented)
+export const selectionPluginKey: PluginKey<any>;
+
+// @public (undocumented)
+interface SelectionPluginOptions extends LongPressSelectionPluginOptions {
+}
+
+// @public (undocumented)
+export function setBlockType(name: string): Command_2;
+
+// @public (undocumented)
+export function setBlockTypeWithAnalytics(name: string, inputMethod: BlockTypeInputMethod, editorAnalyticsApi: EditorAnalyticsAPI | undefined): Command_2;
+
+// @public (undocumented)
+type SetEditorAPI = (editorApi: PublicPluginAPI<any>) => void;
+
+// @public (undocumented)
+export const setIsExpanded: (isExpanded: boolean) => Command_2;
+
+// @public (undocumented)
+export const setKeyboardHeight: (keyboardHeight: number) => Command_2;
+
+// @public (undocumented)
+export const setMobilePaddingTop: (paddingTop: number) => Command_2;
+
+// @public (undocumented)
+export const setStatusPickerAt: (showStatusPickerAt: null | number) => (state: EditorState, dispatch: (tr: Transaction) => void) => boolean;
+
+export { setTextSelection }
+
+// @public (undocumented)
+interface SimpleEntry {
+    // (undocumented)
+    duration: number;
+    // (undocumented)
+    name: string;
+    // (undocumented)
+    startTime: number;
+}
+
+// @public (undocumented)
+interface State {
+}
+
+// @public (undocumented)
+export const statusMessages: {
+    placeholder: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    editText: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    editColor: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};
+
+// @public (undocumented)
+export const statusPluginKey: PluginKey<StatusState>;
+
+// @public (undocumented)
+export type StatusState = {
+    isNew: boolean;
+    showStatusPickerAt: null | number;
+};
+
+// @public (undocumented)
+export type StatusType = {
+    color: Color;
+    text: string;
+    localId?: string;
+};
+
+// @public (undocumented)
+type SubscribeToToolbarAndPickerUpdates = (editorView: EditorView, cb: (args: SubscribeToToolbarAndPickerUpdatesCallbackArgs) => void) => () => void;
+
+// @public (undocumented)
+export const subscribeToToolbarAndPickerUpdates: SubscribeToToolbarAndPickerUpdates;
+
+// @public (undocumented)
+type SubscribeToToolbarAndPickerUpdatesCallbackArgs = {
+    dateState?: DatePluginState;
+    statusState?: StatusState;
+    toolbarConfig: ConfigWithNodeInfo | null | undefined;
+};
+
+// @public (undocumented)
+type SubscribeTypeAheadUpdates = (editorView: EditorView, cb: (props: Props_5) => void) => () => void;
+
+// @public (undocumented)
+export const subscribeTypeAheadUpdates: SubscribeTypeAheadUpdates;
+
+// @public (undocumented)
+export type TaskDecisionInputMethod = INPUT_METHOD.FORMATTING | INPUT_METHOD.INSERT_MENU | INPUT_METHOD.KEYBOARD | INPUT_METHOD.QUICK_INSERT | INPUT_METHOD.TOOLBAR;
+
+// @public (undocumented)
+type TaskDecisionListType = 'decisionList' | 'taskList';
+
+export { TeamMentionResource }
+
+// @public (undocumented)
+type TextColorDefaultColor = {
+    color: string;
+    label: string;
+};
+
+// @public (undocumented)
+interface TextColorPluginConfig {
+    // (undocumented)
+    defaultColor?: TextColorDefaultColor;
+}
+
+// @public (undocumented)
+export const textColorPluginKey: PluginKey<TextColorPluginState>;
+
+// @public (undocumented)
+export type TextColorPluginState = {
+    palette: Array<PaletteColor>;
+    defaultColor: string;
+    disabled?: boolean;
+    color: null | string;
+};
+
+export { TextFormattingInputMethodBasic }
+
+export { TextFormattingInputMethodToolbar }
+
+// @public (undocumented)
+interface TextSelectionData {
+    // (undocumented)
+    anchor: number;
+    // (undocumented)
+    head: number;
+    // (undocumented)
+    type: 'text';
+}
+
+// @public (undocumented)
+export function ToolbarFeedback(props: Props_3): jsx.JSX.Element;
+
+// @public (undocumented)
+export const ToolbarHelp: React_2.FC<WithIntlProps<Props_2 & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React_2.ComponentType<Props_2 & WrappedComponentProps<"intl">>;
+};
+
+// @public (undocumented)
+class TransactionTracker {
+    // (undocumented)
+    addMeasureListener(listener: MeasureListener): void;
+    // (undocumented)
+    bumpDispatchCounter: (options: TransactionTracking) => number;
+    // (undocumented)
+    getMeasureHelpers: (options: TransactionTracking) => MeasureHelpers;
+    // (undocumented)
+    removeMeasureListener(listener: MeasureListener): void;
+    // (undocumented)
+    shouldTrackTransaction(options: TransactionTracking): boolean;
+}
+
+export { TypeAheadItem }
+
+// @public (undocumented)
+export const typeAheadPluginKey: PluginKey<TypeAheadPluginState>;
+
+// @public (undocumented)
+export type TypeAheadPluginState = {
+    decorationSet: DecorationSet;
+    decorationElement: HTMLElement | null;
+    typeAheadHandlers: Array<TypeAheadHandler>;
+    query: string;
+    items: Array<TypeAheadItem_2>;
+    triggerHandler?: TypeAheadHandler;
+    selectedIndex: number;
+    stats: TypeAheadStatsSerializable | null;
+    inputMethod: TypeAheadInputMethod | null;
+};
+
+// @public (undocumented)
+interface TypeAheadStatsSerializable extends TypeAheadStats {
+    // (undocumented)
+    serialize: () => TypeAheadStats;
+}
+
+// @public (undocumented)
+export type UpdateEvent = 'create' | 'delete' | 'resolve' | 'setselectedannotation' | 'unresolve';
+
+// @public (undocumented)
+export const updateStatus: (status?: StatusType) => Command;
+
+// @public (undocumented)
+export const updateStatusWithAnalytics: (inputMethod: InsertBlockInputMethodToolbar, status?: StatusType) => Command;
+
+// @public (undocumented)
+export const version: string;
+
+// @public (undocumented)
+type VisibilityEvent = 'setvisibility';
+
+// @public (undocumented)
+export class WithEditorActions extends React_2.Component<WithEditorActionsProps, any> {
+    // (undocumented)
+    componentDidMount(): void;
+    // (undocumented)
+    componentWillUnmount(): void;
+    // (undocumented)
+    context: {
+        editorActions: EditorActions;
+    };
+    // (undocumented)
+    static contextTypes: {
+        editorActions: PropTypes.Validator<object>;
+    };
+    // (undocumented)
+    render(): React_2.ReactElement<any, React_2.JSXElementConstructor<any> | string> | null;
+}
+
+// @public (undocumented)
+interface WithEditorActionsProps {
+    // (undocumented)
+    render(actions: EditorActions): React_2.ReactElement<any> | null;
+}
+
+// @public (undocumented)
+export class WithHelpTrigger extends React_2.Component<{
+    render: (openHelp: () => void) => React_2.ReactNode;
+}, any> {
+    // (undocumented)
+    static contextTypes: {
+        editorActions: PropTypes.Validator<object>;
+    };
+    // (undocumented)
+    openHelp: () => void;
+    // (undocumented)
+    render(): React_2.ReactNode;
+}
+
+export { WithPluginState }
+
+// (No @packageDocumentation comment for this package)
+
+```