@atlaskit/editor-core 183.0.0 → 183.0.6

package/dist/types-ts4.0/plugins/max-content-size/index.d.ts

@@ -0,0 +1,13 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from 'prosemirror-state';
+import { NextEditorPlugin } from '@atlaskit/editor-common/types';
+import { Dispatch } from '../../event-dispatcher';
+export declare const pluginKey: PluginKey<MaxContentSizePluginState, any>;
+export declare type MaxContentSizePluginState = {
+    maxContentSizeReached: boolean;
+};
+export declare function createPlugin(dispatch: Dispatch, maxContentSize?: number): SafePlugin | undefined;
+declare const maxContentSizePlugin: NextEditorPlugin<'maxContentSize', {
+    pluginConfiguration: number | undefined;
+}>;
+export default maxContentSizePlugin;

package/dist/types-ts4.0/plugins/media/commands/captions.d.ts

@@ -0,0 +1,4 @@
+import { Node as PMNode } from 'prosemirror-model';
+import { Command } from '../../../types';
+export declare const selectCaptionFromMediaSinglePos: (mediaSingleNodePos: number, mediaSingleNode: PMNode) => Command;
+export declare const insertAndSelectCaptionFromMediaSinglePos: (mediaSingleNodePos: number, mediaSingleNode: PMNode) => Command;

package/dist/types-ts4.0/plugins/media/commands/helpers.d.ts

@@ -0,0 +1,15 @@
+import type { Command } from '../../../types/command';
+import type { MediaNodeWithPosHandler, MediaPluginState } from '../pm-plugins/types';
+import { EditorState } from 'prosemirror-state';
+/**
+ * Note that Media Inline is inserted like a media single node into the media plugin state.
+ * Though it is not of type mediaSingle, it shares the same `findMediaSingleNode` method
+ *
+ */
+export declare const findMediaSingleNode: (mediaPluginState: MediaPluginState, id: string) => MediaNodeWithPosHandler | null;
+export declare const findAllMediaSingleNodes: (mediaPluginState: MediaPluginState, id: string) => MediaNodeWithPosHandler[];
+export declare const isMediaNode: (pos: number, state: EditorState) => boolean | null | undefined;
+export declare const updateAllMediaSingleNodesAttrs: (id: string, attrs: object) => Command;
+export declare const updateCurrentMediaNodeAttrs: (attrs: object, mediaNode: MediaNodeWithPosHandler) => Command;
+export declare const updateMediaSingleNodeAttrs: (id: string, attrs: object) => Command;
+export declare const replaceExternalMedia: (pos: number, attrs: object) => Command;

package/dist/types-ts4.0/plugins/media/commands/index.d.ts

@@ -0,0 +1 @@
+export { updateMediaSingleNodeAttrs, updateAllMediaSingleNodesAttrs, replaceExternalMedia, } from './helpers';

package/dist/types-ts4.0/plugins/media/commands/linking.d.ts

@@ -0,0 +1,10 @@
+import { EditorView } from 'prosemirror-view';
+import { CommandDispatch } from '../../../types/command';
+import { EditorState } from 'prosemirror-state';
+import { INPUT_METHOD } from '../../analytics';
+import { Command } from '../../../types';
+export declare const showLinkingToolbar: import("@atlaskit/editor-common/types").Command;
+export declare const showLinkingToolbarWithMediaTypeCheck: Command;
+export declare const hideLinkingToolbar: (state: EditorState, dispatch?: CommandDispatch | undefined, view?: EditorView<any> | undefined, focusFloatingToolbar?: boolean | undefined) => void;
+export declare const unlink: import("@atlaskit/editor-common/types").Command;
+export declare const setUrlToMedia: (url: string, inputMethod: INPUT_METHOD.TYPEAHEAD | INPUT_METHOD.MANUAL) => import("@atlaskit/editor-common/types").Command;

package/dist/types-ts4.0/plugins/media/index.d.ts

