@atlaskit/editor-plugin-media 0.3.1 → 0.3.2

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

@@ -0,0 +1,42 @@
+import type { DispatchAnalyticsEvent } from '@atlaskit/editor-common/analytics';
+import type { EventDispatcher } from '@atlaskit/editor-common/event-dispatcher';
+import type { ContextIdentifierProvider, MediaProvider, ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { MediaNextEditorPluginType } from '../next-plugin-type';
+import type { MediaPluginState } from '../pm-plugins/types';
+import type { ForwardRef, MediaOptions, getPosHandler as ProsemirrorGetPosHandler } from '../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;
+    pluginInjectionApi: ExtractInjectionAPI<MediaNextEditorPluginType> | undefined;
+}
+export interface MediaSingleNodeViewProps {
+    eventDispatcher: EventDispatcher;
+    providerFactory: ProviderFactory;
+    mediaOptions: MediaOptions;
+    fullWidthMode?: boolean;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    isCopyPasteEnabled?: boolean;
+    pluginInjectionApi: ExtractInjectionAPI<MediaNextEditorPluginType> | undefined;
+}
+export interface MediaNodeViewProps {
+    eventDispatcher: EventDispatcher;
+    providerFactory: ProviderFactory;
+    mediaOptions: MediaOptions;
+    pluginInjectionApi: ExtractInjectionAPI<MediaNextEditorPluginType> | undefined;
+}

package/dist/types-ts4.5/picker-facade.d.ts

@@ -0,0 +1,44 @@
+import type { ErrorReportingHandler } from '@atlaskit/editor-common/utils';
+import type { MediaFeatureFlags } from '@atlaskit/media-common/mediaFeatureFlags';
+import type { MediaClientConfig } from '@atlaskit/media-core';
+import type { UploadEndEventPayload, UploadErrorEventPayload, UploadParams, UploadPreviewUpdateEventPayload } from '@atlaskit/media-picker/types';
+import type { CustomMediaPicker, MediaState, MobileUploadEndEventPayload } from './types';
+export type PickerType = 'clipboard' | 'dropzone' | 'customMediaPicker';
+export type ExtendedComponentConfigs = {
+    customMediaPicker: CustomMediaPicker;
+    dropzone: null;
+    clipboard: null;
+};
+export type PickerFacadeConfig = {
+    mediaClientConfig: MediaClientConfig;
+    errorReporter: ErrorReportingHandler;
+    featureFlags?: MediaFeatureFlags;
+};
+export type MediaStateEvent = MediaState;
+export type MediaStateEventListener = (evt: MediaStateEvent) => void;
+export type MediaStateEventSubscriber = (listener: MediaStateEventListener) => void;
+export 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.5/plugin.d.ts

@@ -0,0 +1,7 @@
+import type { MediaProvider } from '@atlaskit/editor-common/provider-factory';
+import type { MediaNextEditorPluginType } from './next-plugin-type';
+import type { MediaState } from './pm-plugins/main';
+import type { CustomMediaPicker } from './types';
+export type { MediaState, MediaProvider, CustomMediaPicker };
+export { insertMediaSingleNode } from './utils/media-single';
+export declare const mediaPlugin: MediaNextEditorPluginType;

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

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

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

@@ -0,0 +1,4 @@
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+export declare const closeMediaAltTextMenu: import("@atlaskit/editor-common/types").Command;
+export declare const openMediaAltTextMenu: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => import("@atlaskit/editor-common/types").Command;
+export declare const updateAltText: (newAltText: string) => import("@atlaskit/editor-common/types").Command;

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

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

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

