@atlaskit/editor-plugin-media 0.3.1 → 0.3.2

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

@@ -0,0 +1,119 @@
+import type { ProviderFactory, Providers } from '@atlaskit/editor-common/provider-factory';
+import type { EditorSelectionAPI } from '@atlaskit/editor-common/selection';
+import type { GetEditorFeatureFlags } from '@atlaskit/editor-common/types';
+import type { NodeType } from '@atlaskit/editor-prosemirror/model';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { FileIdentifier } from '@atlaskit/media-client';
+import type { MediaFeatureFlags } from '@atlaskit/media-common';
+import type { MediaClientConfig } from '@atlaskit/media-core';
+import type { MediaFile, UploadParams } from '@atlaskit/media-picker/types';
+interface PlaceholderTextOptions {
+    allowInserting?: boolean;
+}
+export type MediaStateStatus = 'unknown' | 'ready' | 'cancelled' | 'preview' | 'error' | 'mobile-upload-end';
+export type MediaSingleWithType = 'pixel' | 'percentage';
+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;
+    allowCaptions?: boolean;
+}
+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 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 type MobileUploadEndEventPayload = {
+    readonly file: MediaFile & {
+        readonly collectionName?: string;
+        readonly publicId?: string;
+    };
+};
+export type MediaEditorState = {
+    mediaClientConfig?: MediaClientConfig;
+    editor?: {
+        pos: number;
+        identifier: FileIdentifier;
+    };
+};
+export type MediaToolbarBaseConfig = {
+    title: string;
+    getDomRef?: (view: EditorView) => HTMLElement | undefined;
+    nodeType: NodeType | NodeType[];
+};
+export type MediaFloatingToolbarOptions = {
+    providerFactory?: ProviderFactory;
+    allowResizing?: boolean;
+    allowMediaInline?: boolean;
+    allowLinking?: boolean;
+    allowAdvancedToolBarOptions?: boolean;
+    allowResizingInTables?: boolean;
+    allowAltTextOnImages?: boolean;
+    altTextValidator?: (value: string) => string[];
+    getEditorFeatureFlags?: GetEditorFeatureFlags;
+    fullWidthEnabled?: boolean;
+};
+export type MediaDecorationSpec = {
+    type: 'media';
+    selected: boolean;
+};
+export type ProsemirrorGetPosHandler = getPosHandlerNode;
+export type getPosHandler = getPosHandlerNode;
+export type getPosHandlerNode = () => number | undefined;
+export interface ReactNodeProps {
+    selected: boolean;
+}
+export type ForwardRef = (node: HTMLElement | null) => void;
+export type { InsertMediaAsMediaSingle } from './utils/media-single';
+export type { MediaPluginState } from './pm-plugins/types';

package/dist/types-ts4.5/ui/CaptionPlaceholder/index.d.ts

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

package/dist/types-ts4.5/ui/CaptionPlaceholder/messages.d.ts

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

package/dist/types-ts4.5/ui/ImageBorder/index.d.ts

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

package/dist/types-ts4.5/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.5/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) => 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.5/ui/Media/DropPlaceholder.d.ts

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

package/dist/types-ts4.5/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.5/ui/MediaLinkingToolbar.d.ts