@@ -0,0 +1,14 @@
+import { MediaProvider } from '@atlaskit/editor-common/provider-factory';
+import { NextEditorPlugin } from '../../types';
+import { MediaState } from './pm-plugins/main';
+import { CustomMediaPicker, MediaOptions } from './types';
+import type featureFlagsPlugin from '@atlaskit/editor-plugin-feature-flags';
+export type { MediaState, MediaProvider, CustomMediaPicker };
+export { insertMediaSingleNode } from './utils/media-single';
+declare const mediaPlugin: NextEditorPlugin<'media', {
+    pluginConfiguration: MediaOptions | undefined;
+    dependencies: [
+        typeof featureFlagsPlugin
+    ];
+}>;
+export default mediaPlugin;

package/dist/types-ts4.0/plugins/media/media-plugin-options.d.ts

@@ -0,0 +1,18 @@
+import { Node as PMNode } from 'prosemirror-model';
+import { EditorView, NodeView } from 'prosemirror-view';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import { ErrorReporter } from '@atlaskit/editor-common/utils';
+import { MediaState, CustomMediaPicker } from './types';
+import { getPosHandler } from '../../nodeviews/types';
+export declare type MediaPluginOptions = {
+    providerFactory: ProviderFactory;
+    nodeViews: {
+        [name: string]: (node: PMNode, view: EditorView, getPos: getPosHandler) => NodeView;
+    };
+    errorReporter?: ErrorReporter;
+    uploadErrorHandler?: (state: MediaState) => void;
+    waitForMediaUpload?: boolean;
+    customDropzoneContainer?: HTMLElement;
+    customMediaPicker?: CustomMediaPicker;
+    allowResizing: boolean;
+};

package/dist/types-ts4.0/plugins/media/nodeviews/__mocks__/mediaNodeUpdater.d.ts

@@ -0,0 +1,24 @@
+export declare class MediaNodeUpdater {
+    static instances: MediaNodeUpdater[];
+    static mockOverrides: {};
+    static mockReset(): void;
+    constructor();
+    static setMock(thisKey: string, value: any): void;
+    updateContextId(): Promise<void>;
+    updateNodeContextId(): Promise<void>;
+    getAttrs(): void;
+    getObjectId(): Promise<void>;
+    getNodeContextId(): void;
+    updateDimensions(): void;
+    getRemoteDimensions(): Promise<void>;
+    isNodeFromDifferentCollection(): Promise<void>;
+    hasDifferentContextId(): Promise<void>;
+    copyNode(): Promise<void>;
+    copyNodeFromPos(): Promise<void>;
+    updateMediaSingleFileAttrs(): Promise<void>;
+    uploadExternalMedia(): Promise<void>;
+    isMediaBlobUrl(): void;
+    copyNodeFromBlobUrl(): void;
+    updateNodeAttrs(): void;
+    handleExternalMedia(): Promise<void>;
+}

package/dist/types-ts4.0/plugins/media/nodeviews/mediaGroup.d.ts

@@ -0,0 +1,33 @@
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import type { ContextIdentifierProvider, MediaProvider } from '@atlaskit/editor-common/provider-factory';
+import { MediaClientConfig } from '@atlaskit/media-core';
+import { Node as PMNode } from 'prosemirror-model';
+import { EditorView, NodeView } from 'prosemirror-view';
+import React from 'react';
+import { EventDispatcher } from '../../../event-dispatcher';
+import { getPosHandler } from '../../../nodeviews/';
+import { PortalProviderAPI } from '../../../ui/PortalProvider';
+import { MediaOptions } from '../types';
+import { WrappedComponentProps } from 'react-intl-next';
+export declare type MediaGroupProps = {
+    forwardRef?: (ref: HTMLElement) => void;
+    node: PMNode;
+    view: EditorView;
+    getPos: () => number;
+    disabled?: boolean;
+    allowLazyLoading?: boolean;
+    mediaProvider: Promise<MediaProvider>;
+    contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
+    isCopyPasteEnabled?: boolean;
+    anchorPos: number;
+    headPos: number;
+    mediaOptions: MediaOptions;
+} & WrappedComponentProps;
+export interface MediaGroupState {
+    viewMediaClientConfig?: MediaClientConfig;
+}
+declare const IntlMediaGroup: React.FC<import("react-intl-next").WithIntlProps<MediaGroupProps>> & {
+    WrappedComponent: React.ComponentType<MediaGroupProps>;
+};
+export default IntlMediaGroup;
+export declare const ReactMediaGroupNode: (portalProviderAPI: PortalProviderAPI, eventDispatcher: EventDispatcher, providerFactory: ProviderFactory, mediaOptions?: MediaOptions) => (node: PMNode, view: EditorView, getPos: getPosHandler) => NodeView;