@@ -0,0 +1,4 @@
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import type { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { Schema } from '@atlaskit/editor-prosemirror/model';
+export default function keymapPlugin(schema: Schema, editorAnalyticsAPI: EditorAnalyticsAPI | undefined): SafePlugin;

package/dist/types-ts4.5/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.5/pm-plugins/alt-text/reducer.d.ts

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

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

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

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

@@ -0,0 +1,41 @@
+import React from 'react';
+import { jsx } from '@emotion/react';
+import type { WrappedComponentProps } from 'react-intl-next';
+import type { WithAnalyticsEventsProps } from '@atlaskit/analytics-next';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+export declare const CONTAINER_WIDTH_IN_PX = 420;
+export declare const MAX_ALT_TEXT_LENGTH = 510;
+type Props = {
+    view: EditorView;
+    value?: string;
+    altTextValidator?: (value: string) => string[];
+    onEscape?: () => void;
+} & WrappedComponentProps & WithAnalyticsEventsProps;
+export 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.5/pm-plugins/keymap-media-single.d.ts

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

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

@@ -0,0 +1,6 @@
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import type { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { EditorSelectionAPI } from '@atlaskit/editor-plugin-selection';
+import type { MediaOptions } from '../types';
+export declare function keymapPlugin(options: MediaOptions | undefined, editorAnalyticsAPI: EditorAnalyticsAPI | undefined, editorSelectionAPI: EditorSelectionAPI | undefined): SafePlugin;
+export default keymapPlugin;

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

@@ -0,0 +1,20 @@
+export declare enum MediaLinkingActionsTypes {
+    showToolbar = "MEDIA_SHOW_TOOLBAR",
+    hideToolbar = "MEDIA_HIDE_TOOLBAR",
+    setUrl = "MEDIA_SET_LINK_TO",
+    unlink = "MEDIA_LINKING_UNLINK"
+}
+export interface VisibleAction {
+    type: MediaLinkingActionsTypes.showToolbar;
+}
+export interface HideAction {
+    type: MediaLinkingActionsTypes.hideToolbar;
+}
+export interface SetLinkToMedia {
+    type: MediaLinkingActionsTypes.setUrl;
+    payload: string;
+}
+export interface Unlink {
+    type: MediaLinkingActionsTypes.unlink;
+}
+export type MediaLinkingActions = VisibleAction | SetLinkToMedia | HideAction | Unlink;

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

@@ -0,0 +1,10 @@
+import type { Dispatch } from '@atlaskit/editor-common/event-dispatcher';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+import type { MediaLinkingActions } from './actions';
+import type { MediaLinkingState } from './types';
+export declare const mediaLinkingPluginKey: PluginKey<MediaLinkingState>;
+export declare const createMediaLinkingCommand: <A = MediaLinkingActions>(action: A | ((state: Readonly<import("prosemirror-state").EditorState>) => false | A), transform?: ((tr: import("prosemirror-state").Transaction, state: import("prosemirror-state").EditorState) => import("prosemirror-state").Transaction) | undefined) => import("@atlaskit/editor-common/types").Command, getMediaLinkingState: (state: import("prosemirror-state").EditorState) => MediaLinkingState;
+export type { MediaLinkingState } from './types';
+declare const _default: (dispatch: Dispatch) => SafePlugin<MediaLinkingState>;
+export default _default;

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

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

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

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

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

@@ -0,0 +1,12 @@
+export type InitialState = {
+    visible: false;
+    editable: false;
+    link: '';
+    mediaPos: null;
+};
+export type MediaLinkingState = {
+    mediaPos: number | null;
+    link: string;
+    editable: boolean;
+    visible: boolean;
+};

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

@@ -0,0 +1,120 @@
+import type { IntlShape } from 'react-intl-next';
+import type { RichMediaLayout as MediaSingleLayout } from '@atlaskit/adf-schema';
+import type { Dispatch } from '@atlaskit/editor-common/event-dispatcher';
+import type { ContextIdentifierProvider, MediaProvider } from '@atlaskit/editor-common/provider-factory';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { Node as PMNode, Schema } from '@atlaskit/editor-prosemirror/model';
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { MediaClientConfig } from '@atlaskit/media-core';
+import type { MediaPluginOptions } from '../media-plugin-options';
+import type { MediaNextEditorPluginType } from '../next-plugin-type';
+import type { MediaStateEventSubscriber } from '../picker-facade';
+import PickerFacade from '../picker-facade';
+import type { MediaOptions, MediaState, MediaStateStatus, getPosHandlerNode as ProsemirrorGetPosHandler } from '../types';
+import type { MediaNodeWithPosHandler, MediaPluginState } from './types';
+export type { MediaState, MediaProvider, MediaStateStatus };
+export { stateKey } from './plugin-key';
+export declare const MEDIA_CONTENT_WRAP_CLASS_NAME = "media-content-wrap";
+export declare const MEDIA_PLUGIN_IS_RESIZING_KEY = "mediaSinglePlugin.isResizing";
+export declare const MEDIA_PLUGIN_RESIZING_WIDTH_KEY = "mediaSinglePlugin.resizing-width";
+export declare class MediaPluginStateImplementation implements MediaPluginState {
+    allowsUploads: boolean;
+    mediaClientConfig?: MediaClientConfig;
+    uploadMediaClientConfig?: MediaClientConfig;
+    ignoreLinks: boolean;
+    waitForMediaUpload: boolean;
+    allUploadsFinished: boolean;
+    showDropzone: boolean;
+    isFullscreen: boolean;
+    element?: HTMLElement;
+    layout: MediaSingleLayout;
+    mediaNodes: MediaNodeWithPosHandler[];
+    options: MediaPluginOptions;
+    mediaProvider?: MediaProvider;
+    newInsertionBehaviour?: boolean;
+    isResizing: boolean;
+    resizingWidth: number;
+    currentMaxWidth?: number;
+    private view;
+    private destroyed;
+    private contextIdentifierProvider?;
+    private errorReporter;
+    private customPicker?;
+    private removeOnCloseListener;
+    private openMediaPickerBrowser?;
+    private onPopupToggleCallback;
+    private nodeCount;
+    private taskManager;
+    pickers: PickerFacade[];
+    pickerPromises: Array<Promise<PickerFacade>>;
+    editingMediaSinglePos?: number;
+    showEditingDialog?: boolean;
+    mediaOptions?: MediaOptions;
+    dispatch?: Dispatch;
+    pluginInjectionApi: ExtractInjectionAPI<MediaNextEditorPluginType> | undefined;
+    singletonCreatedAt: number;
+    constructor(state: EditorState, options: MediaPluginOptions, mediaOptions: MediaOptions | undefined, newInsertionBehaviour: boolean | undefined, dispatch: Dispatch | undefined, pluginInjectionApi: ExtractInjectionAPI<MediaNextEditorPluginType> | undefined);
+    clone(): this;
+    onContextIdentifierProvider: (_name: string, provider?: Promise<ContextIdentifierProvider>) => Promise<void>;
+    setMediaProvider: (mediaProvider?: Promise<MediaProvider>) => Promise<void>;
+    getMediaOptions: () => MediaPluginOptions;
+    setIsResizing(isResizing: boolean): void;
+    setResizingWidth(width: number): void;
+    updateElement(): void;
+    private isMediaSchemaNode;
+    private getDomElement;
+    /**
+     * we insert a new file by inserting a initial state for that file.
+     *
+     * called when we insert a new file via the picker (connected via pickerfacade)
+     */
+    insertFile: (mediaState: MediaState, onMediaStateChanged: MediaStateEventSubscriber, pickerType?: string) => void;
+    addPendingTask: (task: Promise<any>) => void;
+    splitMediaGroup: () => boolean;
+    onPopupPickerClose: () => void;
+    showMediaPicker: () => void;
+    setBrowseFn: (browseFn: () => void) => void;
+    onPopupToggle: (onPopupToggleCallback: (isOpen: boolean) => void) => void;
+    /**
+     * Returns a promise that is resolved after all pending operations have been finished.
+     * An optional timeout will cause the promise to reject if the operation takes too long
+     *
+     * NOTE: The promise will resolve even if some of the media have failed to process.
+     */
+    waitForPendingTasks: (timeout?: number | undefined, lastTask?: Promise<MediaState | null> | undefined) => Promise<MediaState | null>;
+    setView(view: EditorView): void;
+    /**
+     * Called from React UI Component when user clicks on "Delete" icon
+     * inside of it
+     */
+    handleMediaNodeRemoval: (node: PMNode | undefined, getPos: ProsemirrorGetPosHandler) => void;
+    trackMediaNodeAddition: (node: PMNode) => void;
+    trackMediaNodeRemoval: (node: PMNode) => void;
+    /**
+     * Called from React UI Component on componentDidMount
+     */
+    handleMediaNodeMount: (node: PMNode, getPos: ProsemirrorGetPosHandler) => void;
+    /**
+     * Called from React UI Component on componentWillUnmount and UNSAFE_componentWillReceiveProps
+     * when React component's underlying node property is replaced with a new node
+     */
+    handleMediaNodeUnmount: (oldNode: PMNode) => void;
+    handleMediaGroupUpdate: (oldNodes: PMNode[], newNodes: PMNode[]) => void;
+    destroy(): void;
+    findMediaNode: (id: string) => MediaNodeWithPosHandler | null;
+    private destroyAllPickers;
+    private destroyPickers;
+    private initPickers;
+    private getInputMethod;
+    updateMediaSingleNodeAttrs: (id: string, attrs: object) => boolean | undefined;
+    private collectionFromProvider;
+    private handleMediaState;
+    removeSelectedMediaContainer: () => boolean;
+    selectedMediaContainerNode: () => PMNode | undefined;
+    handleDrag: (dragState: 'enter' | 'leave') => void;
+    updateAndDispatch(props: Partial<Pick<this, 'allowsUploads' | 'allUploadsFinished' | 'isFullscreen'>>): void;
+}
+export declare const getMediaPluginState: (state: EditorState) => MediaPluginState;
+export declare const createPlugin: (_schema: Schema, options: MediaPluginOptions, reactContext: () => {}, getIntl: () => IntlShape, pluginInjectionApi: ExtractInjectionAPI<MediaNextEditorPluginType> | undefined, dispatch?: Dispatch, mediaOptions?: MediaOptions, newInsertionBehaviour?: boolean) => SafePlugin<MediaPluginState>;

package/dist/types-ts4.5/pm-plugins/media-editor-plugin-factory.d.ts

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

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

@@ -0,0 +1,9 @@
+import type { MediaState } from '../types';
+export declare class MediaTaskManager {
+    private pendingTask;
+    private taskMap;
+    cancelPendingTask: (id: string) => void;
+    waitForPendingTasks: (timeout?: number, lastTask?: Promise<MediaState | null>) => Promise<MediaState | null>;
+    resumePendingTask: (id: string) => void;
+    addPendingTask: (task: Promise<any>, id?: string) => Promise<MediaState | null>;
+}

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

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

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

@@ -0,0 +1,65 @@
+import type { RichMediaLayout as MediaSingleLayout } from '@atlaskit/adf-schema';
+import type { Dispatch } from '@atlaskit/editor-common/event-dispatcher';
+import type { ContextIdentifierProvider, MediaProvider } from '@atlaskit/editor-common/provider-factory';
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { MediaClientConfig } from '@atlaskit/media-core';
+import type { MediaPluginOptions } from '../media-plugin-options';
+import type { MediaStateEventSubscriber } from '../picker-facade';
+import type PickerFacade from '../picker-facade';
+import type { MediaOptions, MediaState, ProsemirrorGetPosHandler } from '../types';
+export interface MediaNodeWithPosHandler {
+    node: PMNode;
+    getPos: ProsemirrorGetPosHandler;
+}
+export interface MediaPluginState {
+    allowsUploads: boolean;
+    mediaClientConfig?: MediaClientConfig;
+    uploadMediaClientConfig?: MediaClientConfig;
+    ignoreLinks: boolean;
+    waitForMediaUpload: boolean;
+    allUploadsFinished: boolean;
+    showDropzone: boolean;
+    isFullscreen: boolean;
+    element?: HTMLElement;
+    layout: MediaSingleLayout;
+    mediaNodes: MediaNodeWithPosHandler[];
+    options: MediaPluginOptions;
+    mediaProvider?: MediaProvider;
+    pickers: PickerFacade[];
+    pickerPromises: Array<Promise<PickerFacade>>;
+    editingMediaSinglePos?: number;
+    showEditingDialog?: boolean;
+    mediaOptions?: MediaOptions;
+    isResizing: boolean;
+    resizingWidth: number;
+    currentMaxWidth?: number;
+    dispatch?: Dispatch;
+    onContextIdentifierProvider: (_name: string, provider?: Promise<ContextIdentifierProvider>) => Promise<void>;
+    setMediaProvider: (mediaProvider?: Promise<MediaProvider>) => Promise<void>;
+    getMediaOptions: () => MediaPluginOptions;
+    insertFile: (mediaState: MediaState, onMediaStateChanged: MediaStateEventSubscriber, pickerType?: string) => void;
+    addPendingTask: (promise: Promise<any>) => void;
+    splitMediaGroup: () => boolean;
+    onPopupPickerClose: () => void;
+    showMediaPicker: () => void;
+    setBrowseFn: (browseFn: () => void) => void;
+    onPopupToggle: (onPopupToogleCallback: (isOpen: boolean) => void) => void;
+    waitForPendingTasks: (timeout?: number, lastTask?: Promise<MediaState | null>) => Promise<MediaState | null>;
+    handleMediaNodeRemoval: (node: PMNode | undefined, getPos: ProsemirrorGetPosHandler) => void;
+    handleMediaNodeMount: (node: PMNode, getPos: ProsemirrorGetPosHandler) => void;
+    handleMediaNodeUnmount: (oldNode: PMNode) => void;
+    handleMediaGroupUpdate: (oldNodes: PMNode[], newNodes: PMNode[]) => void;
+    findMediaNode: (id: string) => MediaNodeWithPosHandler | null;
+    updateMediaSingleNodeAttrs: (id: string, attrs: object) => undefined | boolean;
+    removeSelectedMediaContainer: () => boolean;
+    selectedMediaContainerNode: () => PMNode | undefined;
+    handleDrag: (dragState: 'enter' | 'leave') => void;
+    updateElement(): void;
+    setIsResizing(isResizing: boolean): void;
+    setResizingWidth(width: number): void;
+    setView(view: EditorView): void;
+    destroy(): void;
+    updateAndDispatch(props: Partial<Pick<this, 'allowsUploads' | 'allUploadsFinished' | 'isFullscreen'>>): void;
+    clone(): MediaPluginState;
+}

package/dist/types-ts4.5/toolbar/alt-text.d.ts

@@ -0,0 +1,13 @@
+import type { IntlShape } from 'react-intl-next';
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import type { Command, FloatingToolbarButton, FloatingToolbarConfig, FloatingToolbarCustom } from '@atlaskit/editor-common/types';
+import type { ForceFocusSelector } from '@atlaskit/editor-plugin-floating-toolbar';
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+import type { MediaToolbarBaseConfig } from '../types';
+export declare const altTextButton: (intl: IntlShape, state: EditorState, editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => FloatingToolbarButton<Command>;
+export declare const altTextEditComponent: (options?: AltTextToolbarOptions) => FloatingToolbarCustom<Command>;
+export interface AltTextToolbarOptions {
+    altTextValidator?: (value: string) => string[];
+    forceFocusSelector?: ForceFocusSelector;
+}
+export declare const getAltTextToolbar: (toolbarBaseConfig: MediaToolbarBaseConfig, options?: AltTextToolbarOptions) => FloatingToolbarConfig;

package/dist/types-ts4.5/toolbar/commands.d.ts

@@ -0,0 +1,12 @@
+import type { BorderMarkAttributes, RichMediaLayout } from '@atlaskit/adf-schema';
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import type { Command } from '@atlaskit/editor-common/types';
+import type { PixelEntryValidation } from '../ui/PixelEntry/types';
+export declare const DEFAULT_BORDER_COLOR = "#091e4224";
+export declare const DEFAULT_BORDER_SIZE = 2;
+export declare const changeInlineToMediaCard: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => Command;
+export declare const changeMediaCardToInline: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => Command;
+export declare const removeInlineCard: Command;
+export declare const toggleBorderMark: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => Command;
+export declare const setBorderMark: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (attrs: Partial<BorderMarkAttributes>) => Command;
+export declare const updateMediaSingleWidth: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (width: number, validation: PixelEntryValidation, layout: RichMediaLayout) => Command;

package/dist/types-ts4.5/toolbar/filePreviewItem.d.ts

@@ -0,0 +1,9 @@
+import type { FC } from 'react';
+import type { IntlShape } from 'react-intl-next';
+import type { MediaPluginState } from '../pm-plugins/types';
+interface FilePreviewProps {
+    mediaPluginState: MediaPluginState;
+    intl: IntlShape;
+}
+export declare const FilePreviewItem: FC<FilePreviewProps>;
+export {};

package/dist/types-ts4.5/toolbar/imageBorder.d.ts

@@ -0,0 +1,2 @@
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+export declare function shouldShowImageBorder(editorState: EditorState): boolean;

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

@@ -0,0 +1,6 @@
+import type { IntlShape } from 'react-intl-next';
+import type { ExtractInjectionAPI, FloatingToolbarConfig } from '@atlaskit/editor-common/types';
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+import type { MediaNextEditorPluginType } from '../next-plugin-type';
+import type { MediaFloatingToolbarOptions } from '../types';
+export declare const floatingToolbar: (state: EditorState, intl: IntlShape, options: MediaFloatingToolbarOptions | undefined, pluginInjectionApi: ExtractInjectionAPI<MediaNextEditorPluginType> | undefined) => FloatingToolbarConfig | undefined;

package/dist/types-ts4.5/toolbar/linking-toolbar-appearance.d.ts

@@ -0,0 +1,14 @@
+/** @jsx jsx */
+import React from 'react';
+import type { IntlShape } from 'react-intl-next';
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+import type { MediaLinkingState } from '../pm-plugins/linking';
+export interface LinkingToolbarProps {
+    editorState: EditorState;
+    intl: IntlShape;
+    mediaLinkingState: MediaLinkingState;
+    onAddLink: React.MouseEventHandler;
+    onEditLink: React.MouseEventHandler;
+    onOpenLink: React.MouseEventHandler;
+}
+export declare const LinkToolbarAppearance: React.FC<LinkingToolbarProps>;

package/dist/types-ts4.5/toolbar/linking.d.ts

@@ -0,0 +1,10 @@
+import type { IntlShape } from 'react-intl-next';
+import type { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import type { FloatingToolbarConfig } from '@atlaskit/editor-common/types';
+import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+import type { MediaNextEditorPluginType } from '../next-plugin-type';
+import type { MediaLinkingState } from '../pm-plugins/linking';
+import type { MediaToolbarBaseConfig } from '../types';
+export declare function shouldShowMediaLinkToolbar(editorState: EditorState): boolean;
+export declare const getLinkingToolbar: (toolbarBaseConfig: MediaToolbarBaseConfig, mediaLinkingState: MediaLinkingState, state: EditorState, intl: IntlShape, pluginInjectionApi: ExtractInjectionAPI<MediaNextEditorPluginType> | undefined, providerFactory?: ProviderFactory) => FloatingToolbarConfig | undefined;

package/dist/types-ts4.5/toolbar/utils.d.ts

@@ -0,0 +1,11 @@
+import type { MediaBaseAttributes, RichMediaLayout } from '@atlaskit/adf-schema';
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { MediaPluginState } from '../pm-plugins/types';
+export declare const getSelectedMediaContainerNodeAttrs: (mediaPluginState: MediaPluginState) => MediaBaseAttributes | null;
+export declare const downloadMedia: (mediaPluginState: MediaPluginState) => Promise<boolean>;
+export declare const removeMediaGroupNode: (state: EditorState) => import("prosemirror-state").Transaction;
+export declare const getSelectedMediaSingle: (state: EditorState) => import("prosemirror-utils/dist/types").FindResult;
+export declare const getPixelWidthOfElement: (editorView: EditorView, pos: number, mediaWidth: number) => number;
+export declare const calcNewLayout: (width: number, layout: RichMediaLayout, contentWidth: number, fullWidthMode?: boolean, isNested?: boolean) => RichMediaLayout;
+export declare const getMaxToolbarWidth: () => number;