@atlaskit/editor-core 182.2.0 → 183.0.6

package/dist/types-ts4.0/plugins/media/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 declare type MediaLinkingActions = VisibleAction | SetLinkToMedia | HideAction | Unlink;

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

@@ -0,0 +1,10 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from 'prosemirror-state';
+import { Dispatch } from '../../../../event-dispatcher';
+import { MediaLinkingActions } from './actions';
+import { MediaLinkingState } from './types';
+export declare const mediaLinkingPluginKey: PluginKey<MediaLinkingState, any>;
+export declare const createMediaLinkingCommand: <A = MediaLinkingActions>(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, getMediaLinkingState: (state: import("prosemirror-state").EditorState<any>) => MediaLinkingState;
+export type { MediaLinkingState } from './types';
+declare const _default: (dispatch: Dispatch) => SafePlugin<MediaLinkingState, import("prosemirror-model").Schema<any, any>>;
+export default _default;

package/dist/types-ts4.0/plugins/media/pm-plugins/linking/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/linking/reducer.d.ts

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

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

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

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

@@ -0,0 +1,108 @@
+import { Node as PMNode, Schema } from 'prosemirror-model';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { EditorState } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+import { MediaClientConfig } from '@atlaskit/media-core';
+import { RichMediaLayout as MediaSingleLayout } from '@atlaskit/adf-schema';
+import type { ContextIdentifierProvider, MediaProvider } from '@atlaskit/editor-common/provider-factory';
+import { Dispatch } from '../../../event-dispatcher';
+import { ProsemirrorGetPosHandler } from '../../../nodeviews';
+import { MediaPluginOptions } from '../media-plugin-options';
+import { MediaOptions, MediaState, MediaStateStatus } from '../types';
+import PickerFacade, { MediaStateEventSubscriber } from '../picker-facade';
+import { MediaNodeWithPosHandler, MediaPluginState } from './types';
+import { IntlShape } from 'react-intl-next';
+export type { MediaState, MediaProvider, MediaStateStatus };
+export { stateKey } from './plugin-key';
+export declare const MEDIA_CONTENT_WRAP_CLASS_NAME = "media-content-wrap";
+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;
+    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;
+    constructor(state: EditorState, options: MediaPluginOptions, mediaOptions?: MediaOptions, newInsertionBehaviour?: boolean, dispatch?: Dispatch);
+    onContextIdentifierProvider: (_name: string, provider?: Promise<ContextIdentifierProvider> | undefined) => Promise<void>;
+    setMediaProvider: (mediaProvider?: Promise<MediaProvider> | undefined) => Promise<void>;
+    getMediaOptions: () => MediaPluginOptions;
+    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 | undefined) => 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, dispatch?: Dispatch<any> | undefined, mediaOptions?: MediaOptions | undefined, newInsertionBehaviour?: boolean | undefined) => SafePlugin<any, any>;

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

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

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

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

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

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

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

@@ -0,0 +1,60 @@
+import { Node as PMNode } from 'prosemirror-model';
+import { MediaClientConfig } from '@atlaskit/media-core';
+import { RichMediaLayout as MediaSingleLayout } from '@atlaskit/adf-schema';
+import type { ContextIdentifierProvider } from '@atlaskit/editor-common/provider-factory';
+import { MediaProvider } from '@atlaskit/editor-common/provider-factory';
+import { MediaOptions, MediaState } from '../types';
+import { MediaPluginOptions } from '../media-plugin-options';
+import { EditorView } from 'prosemirror-view';
+import PickerFacade, { MediaStateEventSubscriber } from '../picker-facade';
+import { Dispatch } from '../../../event-dispatcher';
+import { ProsemirrorGetPosHandler } from '../../../nodeviews/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;
+    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;
+    setView(view: EditorView): void;
+    destroy(): void;
+    updateAndDispatch(props: Partial<Pick<this, 'allowsUploads' | 'allUploadsFinished' | 'isFullscreen'>>): void;
+}

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

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

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

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

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