package/dist/types-ts4.0/plugins/media/nodeviews/mediaInline.d.ts

@@ -0,0 +1,47 @@
+import { Node as PMNode } from 'prosemirror-model';
+import { EditorView, NodeView } from 'prosemirror-view';
+import React from 'react';
+import { EventDispatcher } from '../../../event-dispatcher';
+import { getPosHandler, ProsemirrorGetPosHandler, SelectionBasedNodeView } from '../../../nodeviews/';
+import { FileIdentifier } from '@atlaskit/media-client';
+import { ProviderFactory, ContextIdentifierProvider } from '@atlaskit/editor-common/provider-factory';
+import type { MediaProvider } from '@atlaskit/editor-common/provider-factory';
+import { PortalProviderAPI } from '../../../../src/ui/PortalProvider';
+import { MediaPluginState } from '../pm-plugins/types';
+import { MediaNodeUpdater } from './mediaNodeUpdater';
+import { DispatchAnalyticsEvent } from '../../analytics';
+export interface MediaInlineProps {
+    mediaProvider: Promise<MediaProvider>;
+    identifier: FileIdentifier;
+    node: PMNode;
+    isSelected: boolean;
+    view: EditorView;
+    getPos: ProsemirrorGetPosHandler;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
+    mediaPluginState: MediaPluginState;
+}
+export declare const createMediaNodeUpdater: (props: MediaInlineProps) => MediaNodeUpdater;
+/**
+ * Handles updating the media inline node attributes
+ * but also handling copy-paste for cross-editor of the same instance
+ * using the contextid
+ *
+ */
+export declare const updateMediaNodeAttributes: (props: MediaInlineProps) => Promise<void>;
+export declare const handleNewNode: (props: MediaInlineProps) => void;
+export declare const MediaInline: React.FC<MediaInlineProps>;
+export interface MediaInlineNodeViewProps {
+    providerFactory: ProviderFactory;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+}
+export declare class MediaInlineNodeView extends SelectionBasedNodeView<MediaInlineNodeViewProps> {
+    createDomRef(): HTMLSpanElement;
+    getContentDOM(): {
+        dom: HTMLSpanElement;
+    };
+    ignoreMutation(): boolean;
+    viewShouldUpdate(nextNode: PMNode): boolean;
+    render(props: MediaInlineNodeViewProps): JSX.Element;
+}
+export declare const ReactMediaInlineNode: (portalProviderAPI: PortalProviderAPI, eventDispatcher: EventDispatcher, providerFactory: ProviderFactory, dispatchAnalyticsEvent?: DispatchAnalyticsEvent | undefined) => (node: PMNode, view: EditorView, getPos: getPosHandler) => NodeView;

package/dist/types-ts4.0/plugins/media/nodeviews/mediaNodeUpdater.d.ts