@@ -0,0 +1,35 @@
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+import type { IntlShape, WrappedComponentProps } from 'react-intl-next';
+import type { RecentSearchInputTypes } from '@atlaskit/editor-common/link';
+import type { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+export 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.5/ui/MediaPicker/BrowserWrapper.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import type { MediaFeatureFlags } from '@atlaskit/media-common/mediaFeatureFlags';
+import type { MediaPluginState } from '../../pm-plugins/types';
+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.5/ui/MediaPicker/ClipboardWrapper.d.ts

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

package/dist/types-ts4.5/ui/MediaPicker/DropzoneWrapper.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import type { EditorAppearance } from '@atlaskit/editor-common/types';
+import type { MediaFeatureFlags } from '@atlaskit/media-common/mediaFeatureFlags';
+import type { MediaPluginState } from '../../pm-plugins/types';
+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.5/ui/MediaPicker/PickerFacadeProvider.d.ts

@@ -0,0 +1,28 @@
+import React from 'react';
+import type { MediaClientConfig } from '@atlaskit/media-core';
+import type { BrowserConfig, ClipboardConfig, DropzoneConfig } from '@atlaskit/media-picker/types';
+import PickerFacade from '../../picker-facade';
+import type { MediaPluginState } from '../../pm-plugins/types';
+export interface ChildrenProps {
+    config: ClipboardConfig | BrowserConfig | DropzoneConfig;
+    mediaClientConfig: MediaClientConfig;
+    pickerFacadeInstance: PickerFacade;
+}
+export type Props = {
+    mediaState: MediaPluginState;
+    analyticsName: string;
+    children: (props: ChildrenProps) => React.ReactNode;
+};
+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 {};

package/dist/types-ts4.5/ui/MediaPicker/index.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+import type { EditorAppearance, ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { MediaNextEditorPluginType } from '../../next-plugin-type';
+import type { MediaPluginState } from '../../pm-plugins/types';
+type Props = {
+    mediaState: MediaPluginState;
+    editorDomElement: Element;
+    appearance: EditorAppearance;
+    api: ExtractInjectionAPI<MediaNextEditorPluginType> | undefined;
+};
+type State = {
+    isPopupOpened: boolean;
+};
+export declare class MediaPickerComponents extends React.Component<Props, State> {
+    static displayName: string;
+    state: {
+        isPopupOpened: boolean;
+    };
+    componentDidMount(): void;
+    onBrowseFn: (nativeBrowseFn: () => void) => void;
+    render(): JSX.Element;
+}
+export {};

package/dist/types-ts4.5/ui/PixelEntry/constants.d.ts

@@ -0,0 +1 @@
+export declare const PIXELENTRY_MIGRATION_BUTTON_TESTID = "pixel-entry-convert-pixels-btn";

package/dist/types-ts4.5/ui/PixelEntry/index.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { jsx } from '@emotion/react';
+import type { IntlShape } from 'react-intl-next';
+import type { PixelEntryProps } from './types';
+export declare const PixelEntry: ({ width, mediaWidth, mediaHeight, onSubmit, minWidth, maxWidth, onChange, intl: { formatMessage }, showMigration, onMigrate, }: PixelEntryProps) => jsx.JSX.Element;
+export declare const FullWidthDisplay: React.FC<{
+    intl: IntlShape;
+}>;

package/dist/types-ts4.5/ui/PixelEntry/messages.d.ts

@@ -0,0 +1,47 @@
+export declare const messages: {
+    validationFailedMessage: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    inputWidthTooltip: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    inputWidthAriaLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    inputHeightTooltip: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    inputHeightAriaLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    submitButtonText: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    fullWidthLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    migrationButtonText: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    migrationButtonTooltip: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};

package/dist/types-ts4.5/ui/PixelEntry/styles.d.ts

@@ -0,0 +1,8 @@
+export declare const pixelSizingWrapper: import("@emotion/react").SerializedStyles;
+export declare const pixelEntryForm: import("@emotion/react").SerializedStyles;
+export declare const pixelSizingInput: import("@emotion/react").SerializedStyles;
+export declare const pixelSizingLabel: import("@emotion/react").SerializedStyles;
+export declare const pixelSizingWidthInput: import("@emotion/react").SerializedStyles;
+export declare const pixelSizingHeightInput: import("@emotion/react").SerializedStyles;
+export declare const pixelEntryHiddenSubmit: import("@emotion/react").SerializedStyles;
+export declare const pixelSizingFullWidthLabelStyles: import("@emotion/react").SerializedStyles;

package/dist/types-ts4.5/ui/PixelEntry/types.d.ts

@@ -0,0 +1,58 @@
+import type { IntlShape } from 'react-intl-next';
+export type PixelEntryProps = {
+    /**
+     * IntlShape passed in for translations
+     */
+    intl: IntlShape;
+    /**
+     * The current pixel width
+     */
+    width: number;
+    /**
+     * The original media width used to calculate the height
+     */
+    mediaWidth: number;
+    /**
+     * The original media height used to calculate the width
+     */
+    mediaHeight: number;
+    /**
+     * The minimum acceptable width input
+     */
+    minWidth: number;
+    /**
+     * The maximum acceptable width input
+     */
+    maxWidth: number;
+    /**
+     *
+     * Handler for valid input
+     */
+    onChange?: (valid: boolean) => void;
+    /**
+     * show migration button to convert to pixels for legacy image resize experience
+     */
+    showMigration?: boolean;
+    /**
+     * The submit function that is called when the form is valid and the submit key is pressed
+     */
+    onSubmit?: (value: PixelEntryFormData) => void;
+    /**
+     * An optional validate function that is called before onSubmit is called.
+     * The value passed through the validator currently comes from the width input only.
+     */
+    validate?: (value: number | '') => boolean;
+    /**
+     * Migration handler called when the CTA button is clicked
+     */
+    onMigrate?: () => void;
+};
+export type PixelEntryFormValues = {
+    inputWidth: number | '';
+    inputHeight: number | '';
+};
+export type PixelEntryValidation = 'valid' | 'greater-than-max' | 'less-than-min';
+export type PixelEntryFormData = {
+    width: number;
+    validation: PixelEntryValidation;
+};

package/dist/types-ts4.5/ui/ResizableMediaSingle/ResizableMediaMigrationNotification.d.ts

@@ -0,0 +1,3 @@
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+export declare const ResizableMediaMigrationNotification: () => jsx.JSX.Element;

package/dist/types-ts4.5/ui/ResizableMediaSingle/ResizableMediaSingleNext.d.ts

@@ -0,0 +1,59 @@
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+import type { RichMediaLayout as MediaSingleLayout } from '@atlaskit/adf-schema';
+import type { GuidelineConfig, GuidelineSnapsReference, RelativeGuides } from '@atlaskit/editor-common/guideline';
+import type { Dimensions, HandleResize, HandleResizeStart, Position, Snap } from '@atlaskit/editor-common/resizer';
+import type { MediaClientConfig } from '@atlaskit/media-core';
+import type { Props } from './types';
+type State = {
+    isVideoFile: boolean;
+    isResizing: boolean;
+    size: Dimensions;
+    snaps: Snap;
+    relativeGuides: RelativeGuides;
+    guidelines: GuidelineConfig[];
+};
+export declare const resizerNextTestId = "mediaSingle.resizerNext.testid";
+type ResizableMediaSingleNextProps = Props & {
+    showLegacyNotification?: boolean;
+};
+declare class ResizableMediaSingleNext extends React.Component<ResizableMediaSingleNextProps, State> {
+    private lastSnappedGuidelineKeys;
+    constructor(props: ResizableMediaSingleNextProps);
+    componentDidUpdate(prevProps: Props): boolean;
+    componentDidMount(): Promise<void>;
+    UNSAFE_componentWillReceiveProps(nextProps: Props): void;
+    get wrappedLayout(): boolean;
+    get pos(): number | null;
+    get $pos(): import("prosemirror-model").ResolvedPos | null;
+    get aspectRatio(): number;
+    get insideInlineLike(): boolean;
+    get insideLayout(): boolean;
+    get isGuidelineEnabled(): boolean;
+    isNestedNode(): boolean;
+    private getDefaultGuidelines;
+    private updateGuidelines;
+    checkVideoFile(viewMediaClientConfig?: MediaClientConfig): Promise<void>;
+    calcNewLayout: (newWidth: number, stop: boolean) => MediaSingleLayout;
+    calcUnwrappedLayout: (width: number, containerWidth: number, contentWidth: number, fullWidthMode?: boolean, isNestedNode?: boolean) => 'center' | 'wide' | 'full-width';
+    calcPxHeight: (newWidth: number) => number;
+    private displayGuideline;
+    private setIsResizing;
+    private updateSizeInPluginState;
+    private calcMaxWidth;
+    private calcMinWidth;
+    private getRelativeGuides;
+    updateActiveGuidelines: (width: number | undefined, guidelines: GuidelineConfig[], guidelineSnapsReference: GuidelineSnapsReference) => void;
+    calculateSizeState: (size: Position & Dimensions, delta: Dimensions, onResizeStop?: boolean) => {
+        width: number;
+        height: number;
+        layout: MediaSingleLayout;
+    };
+    selectCurrentMediaNode: () => void;
+    handleResizeStart: HandleResizeStart;
+    handleResize: HandleResize;
+    handleResizeStop: HandleResize;
+    render(): jsx.JSX.Element;
+}
+export default ResizableMediaSingleNext;

package/dist/types-ts4.5/ui/ResizableMediaSingle/index.d.ts

@@ -0,0 +1,45 @@
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+import type { RichMediaLayout as MediaSingleLayout } from '@atlaskit/adf-schema';
+import type { MediaClientConfig } from '@atlaskit/media-core';
+import type { Props } from './types';
+type State = {
+    offsetLeft: number;
+    isVideoFile: boolean;
+    resizedPctWidth?: number;
+};
+export default class ResizableMediaSingle extends React.Component<Props, State> {
+    state: State;
+    componentDidUpdate(prevProps: Props): boolean;
+    private displayGrid;
+    get wrappedLayout(): boolean;
+    isNestedInTable(): boolean;
+    componentDidMount(): Promise<void>;
+    UNSAFE_componentWillReceiveProps(nextProps: Props): void;
+    checkVideoFile(viewMediaClientConfig?: MediaClientConfig): Promise<void>;
+    /**
+     * When returning to center layout from a wrapped/aligned layout, it might actually
+     * be wide or full-width
+     */
+    checkLayout(oldLayout: MediaSingleLayout, newLayout: MediaSingleLayout): void;
+    calcNewSize: (newWidth: number, stop: boolean) => {
+        width: number | null;
+        layout: MediaSingleLayout;
+    };
+    calcUnwrappedLayout: (pct: number, width: number) => 'center' | 'wide' | 'full-width';
+    get $pos(): import("prosemirror-model").ResolvedPos | null;
+    /**
+     * The maxmimum number of grid columns this node can resize to.
+     */
+    get gridWidth(): number;
+    calcColumnLeftOffset: () => number;
+    wrapper?: HTMLElement;
+    calcPxWidth: (useLayout?: MediaSingleLayout) => number;
+    get insideInlineLike(): boolean;
+    get insideLayout(): boolean;
+    highlights: (newWidth: number, snapPoints: number[]) => string[] | number[];
+    private saveWrapper;
+    render(): jsx.JSX.Element;
+}
+export {};

package/dist/types-ts4.5/ui/ResizableMediaSingle/styled.d.ts

@@ -0,0 +1,2 @@
+import type { MediaSingleDimensionHelperProps } from '@atlaskit/editor-common/ui';
+export declare const wrapperStyle: (props: MediaSingleDimensionHelperProps) => import("@emotion/react").SerializedStyles;

package/dist/types-ts4.5/ui/ResizableMediaSingle/styles.d.ts

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

package/dist/types-ts4.5/ui/ResizableMediaSingle/types.d.ts

@@ -0,0 +1,27 @@
+import type { RichMediaLayout as MediaSingleLayout } from '@atlaskit/adf-schema';
+import type { DispatchAnalyticsEvent } from '@atlaskit/editor-common/analytics';
+import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { MediaSingleProps } from '@atlaskit/editor-common/ui';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { MediaClientConfig } from '@atlaskit/media-core';
+import type { MediaNextEditorPluginType } from '../../next-plugin-type';
+import type { getPosHandler } from '../../types';
+export type EnabledHandles = {
+    left?: boolean;
+    right?: boolean;
+};
+export type Props = MediaSingleProps & {
+    updateSize: (width: number | null, layout: MediaSingleLayout) => void;
+    getPos: getPosHandler;
+    view: EditorView;
+    lineLength: number;
+    gridSize: number;
+    containerWidth: number;
+    allowBreakoutSnapPoints?: boolean;
+    selected: boolean;
+    viewMediaClientConfig?: MediaClientConfig;
+    fullWidthMode?: boolean;
+    dispatchAnalyticsEvent: DispatchAnalyticsEvent;
+    mediaSingleWidth?: number;
+    pluginInjectionApi: ExtractInjectionAPI<MediaNextEditorPluginType> | undefined;
+};

package/dist/types-ts4.5/ui/ToolbarMedia/index.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import type { WrappedComponentProps } from 'react-intl-next';
+import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { MediaNextEditorPluginType } from '../../next-plugin-type';
+export interface Props {
+    isDisabled?: boolean;
+    isReducedSpacing?: boolean;
+    api: ExtractInjectionAPI<MediaNextEditorPluginType> | undefined;
+}
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<Props & WrappedComponentProps<"intl">>;
+};
+export default _default;

package/dist/types-ts4.5/ui/ToolbarMedia/toolbar-media-messages.d.ts

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

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

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