@@ -0,0 +1,9 @@
+import { BorderMarkAttributes } from '@atlaskit/adf-schema';
+import { Command } from '../../../types';
+export declare const DEFAULT_BORDER_COLOR = "#091e4224";
+export declare const DEFAULT_BORDER_SIZE = 2;
+export declare const changeInlineToMediaCard: Command;
+export declare const changeMediaCardToInline: Command;
+export declare const removeInlineCard: Command;
+export declare const toggleBorderMark: Command;
+export declare const setBorderMark: (attrs: Partial<BorderMarkAttributes>) => Command;

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

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

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

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

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

@@ -0,0 +1,5 @@
+import { EditorState } from 'prosemirror-state';
+import { IntlShape } from 'react-intl-next';
+import { FloatingToolbarConfig } from '../../../plugins/floating-toolbar/types';
+import { MediaFloatingToolbarOptions } from '../types';
+export declare const floatingToolbar: (state: EditorState, intl: IntlShape, options?: MediaFloatingToolbarOptions) => FloatingToolbarConfig | undefined;

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

@@ -0,0 +1,14 @@
+/** @jsx jsx */
+import React from 'react';
+import { IntlShape } from 'react-intl-next';
+import { EditorState } from 'prosemirror-state';
+import { 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.0/plugins/media/toolbar/linking.d.ts

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

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

@@ -0,0 +1,6 @@
+import { MediaBaseAttributes } from '@atlaskit/adf-schema';
+import { EditorState } from 'prosemirror-state';
+import { 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<any>;

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

@@ -0,0 +1,102 @@
+import { EditorView } from 'prosemirror-view';
+import { NodeType } from 'prosemirror-model';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import { Providers } from '@atlaskit/editor-common/provider-factory';
+import { FileIdentifier } from '@atlaskit/media-client';
+import { MediaClientConfig } from '@atlaskit/media-core';
+import { MediaFeatureFlags } from '@atlaskit/media-common';
+import { UploadParams, MediaFile } from '@atlaskit/media-picker/types';
+import { EditorSelectionAPI } from '@atlaskit/editor-common/selection';
+import { GetEditorFeatureFlags } from '@atlaskit/editor-common/types';
+import { PlaceholderTextOptions } from '../../plugins/placeholder-text/types';
+export declare type MediaStateStatus = 'unknown' | 'ready' | 'cancelled' | 'preview' | 'error' | 'mobile-upload-end';
+export interface MediaOptions {
+    provider?: Providers['mediaProvider'];
+    allowMediaSingle?: boolean | MediaSingleOptions;
+    allowMediaGroup?: boolean;
+    customDropzoneContainer?: HTMLElement;
+    customMediaPicker?: CustomMediaPicker;
+    allowResizing?: boolean;
+    allowResizingInTables?: boolean;
+    allowLinking?: boolean;
+    allowLazyLoading?: boolean;
+    allowBreakoutSnapPoints?: boolean;
+    allowAdvancedToolBarOptions?: boolean;
+    allowMediaSingleEditable?: boolean;
+    allowRemoteDimensionsFetch?: boolean;
+    allowDropzoneDropLine?: boolean;
+    allowMarkingUploadsAsIncomplete?: boolean;
+    fullWidthEnabled?: boolean;
+    uploadErrorHandler?: (state: MediaState) => void;
+    waitForMediaUpload?: boolean;
+    isCopyPasteEnabled?: boolean;
+    allowAltTextOnImages?: boolean;
+    enableDownloadButton?: boolean;
+    altTextValidator?: (value: string) => string[];
+    useForgePlugins?: boolean;
+    allowTemplatePlaceholders?: boolean | PlaceholderTextOptions;
+    alignLeftOnInsert?: boolean;
+    editorSelectionAPI?: EditorSelectionAPI;
+    featureFlags?: MediaFeatureFlags;
+    getEditorFeatureFlags?: GetEditorFeatureFlags;
+}
+export interface MediaSingleOptions {
+    disableLayout?: boolean;
+}
+export interface MediaState {
+    id: string;
+    status?: MediaStateStatus;
+    fileName?: string;
+    fileSize?: number;
+    fileMimeType?: string;
+    collection?: string;
+    dimensions?: {
+        width: number | undefined;
+        height: number | undefined;
+    };
+    scaleFactor?: number;
+    error?: {
+        name: string;
+        description: string;
+    };
+    /** still require to support Mobile */
+    publicId?: string;
+    contextId?: string;
+}
+export declare type Listener = (data: any) => void;
+export interface CustomMediaPicker {
+    on(event: string, cb: Listener): void;
+    removeAllListeners(event: any): void;
+    emit(event: string, data: any): void;
+    destroy(): void;
+    setUploadParams(uploadParams: UploadParams): void;
+}
+export declare type MobileUploadEndEventPayload = {
+    readonly file: MediaFile & {
+        readonly collectionName?: string;
+        readonly publicId?: string;
+    };
+};
+export declare type MediaEditorState = {
+    mediaClientConfig?: MediaClientConfig;
+    editor?: {
+        pos: number;
+        identifier: FileIdentifier;
+    };
+};
+export declare type MediaToolbarBaseConfig = {
+    title: string;
+    getDomRef?: (view: EditorView) => HTMLElement | undefined;
+    nodeType: NodeType | NodeType[];
+};
+export declare type MediaFloatingToolbarOptions = {
+    providerFactory?: ProviderFactory;
+    allowResizing?: boolean;
+    allowMediaInline?: boolean;
+    allowLinking?: boolean;
+    allowAdvancedToolBarOptions?: boolean;
+    allowResizingInTables?: boolean;
+    allowAltTextOnImages?: boolean;
+    altTextValidator?: (value: string) => string[];
+    getEditorFeatureFlags?: GetEditorFeatureFlags;
+};

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

@@ -0,0 +1,7 @@
+/** @jsx jsx */
+import React from 'react';
+export declare const CAPTION_PLACEHOLDER_ID = "caption-placeholder";
+declare const _default: React.ForwardRefExoticComponent<{
+    onClick: () => void;
+} & React.RefAttributes<HTMLSpanElement>>;
+export default _default;

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

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

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

@@ -0,0 +1,13 @@
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+import { IntlShape } from 'react-intl-next';
+import { BorderMarkAttributes } from '@atlaskit/adf-schema';
+export interface ImageBorderProps {
+    intl: IntlShape;
+    toggleBorder: () => void;
+    borderMark?: BorderMarkAttributes;
+    showSomewhatSemanticTooltips?: boolean;
+    setBorder: (attrs: Partial<BorderMarkAttributes>) => void;
+}
+declare const ImageBorder: ({ intl: { formatMessage }, toggleBorder, showSomewhatSemanticTooltips, borderMark, setBorder, }: ImageBorderProps) => jsx.JSX.Element;
+export default ImageBorder;

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

@@ -0,0 +1,42 @@
+export declare const messages: {
+    borderColor: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    borderSize: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    addBorder: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    removeBorder: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    borderOptions: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    borderSizeSubtle: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    borderSizeMedium: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    borderSizeBold: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};

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

@@ -0,0 +1,15 @@
+export declare const menuItemDimensions: {
+    width: number;
+    height: number;
+};
+export declare const itemSpacing: number;
+export declare const contextualMenuArrow: import("@emotion/react").SerializedStyles;
+export declare const contextualMenuColorIcon: (color?: string | undefined) => import("@emotion/react").SerializedStyles;
+export declare const contextualSubMenu: (index: number) => import("@emotion/react").SerializedStyles;
+export declare const buttonStyle: (selected: boolean) => import("@emotion/react").SerializedStyles;
+export declare const buttonWrapperStyle: import("@emotion/react").SerializedStyles;
+export declare const line: (size: number, selected: boolean) => import("@emotion/react").SerializedStyles;
+export declare const toolbarButtonWrapper: ({ enabled, isOpen, }: {
+    enabled: boolean;
+    isOpen: boolean;
+}) => import("@emotion/react").SerializedStyles;

package/dist/types-ts4.0/plugins/media/ui/Media/DropPlaceholder.d.ts

@@ -0,0 +1,8 @@
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+export declare type PlaceholderType = 'single' | 'group';
+export interface Props {
+    type: PlaceholderType;
+}
+declare const _default: ({ type }: Props) => jsx.JSX.Element;
+export default _default;

package/dist/types-ts4.0/plugins/media/ui/Media/drop-placeholder-messages.d.ts

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

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

@@ -0,0 +1,35 @@
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import { IntlShape, WrappedComponentProps } from 'react-intl-next';
+import { RecentSearchInputTypes } from '../../../ui/LinkSearch/types';
+export declare type Props = {
+    intl: IntlShape;
+    providerFactory: ProviderFactory;
+    editing: boolean;
+    onBack: (url: string, meta: {
+        inputMethod?: RecentSearchInputTypes;
+    }) => void;
+    onUnlink: () => void;
+    onCancel: () => void;
+    onBlur: (href: string) => void;
+    onSubmit: (href: string, meta: {
+        inputMethod: RecentSearchInputTypes;
+    }) => void;
+    displayUrl?: string;
+};
+export declare class LinkAddToolbar extends React.PureComponent<Props & WrappedComponentProps> {
+    state: {
+        validationErrors: never[];
+    };
+    private handleSubmit;
+    private handleOnBack;
+    private handleCancel;
+    private handleUnlink;
+    private handleOnBlur;
+    private getValidationErrors;
+    private renderContainer;
+    render(): jsx.JSX.Element;
+}
+export default LinkAddToolbar;

package/dist/types-ts4.0/plugins/media/ui/MediaPicker/BrowserWrapper.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { MediaPluginState } from '../../pm-plugins/types';
+import { MediaFeatureFlags } from '@atlaskit/media-common/mediaFeatureFlags';
+declare type Props = {
+    mediaState: MediaPluginState;
+    isOpen?: boolean;
+    onBrowseFn: (browse: () => void) => void;
+    featureFlags?: MediaFeatureFlags;
+};
+export declare const BrowserWrapper: ({ mediaState, isOpen, onBrowseFn, featureFlags, }: Props) => JSX.Element;
+export {};

package/dist/types-ts4.0/plugins/media/ui/MediaPicker/ClipboardWrapper.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { MediaPluginState } from '../../pm-plugins/types';
+import { MediaFeatureFlags } from '@atlaskit/media-common/mediaFeatureFlags';
+declare type Props = {
+    mediaState: MediaPluginState;
+    featureFlags?: MediaFeatureFlags;
+};
+export declare const ClipboardWrapper: ({ mediaState, featureFlags }: Props) => JSX.Element;
+export {};

package/dist/types-ts4.0/plugins/media/ui/MediaPicker/DropzoneWrapper.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import { MediaPluginState } from '../../pm-plugins/types';
+import { MediaFeatureFlags } from '@atlaskit/media-common/mediaFeatureFlags';
+import { EditorAppearance } from '../../../../types/editor-appearance';
+declare type Props = {
+    mediaState: MediaPluginState;
+    isActive: boolean;
+    featureFlags?: MediaFeatureFlags;
+    editorDomElement: Element;
+    appearance: EditorAppearance;
+};
+export declare const DropzoneWrapper: ({ mediaState, isActive, featureFlags, editorDomElement, appearance, }: Props) => JSX.Element;
+export {};

package/dist/types-ts4.0/plugins/media/ui/MediaPicker/PickerFacadeProvider.d.ts

@@ -0,0 +1,28 @@
+import React from 'react';
+import { ClipboardConfig, BrowserConfig, DropzoneConfig } from '@atlaskit/media-picker/types';
+import { MediaClientConfig } from '@atlaskit/media-core';
+import PickerFacade from '../../picker-facade';
+import { MediaPluginState } from '../../pm-plugins/types';
+export interface ChildrenProps {
+    config: ClipboardConfig | BrowserConfig | DropzoneConfig;
+    mediaClientConfig: MediaClientConfig;
+    pickerFacadeInstance: PickerFacade;
+}
+export declare type Props = {
+    mediaState: MediaPluginState;
+    analyticsName: string;
+    children: (props: ChildrenProps) => React.ReactNode;
+};
+declare type State = {
+    config?: ClipboardConfig | BrowserConfig | DropzoneConfig;
+    mediaClientConfig?: MediaClientConfig;
+    pickerFacadeInstance?: PickerFacade;
+};
+export default class PickerFacadeProvider extends React.Component<Props, State> {
+    state: State;
+    private handleMediaProvider;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    render(): React.ReactNode;
+}
+export {};