@@ -0,0 +1,47 @@
+import { MediaADFAttrs } from '@atlaskit/adf-schema';
+import type { MediaProvider } from '@atlaskit/editor-common/provider-factory';
+import { Node as PMNode } from 'prosemirror-model';
+import { EditorView } from 'prosemirror-view';
+import type { ContextIdentifierProvider } from '@atlaskit/editor-common/provider-factory';
+import { DispatchAnalyticsEvent } from '../../analytics';
+import { MediaOptions } from '../types';
+import { ProsemirrorGetPosHandler } from '../../../nodeviews';
+import { MediaTraceContext } from '@atlaskit/media-common';
+export declare type RemoteDimensions = {
+    id: string;
+    height: number;
+    width: number;
+};
+export interface MediaNodeUpdaterProps {
+    view: EditorView;
+    node: PMNode;
+    mediaProvider?: Promise<MediaProvider>;
+    contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
+    isMediaSingle: boolean;
+    mediaOptions?: MediaOptions;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+}
+export declare class MediaNodeUpdater {
+    props: MediaNodeUpdaterProps;
+    constructor(props: MediaNodeUpdaterProps);
+    isMediaBlobUrl(): boolean;
+    updateContextId: () => Promise<void>;
+    updateNodeContextId: (getPos: ProsemirrorGetPosHandler) => Promise<void>;
+    private hasFileAttributesDefined;
+    private getNewFileAttrsForNode;
+    updateMediaSingleFileAttrs: () => Promise<void>;
+    updateNodeAttrs: (getPos: ProsemirrorGetPosHandler) => Promise<void>;
+    getAttrs: () => MediaADFAttrs | undefined;
+    getObjectId: () => Promise<string | null>;
+    uploadExternalMedia: (getPos: ProsemirrorGetPosHandler) => Promise<void>;
+    getNodeContextId: () => string | null;
+    updateDimensions: (dimensions: RemoteDimensions) => void;
+    getRemoteDimensions(): Promise<false | RemoteDimensions>;
+    hasDifferentContextId: () => Promise<boolean>;
+    isNodeFromDifferentCollection: () => Promise<boolean>;
+    handleExternalMedia(getPos: ProsemirrorGetPosHandler): Promise<void>;
+    copyNodeFromBlobUrl: (getPos: ProsemirrorGetPosHandler) => Promise<void>;
+    copyNodeFromPos: (getPos: ProsemirrorGetPosHandler, traceContext?: MediaTraceContext | undefined) => Promise<void>;
+    copyNode: (traceContext?: MediaTraceContext | undefined) => Promise<void>;
+    private copyFile;
+}

package/dist/types-ts4.0/plugins/media/nodeviews/mediaNodeView/index.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="react" />
+import { MediaADFAttrs } from '@atlaskit/adf-schema';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import type { Providers, MediaProvider, ContextIdentifierProvider } from '@atlaskit/editor-common/provider-factory';
+import { Node as PMNode } from 'prosemirror-model';
+import { EditorView } from 'prosemirror-view';
+import { EventDispatcher } from '../../../../event-dispatcher';
+import { getPosHandler, SelectionBasedNodeView } from '../../../../nodeviews';
+import { PortalProviderAPI } from '../../../../ui/PortalProvider';
+import { WidthPluginState } from '../../../width';
+import { MediaOptions } from '../../types';
+import { MediaNodeViewProps } from '../types';
+declare class MediaNodeView extends SelectionBasedNodeView<MediaNodeViewProps> {
+    createDomRef(): HTMLElement;
+    viewShouldUpdate(nextNode: PMNode): boolean;
+    stopEvent(event: Event): boolean;
+    getAttrs(): MediaADFAttrs;
+    isMediaBlobUrl(): boolean;
+    renderMediaNodeWithState: (mediaProvider?: Promise<MediaProvider> | undefined, contextIdentifierProvider?: Promise<ContextIdentifierProvider> | undefined) => ({ width: editorWidth }: {
+        width?: import("@atlaskit/editor-common/types").EditorContainerWidth | undefined;
+    }) => JSX.Element;
+    renderMediaNodeWithProviders: ({ mediaProvider, contextIdentifierProvider, }: Providers) => JSX.Element;
+    render(): JSX.Element;
+}
+export declare const ReactMediaNode: (portalProviderAPI: PortalProviderAPI, eventDispatcher: EventDispatcher, providerFactory: ProviderFactory, mediaOptions?: MediaOptions) => (node: PMNode, view: EditorView, getPos: getPosHandler) => MediaNodeView;
+export {};

package/dist/types-ts4.0/plugins/media/nodeviews/mediaNodeView/media.d.ts

@@ -0,0 +1,45 @@
+import type { ContextIdentifierProvider, MediaProvider } from '@atlaskit/editor-common/provider-factory';
+import type { ImageLoaderProps } from '@atlaskit/editor-common/utils';
+import { CardDimensions, CardOnClickCallback, NumericalCardDimensions } from '@atlaskit/media-card';
+import { MediaClientConfig } from '@atlaskit/media-core';
+import { Node as PMNode } from 'prosemirror-model';
+import { EditorView } from 'prosemirror-view';
+import React, { Component } from 'react';
+import { ProsemirrorGetPosHandler, ReactNodeProps } from '../../../../nodeviews';
+import { MediaOptions } from '../../types';
+export declare const MEDIA_HEIGHT = 125;
+export declare const FILE_WIDTH = 156;
+export interface MediaNodeProps extends ReactNodeProps, ImageLoaderProps {
+    view: EditorView;
+    node: PMNode;
+    getPos: ProsemirrorGetPosHandler;
+    contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
+    originalDimensions: NumericalCardDimensions;
+    maxDimensions: CardDimensions;
+    isMediaSingle?: boolean;
+    onClick?: CardOnClickCallback;
+    mediaProvider?: Promise<MediaProvider>;
+    isLoading?: boolean;
+    mediaOptions?: MediaOptions;
+}
+interface MediaNodeState {
+    viewMediaClientConfig?: MediaClientConfig;
+    contextIdentifierProvider?: ContextIdentifierProvider;
+}
+export declare class MediaNode extends Component<MediaNodeProps, MediaNodeState> {
+    private mediaPluginState;
+    state: MediaNodeState;
+    constructor(props: MediaNodeProps);
+    shouldComponentUpdate(nextProps: MediaNodeProps, nextState: MediaNodeState): boolean;
+    componentDidMount(): Promise<void>;
+    componentWillUnmount(): void;
+    componentDidUpdate(prevProps: Readonly<MediaNodeProps>): void;
+    private setViewMediaClientConfig;
+    private selectMediaSingleFromCard;
+    private selectMediaSingle;
+    render(): JSX.Element;
+    private onFullscreenChange;
+    private handleNewNode;
+}
+declare const _default: React.ComponentClass<MediaNodeProps & ImageLoaderProps, any>;
+export default _default;

package/dist/types-ts4.0/plugins/media/nodeviews/mediaSingle.d.ts

@@ -0,0 +1,61 @@
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+import React, { Component, MouseEvent } from 'react';
+import { Node as PMNode } from 'prosemirror-model';
+import { EditorView, Decoration } from 'prosemirror-view';
+import { RichMediaLayout as MediaSingleLayout } from '@atlaskit/adf-schema';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import type { ContextIdentifierProvider } from '@atlaskit/editor-common/provider-factory';
+import { CardEvent } from '@atlaskit/media-card';
+import { MediaClientConfig } from '@atlaskit/media-core';
+import { getPosHandler, ForwardRef } from '../../../nodeviews/';
+import { EventDispatcher } from '../../../event-dispatcher';
+import { PortalProviderAPI } from '../../../ui/PortalProvider';
+import { MediaOptions } from '../types';
+import { MediaSingleNodeProps, MediaSingleNodeViewProps } from './types';
+import { MediaNodeUpdater } from './mediaNodeUpdater';
+import { DispatchAnalyticsEvent } from '../../analytics';
+import ReactNodeView from '../../../nodeviews/ReactNodeView';
+export interface MediaSingleNodeState {
+    width?: number;
+    height?: number;
+    viewMediaClientConfig?: MediaClientConfig;
+    contextIdentifierProvider?: ContextIdentifierProvider;
+    isCopying: boolean;
+}
+export default class MediaSingleNode extends Component<MediaSingleNodeProps, MediaSingleNodeState> {
+    static defaultProps: Partial<MediaSingleNodeProps>;
+    static displayName: string;
+    state: MediaSingleNodeState;
+    mediaSingleWrapperRef: React.RefObject<HTMLDivElement>;
+    captionPlaceHolderRef: React.RefObject<HTMLSpanElement>;
+    createMediaNodeUpdater: (props: MediaSingleNodeProps) => MediaNodeUpdater;
+    UNSAFE_componentWillReceiveProps(nextProps: MediaSingleNodeProps): void;
+    setViewMediaClientConfig: (props: MediaSingleNodeProps) => Promise<void>;
+    updateMediaNodeAttributes: (props: MediaSingleNodeProps) => Promise<void>;
+    componentDidMount(): Promise<void>;
+    selectMediaSingle: ({ event }: CardEvent) => void;
+    updateSize: (width: number | null, layout: MediaSingleLayout) => void;
+    onMediaSingleClicked: (event: MouseEvent) => void;
+    render(): jsx.JSX.Element;
+    private clickPlaceholder;
+    private getLineLength;
+}
+declare class MediaSingleNodeView extends ReactNodeView<MediaSingleNodeViewProps> {
+    lastOffsetLeft: number;
+    forceViewUpdate: boolean;
+    selectionType: number | null;
+    createDomRef(): HTMLElement;
+    getContentDOM(): {
+        dom: HTMLDivElement;
+    };
+    viewShouldUpdate(nextNode: PMNode): boolean;
+    checkAndUpdateSelectionType: () => import("@atlaskit/editor-common/utils").SelectedState | null;
+    isNodeSelected: () => boolean;
+    getNodeMediaId(node: PMNode): string | undefined;
+    update(node: PMNode, decorations: Decoration[], _innerDecorations?: Decoration[], isValidUpdate?: (currentNode: PMNode, newNode: PMNode) => boolean): boolean;
+    render(props: MediaSingleNodeViewProps, forwardRef?: ForwardRef): jsx.JSX.Element;
+    ignoreMutation(): boolean;
+}
+export declare const ReactMediaSingleNode: (portalProviderAPI: PortalProviderAPI, eventDispatcher: EventDispatcher, providerFactory: ProviderFactory, dispatchAnalyticsEvent?: DispatchAnalyticsEvent | undefined, mediaOptions?: MediaOptions) => (node: PMNode, view: EditorView, getPos: getPosHandler) => MediaSingleNodeView;
+export {};

package/dist/types-ts4.0/plugins/media/nodeviews/messages.d.ts

@@ -0,0 +1,7 @@
+export declare const messages: {
+    mediaGroupDeleteLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};

package/dist/types-ts4.0/plugins/media/nodeviews/styles.d.ts

@@ -0,0 +1,16 @@
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+import { NumericalCardDimensions } from '@atlaskit/media-card';
+export declare const MediaInlineNodeSelector = "media-inline-node";
+export declare const MediaSingleNodeSelector = "media-single-node";
+export declare const figureWrapper: import("@emotion/react").SerializedStyles;
+declare type MediaCardWrapperProps = {
+    dimensions: NumericalCardDimensions;
+    children: React.ReactNode;
+    selected?: boolean;
+    borderWidth?: number;
+    onContextMenu?: (event: React.MouseEvent<HTMLElement, MouseEvent>) => void;
+};
+export declare const MediaCardWrapper: ({ dimensions, children, selected, borderWidth, onContextMenu, }: MediaCardWrapperProps) => jsx.JSX.Element;
+export {};

package/dist/types-ts4.0/plugins/media/nodeviews/types.d.ts

@@ -0,0 +1,39 @@
+import { Node as PMNode } from 'prosemirror-model';
+import { EditorView } from 'prosemirror-view';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import type { ContextIdentifierProvider, MediaProvider } from '@atlaskit/editor-common/provider-factory';
+import { ProsemirrorGetPosHandler, ForwardRef } from '../../../nodeviews';
+import { EventDispatcher } from '../../../event-dispatcher';
+import { MediaOptions } from '../types';
+import { DispatchAnalyticsEvent } from '../../analytics';
+import { MediaPluginState } from '../pm-plugins/types';
+export interface MediaSingleNodeProps {
+    view: EditorView;
+    node: PMNode;
+    getPos: ProsemirrorGetPosHandler;
+    eventDispatcher: EventDispatcher;
+    width: number;
+    selected: Function;
+    lineLength: number;
+    mediaOptions: MediaOptions;
+    mediaProvider?: Promise<MediaProvider>;
+    contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
+    fullWidthMode?: boolean;
+    mediaPluginState: MediaPluginState;
+    dispatchAnalyticsEvent: DispatchAnalyticsEvent;
+    isCopyPasteEnabled?: boolean;
+    forwardRef: ForwardRef;
+}
+export interface MediaSingleNodeViewProps {
+    eventDispatcher: EventDispatcher;
+    providerFactory: ProviderFactory;
+    mediaOptions: MediaOptions;
+    fullWidthMode?: boolean;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    isCopyPasteEnabled?: boolean;
+}
+export interface MediaNodeViewProps {
+    eventDispatcher: EventDispatcher;
+    providerFactory: ProviderFactory;
+    mediaOptions: MediaOptions;
+}

package/dist/types-ts4.0/plugins/media/picker-facade.d.ts

@@ -0,0 +1,44 @@
+import { UploadPreviewUpdateEventPayload, UploadParams, UploadErrorEventPayload, UploadEndEventPayload } from '@atlaskit/media-picker/types';
+import { MediaClientConfig } from '@atlaskit/media-core';
+import type { ErrorReportingHandler } from '@atlaskit/editor-common/utils';
+import { MediaFeatureFlags } from '@atlaskit/media-common/mediaFeatureFlags';
+import { MediaState, CustomMediaPicker, MobileUploadEndEventPayload } from './types';
+export declare type PickerType = 'clipboard' | 'dropzone' | 'customMediaPicker';
+export declare type ExtendedComponentConfigs = {
+    customMediaPicker: CustomMediaPicker;
+    dropzone: null;
+    clipboard: null;
+};
+export declare type PickerFacadeConfig = {
+    mediaClientConfig: MediaClientConfig;
+    errorReporter: ErrorReportingHandler;
+    featureFlags?: MediaFeatureFlags;
+};
+export declare type MediaStateEvent = MediaState;
+export declare type MediaStateEventListener = (evt: MediaStateEvent) => void;
+export declare type MediaStateEventSubscriber = (listener: MediaStateEventListener) => void;
+export declare type NewMediaEvent = (state: MediaState, onStateChanged: MediaStateEventSubscriber, pickerType?: string) => void;
+export default class PickerFacade {
+    readonly config: PickerFacadeConfig;
+    readonly pickerConfig?: CustomMediaPicker | null | undefined;
+    private picker?;
+    private onDragListeners;
+    private pickerType;
+    private onStartListeners;
+    private eventListeners;
+    private analyticsName;
+    erroredFiles: Set<string>;
+    constructor(pickerType: PickerType, config: PickerFacadeConfig, pickerConfig?: CustomMediaPicker | null | undefined, analyticsName?: string);
+    init(): Promise<PickerFacade>;
+    get type(): PickerType;
+    get mediaPicker(): CustomMediaPicker | undefined;
+    destroy(): void;
+    setUploadParams(params: UploadParams): void;
+    onNewMedia(cb: NewMediaEvent): void;
+    onDrag(cb: (state: 'enter' | 'leave') => any): void;
+    handleUploadPreviewUpdate: (event: UploadPreviewUpdateEventPayload) => void;
+    private subscribeStateChanged;
+    handleUploadError: ({ error, fileId }: UploadErrorEventPayload) => void;
+    handleMobileUploadEnd: (event: MobileUploadEndEventPayload) => void;
+    handleReady: (event: UploadEndEventPayload) => void;
+}

package/dist/types-ts4.0/plugins/media/pm-plugins/alt-text/actions.d.ts

@@ -0,0 +1,10 @@
+export declare type CloseMediaAltTextMenu = {
+    type: 'closeMediaAltTextMenu';
+};
+export declare type OpenMediaAltTextMenu = {
+    type: 'openMediaAltTextMenu';
+};
+export declare type UpdateAltText = {
+    type: 'updateAltText';
+};
+export declare type MediaAltTextAction = OpenMediaAltTextMenu | CloseMediaAltTextMenu | UpdateAltText;

package/dist/types-ts4.0/plugins/media/pm-plugins/alt-text/commands.d.ts

@@ -0,0 +1,3 @@
+export declare const closeMediaAltTextMenu: import("@atlaskit/editor-common/types").Command;
+export declare const openMediaAltTextMenu: import("../../../..").Command;
+export declare const updateAltText: (newAltText: string) => import("@atlaskit/editor-common/types").Command;

package/dist/types-ts4.0/plugins/media/pm-plugins/alt-text/index.d.ts

@@ -0,0 +1,7 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from 'prosemirror-state';
+import { PMPluginFactoryParams } from '../../../../types';
+export declare const pluginKey: PluginKey<any, any>;
+declare const createCommand: <A = import("./actions").MediaAltTextAction>(action: A | ((state: Readonly<import("prosemirror-state").EditorState<any>>) => false | A), transform?: ((tr: import("prosemirror-state").Transaction<any>, state: import("prosemirror-state").EditorState<any>) => import("prosemirror-state").Transaction<any>) | undefined) => import("@atlaskit/editor-common/types").Command, getPluginState: (state: import("prosemirror-state").EditorState<any>) => import("./types").MediaAltTextState;
+export declare const createPlugin: ({ dispatch, providerFactory, }: PMPluginFactoryParams) => SafePlugin<import("./types").MediaAltTextState, import("prosemirror-model").Schema<any, any>>;
+export { createCommand, getPluginState };

package/dist/types-ts4.0/plugins/media/pm-plugins/alt-text/keymap.d.ts

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

package/dist/types-ts4.0/plugins/media/pm-plugins/alt-text/messages.d.ts

@@ -0,0 +1,37 @@
+export declare const messages: {
+    altText: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    editAltText: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    back: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    clear: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    placeholder: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    supportText: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    validationMessage: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};

package/dist/types-ts4.0/plugins/media/pm-plugins/alt-text/reducer.d.ts

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

package/dist/types-ts4.0/plugins/media/pm-plugins/alt-text/style.d.ts

@@ -0,0 +1,3 @@
+export declare const ClassNames: {
+    FLOATING_TOOLBAR_COMPONENT: string;
+};

package/dist/types-ts4.0/plugins/media/pm-plugins/alt-text/types.d.ts

@@ -0,0 +1,3 @@
+export declare type MediaAltTextState = {
+    isAltTextEditorOpen: boolean;
+};

package/dist/types-ts4.0/plugins/media/pm-plugins/alt-text/ui/AltTextEdit.d.ts

@@ -0,0 +1,41 @@
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+import { EditorView } from 'prosemirror-view';
+import { WrappedComponentProps } from 'react-intl-next';
+import { WithAnalyticsEventsProps } from '@atlaskit/analytics-next';
+export declare const CONTAINER_WIDTH_IN_PX = 420;
+export declare const MAX_ALT_TEXT_LENGTH = 510;
+declare type Props = {
+    view: EditorView;
+    value?: string;
+    altTextValidator?: (value: string) => string[];
+} & WrappedComponentProps & WithAnalyticsEventsProps;
+export declare type AltTextEditComponentState = {
+    showClearTextButton: boolean;
+    validationErrors: string[] | undefined;
+    lastValue: string | undefined;
+};
+export declare class AltTextEditComponent extends React.Component<Props, AltTextEditComponentState> {
+    private fireCustomAnalytics?;
+    state: {
+        showClearTextButton: boolean;
+        validationErrors: string[];
+        lastValue: string | undefined;
+    };
+    constructor(props: Props);
+    prevValue: string | undefined;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    private getValidationErrors;
+    render(): jsx.JSX.Element;
+    private closeMediaAltTextMenu;
+    private fireAnalytics;
+    private dispatchCancelEvent;
+    private updateAltText;
+    private handleOnChange;
+    private handleOnBlur;
+    private handleClearText;
+}
+declare const _default: React.ForwardRefExoticComponent<Omit<React.PropsWithChildren<import("react-intl-next").WithIntlProps<Props>>, keyof WithAnalyticsEventsProps> & React.RefAttributes<any>>;
+export default _default;

package/dist/types-ts4.0/plugins/media/pm-plugins/keymap-media-single.d.ts

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

package/dist/types-ts4.0/plugins/media/pm-plugins/keymap.d.ts

@@ -0,0 +1,4 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { MediaOptions } from '../types';
+export declare function keymapPlugin(options?: MediaOptions): SafePlugin;
+export default keymapPlugin;