@atlaskit/editor-common 76.9.0 → 76.9.2

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

@@ -0,0 +1,57 @@
+/** @jsx jsx */
+import type { RefObject } from 'react';
+import React from 'react';
+import { jsx } from '@emotion/react';
+import type { RichMediaLayout as MediaSingleLayout } from '@atlaskit/adf-schema';
+/**
+ * Calculates the image width for non-resized images.
+ *
+ * If an image has not been resized using the pctWidth attribute,
+ * then an image in wide or full-width can not be wider than the image's
+ * original width.
+ */
+export declare function calcLegacyWidth(layout: MediaSingleLayout, width: number, containerWidth?: number, fullWidthMode?: boolean, isResized?: boolean): string;
+/**
+ * Calculates the image width for previously resized images.
+ *
+ * Wide and full-width images are always that size (960px and 100%); there is
+ * no distinction between max-width and width.
+ */
+export declare function calcResizedWidth(layout: MediaSingleLayout, width: number, containerWidth?: number): any;
+export interface MediaSingleWrapperProps {
+    containerWidth?: number;
+    fullWidthMode?: boolean;
+    isResized?: boolean;
+    layout: MediaSingleLayout;
+    /**
+     * @private
+     * @deprecated Use {@link MediaSingleWrapperProps["mediaSingleWidth"]} instead.
+     * Cleanup ticket: https://product-fabric.atlassian.net/browse/ED-19076
+     */
+    pctWidth?: number;
+    mediaSingleWidth?: number;
+    width?: number;
+    innerRef?: ((elem: HTMLDivElement) => void) | RefObject<HTMLDivElement>;
+    isExtendedResizeExperienceOn?: boolean;
+    isNestedNode?: boolean;
+}
+/**
+ * Can't use `.attrs` to handle highly dynamic styles because we are still
+ * supporting `styled-components` v1.
+ */
+export declare const MediaSingleDimensionHelper: ({ containerWidth, fullWidthMode, isResized, layout, mediaSingleWidth, width, isExtendedResizeExperienceOn, isNestedNode, }: MediaSingleWrapperProps) => import("@emotion/react").SerializedStyles;
+export interface MediaWrapperProps {
+    paddingBottom?: string;
+    height?: number;
+    hasFallbackContainer?: boolean;
+}
+export declare const mediaWrapperStyle: (props: MediaWrapperProps) => import("@emotion/react").SerializedStyles;
+export declare const MediaWrapper: {
+    ({ children, ...rest }: React.HTMLAttributes<HTMLDivElement> & MediaWrapperProps): jsx.JSX.Element;
+    displayName: string;
+};
+type MediaBorderGapFillerProps = {
+    borderColor: string;
+};
+export declare const MediaBorderGapFiller: React.FC<MediaBorderGapFillerProps>;
+export {};

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

@@ -0,0 +1,12 @@
+export type MediaSingleWidthType = 'pixel' | 'percentage';
+export type MediaSingleSize = {
+    /**
+     * The width attribute from mediaSingle node
+     */
+    width?: number;
+    /**
+     * The widthType attribute from mediaSingle node
+     * @default percentage
+     */
+    widthType?: MediaSingleWidthType;
+};

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

@@ -0,0 +1,21 @@
+import { PureComponent } from 'react';
+import { ProviderFactory } from '../../provider-factory';
+import { ProfilecardProvider } from '../../provider-factory/profile-card-provider';
+import { MentionEventHandlers } from '../EventHandlers';
+export interface MentionProps {
+    id: string;
+    providers?: ProviderFactory;
+    eventHandlers?: MentionEventHandlers;
+    text: string;
+    accessLevel?: string;
+}
+export interface MentionState {
+    profilecardProvider: ProfilecardProvider | null;
+}
+export default class Mention extends PureComponent<MentionProps, {}> {
+    private providerFactory;
+    constructor(props: MentionProps);
+    componentWillUnmount(): void;
+    private renderWithProvider;
+    render(): JSX.Element;
+}

package/dist/types-ts4.5/ui/Mention/mention-with-profilecard.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+import { MentionProvider } from '@atlaskit/mention';
+import { ProfilecardProvider } from '../../provider-factory/profile-card-provider';
+import { MentionEventHandler } from '../EventHandlers';
+export interface Props {
+    id: string;
+    text: string;
+    accessLevel?: string;
+    mentionProvider?: Promise<MentionProvider>;
+    profilecardProvider: ProfilecardProvider;
+    onClick?: MentionEventHandler;
+    onMouseEnter?: MentionEventHandler;
+    onMouseLeave?: MentionEventHandler;
+}
+export default function MentionWithProfileCard({ id, text, accessLevel, mentionProvider, profilecardProvider, onClick, onMouseEnter, onMouseLeave, }: Props): JSX.Element;

package/dist/types-ts4.5/ui/Mention/mention-with-providers.d.ts

@@ -0,0 +1,22 @@
+import { PureComponent } from 'react';
+import { MentionProvider } from '@atlaskit/mention/resource';
+import { ProfilecardProvider } from '../../provider-factory/profile-card-provider';
+import { MentionEventHandlers } from '../EventHandlers';
+export interface Props {
+    id: string;
+    text: string;
+    accessLevel?: string;
+    mentionProvider?: Promise<MentionProvider>;
+    profilecardProvider?: Promise<ProfilecardProvider>;
+    eventHandlers?: MentionEventHandlers;
+}
+export interface State {
+    profilecardProvider: ProfilecardProvider | null;
+}
+export default class MentionWithProviders extends PureComponent<Props, State> {
+    state: State;
+    UNSAFE_componentWillMount(): void;
+    UNSAFE_componentWillReceiveProps(nextProps: Props): void;
+    private updateProfilecardProvider;
+    render(): JSX.Element;
+}

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

@@ -0,0 +1,2 @@
+import { ProfileCardAction } from '@atlaskit/profilecard';
+export type { ProfileCardAction };

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

@@ -0,0 +1,11 @@
+/** @jsx jsx */
+import { ReactNode } from 'react';
+import { jsx } from '@emotion/react';
+interface Props {
+    /** The content of the message */
+    children: ReactNode;
+}
+export declare const HelperMessage: ({ children }: Props) => jsx.JSX.Element;
+export declare const ErrorMessage: ({ children }: Props) => jsx.JSX.Element;
+export declare const ValidMessage: ({ children }: Props) => jsx.JSX.Element;
+export {};

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

@@ -0,0 +1,103 @@
+import React from 'react';
+import { ShadowObserver } from './shadowObserver';
+export declare const shadowClassNames: {
+    RIGHT_SHADOW: string;
+    LEFT_SHADOW: string;
+};
+export interface OverflowShadowProps {
+    handleRef?: (ref: HTMLElement | null) => void;
+    shadowClassNames?: string;
+}
+export interface OverflowShadowState {
+    showLeftShadow: boolean;
+    showRightShadow: boolean;
+}
+export interface OverflowShadowOptions {
+    overflowSelector: string;
+    useShadowObserver?: boolean;
+}
+export default function overflowShadow<P>(Component: React.ComponentType<P & OverflowShadowProps> | React.StatelessComponent<P & OverflowShadowProps>, options: OverflowShadowOptions): {
+    new (props: P | Readonly<P>): {
+        overflowContainer?: HTMLElement | null | undefined;
+        container?: HTMLElement | undefined;
+        shadowObserver?: ShadowObserver | undefined;
+        overflowContainerWidth: number;
+        scrollable?: NodeList | undefined;
+        diff?: number | undefined;
+        state: {
+            showLeftShadow: boolean;
+            showRightShadow: boolean;
+        };
+        componentWillUnmount(): void;
+        componentDidUpdate(): void;
+        handleScroll: (event: Event) => void;
+        updateShadows: () => void;
+        showLeftShadow: (overflowContainer: HTMLElement | null | undefined) => boolean;
+        calcOverflowDiff: () => number;
+        calcScrollableWidth: () => number;
+        handleContainer: (container: HTMLElement | null) => void;
+        initShadowObserver(): void;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends keyof OverflowShadowState>(state: OverflowShadowState | ((prevState: Readonly<OverflowShadowState>, props: Readonly<P>) => OverflowShadowState | Pick<OverflowShadowState, K> | null) | Pick<OverflowShadowState, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<P> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<P>, nextState: Readonly<OverflowShadowState>, nextContext: any): boolean;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<P>, prevState: Readonly<OverflowShadowState>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<P>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<P>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<P>, nextState: Readonly<OverflowShadowState>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<P>, nextState: Readonly<OverflowShadowState>, nextContext: any): void;
+    };
+    new (props: P, context: any): {
+        overflowContainer?: HTMLElement | null | undefined;
+        container?: HTMLElement | undefined;
+        shadowObserver?: ShadowObserver | undefined;
+        overflowContainerWidth: number;
+        scrollable?: NodeList | undefined;
+        diff?: number | undefined;
+        state: {
+            showLeftShadow: boolean;
+            showRightShadow: boolean;
+        };
+        componentWillUnmount(): void;
+        componentDidUpdate(): void;
+        handleScroll: (event: Event) => void;
+        updateShadows: () => void;
+        showLeftShadow: (overflowContainer: HTMLElement | null | undefined) => boolean;
+        calcOverflowDiff: () => number;
+        calcScrollableWidth: () => number;
+        handleContainer: (container: HTMLElement | null) => void;
+        initShadowObserver(): void;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends keyof OverflowShadowState>(state: OverflowShadowState | ((prevState: Readonly<OverflowShadowState>, props: Readonly<P>) => OverflowShadowState | Pick<OverflowShadowState, K> | null) | Pick<OverflowShadowState, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<P> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<P>, nextState: Readonly<OverflowShadowState>, nextContext: any): boolean;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<P>, prevState: Readonly<OverflowShadowState>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<P>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<P>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<P>, nextState: Readonly<OverflowShadowState>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<P>, nextState: Readonly<OverflowShadowState>, nextContext: any): void;
+    };
+    contextType?: React.Context<any> | undefined;
+};

package/dist/types-ts4.5/ui/OverflowShadow/shadowObserver.d.ts

@@ -0,0 +1,27 @@
+export declare enum ShadowKeys {
+    SHOW_LEFT_SHADOW = "showLeftShadow",
+    SHOW_RIGHT_SHADOW = "showRightShadow"
+}
+export type ShadowsStates = {
+    [ShadowKey in ShadowKeys]: boolean;
+};
+export declare const shadowObserverClassNames: {
+    SENTINEL_LEFT: string;
+    SENTINEL_RIGHT: string;
+    SHADOW_CONTAINER: string;
+};
+export declare class ShadowObserver {
+    private intersectionObserver?;
+    private scrollContainer;
+    private onUpdateShadows;
+    private sentinels;
+    private requestCallbackId?;
+    readonly shadowStates: ShadowsStates;
+    constructor({ scrollContainer, onUpdateShadows, }: {
+        scrollContainer: HTMLElement;
+        onUpdateShadows: (eventData: ShadowsStates) => void;
+    });
+    private init;
+    private onIntersect;
+    dispose(): void;
+}

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

@@ -0,0 +1,47 @@
+/** @jsx jsx */
+import type { FocusEvent, KeyboardEvent } from 'react';
+import { PureComponent } from 'react';
+import { jsx } from '@emotion/react';
+export interface Props {
+    autoFocus?: boolean | FocusOptions;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    onSubmit?: (value: string) => void;
+    onCancel?: (e: KeyboardEvent) => void;
+    placeholder?: string;
+    onMouseDown?: Function;
+    onKeyDown?: (e: KeyboardEvent<any>) => void;
+    onUndo?: Function;
+    onRedo?: Function;
+    onBlur?: Function;
+    width?: number;
+    maxLength?: number;
+    testId?: string;
+    ariaLabel?: string;
+    describedById?: string;
+    ariaExpanded?: boolean;
+    ariaActiveDescendant?: string;
+    ariaControls?: string;
+    role?: string;
+    ariaAutoComplete?: boolean;
+    inputId?: string;
+}
+export interface State {
+    value?: string;
+}
+export default class PanelTextInput extends PureComponent<Props, State> {
+    private input?;
+    private focusTimeoutId;
+    constructor(props: Props);
+    componentDidUpdate(prevProps: Props): void;
+    componentWillUnmount(): void;
+    onMouseDown: () => void;
+    onBlur: (e: FocusEvent<any>) => void;
+    render(): jsx.JSX.Element;
+    focus(): void;
+    private handleChange;
+    private handleKeydown;
+    private isUndoEvent;
+    private isRedoEvent;
+    private handleRef;
+}

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

@@ -0,0 +1,2 @@
+export declare const panelTextInput: import("@emotion/react").SerializedStyles;
+export declare const panelTextInputWithCustomWidth: (width: number) => import("@emotion/react").SerializedStyles;

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

@@ -0,0 +1,85 @@
+import React from 'react';
+import type { Position } from './utils';
+export interface Props {
+    zIndex?: number;
+    alignX?: 'left' | 'right' | 'center' | 'end';
+    alignY?: 'top' | 'bottom' | 'start';
+    target?: HTMLElement;
+    fitHeight?: number;
+    fitWidth?: number;
+    boundariesElement?: HTMLElement;
+    mountTo?: HTMLElement;
+    offset?: number[];
+    onPositionCalculated?: (position: Position) => Position;
+    onPlacementChanged?: (placement: [
+        string,
+        string
+    ]) => void;
+    shouldRenderPopup?: (position: Position) => boolean;
+    scrollableElement?: HTMLElement;
+    stick?: boolean;
+    /** `null` should only be used if we provide enough context to screen readers to exclude aria-label attribute */
+    ariaLabel?: string | null;
+    forcePlacement?: boolean;
+    allowOutOfBounds?: boolean;
+    rect?: DOMRect;
+    style?: React.CSSProperties;
+    /** Enable focus trap to contain the user's focus within the popup */
+    focusTrap?: boolean;
+    preventOverflow?: boolean;
+    absoluteOffset?: Position;
+}
+export interface State {
+    popup?: HTMLElement;
+    position?: Position;
+    validPosition: boolean;
+}
+export default class Popup extends React.Component<Props, State> {
+    scrollElement: undefined | false | HTMLElement;
+    scrollParentElement: undefined | false | HTMLElement;
+    rafIds: Set<number>;
+    static defaultProps: {
+        offset: number[];
+        allowOutOfBound: boolean;
+    };
+    state: State;
+    private popupRef;
+    private focusTrap?;
+    private placement;
+    /**
+     * Calculates new popup position
+     */
+    private calculatePosition;
+    private updatePosition;
+    private cannotSetPopup;
+    /**
+     * Popup initialization.
+     * Checks whether it's possible to position popup along given target, and if it's not throws an error.
+     */
+    private initPopup;
+    private handleRef;
+    private scheduledUpdatePosition;
+    onResize: () => void;
+    UNSAFE_componentWillReceiveProps(newProps: Props): void;
+    resizeObserver: ResizeObserver | undefined;
+    /**
+     * Raf scheduled so that it also occurs after the initial update position
+     */
+    private initFocusTrap;
+    /**
+     * Cancels the initialisation of the focus trap if it has not yet occured
+     * Deactivates the focus trap if it exists
+     */
+    private destroyFocusTrap;
+    /**
+     * Handle pausing, unpausing, and initialising (if not yet initialised) of the focus trap
+     */
+    handleChangedFocusTrapProp(prevProps: Props): void;
+    componentDidUpdate(prevProps: Props): void;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    private renderPopup;
+    render(): JSX.Element | null;
+}
+export { findOverflowScrollParent } from './utils';
+export type { Position } from './utils';

package/dist/types-ts4.5/ui/Popup/utils.d.ts

@@ -0,0 +1,42 @@
+export interface Position {
+    top?: number;
+    right?: number;
+    bottom?: number;
+    left?: number;
+}
+export interface CalculatePositionParams {
+    placement: [
+        string,
+        string
+    ];
+    target?: HTMLElement;
+    popup?: HTMLElement;
+    offset: number[];
+    stick?: boolean;
+    allowOutOfBounds?: boolean;
+    rect?: DOMRect;
+}
+export declare function isBody(elem: HTMLElement | Element): boolean;
+export declare function isTextNode(elem: HTMLElement | Element): boolean;
+/**
+ * Decides if given fitHeight fits below or above the target taking boundaries into account.
+ */
+export declare function getVerticalPlacement(target: HTMLElement, boundariesElement: HTMLElement, fitHeight?: number, alignY?: string, forcePlacement?: boolean, preventOverflow?: boolean): string;
+/**
+ * Decides if given fitWidth fits to the left or to the right of the target taking boundaries into account.
+ */
+export declare function getHorizontalPlacement(target: HTMLElement, boundariesElement: HTMLElement, fitWidth?: number, alignX?: string, forcePlacement?: boolean, preventOverflow?: boolean): string;
+export declare function calculatePlacement(target: HTMLElement, boundariesElement: HTMLElement, fitWidth?: number, fitHeight?: number, alignX?: string, alignY?: string, forcePlacement?: boolean, preventOverflow?: boolean): [
+    string,
+    string
+];
+/**
+ * Calculates relative coordinates for placing popup along with the target.
+ * Uses placement from calculatePlacement.
+ */
+export declare function calculatePosition({ placement, target, popup, offset, stick, allowOutOfBounds, rect, }: CalculatePositionParams): Position;
+export declare function validatePosition(popup: HTMLElement): boolean;
+/**
+ * Traverse DOM Tree upwards looking for popup parents with "overflow: scroll".
+ */
+export declare function findOverflowScrollParent(popup: HTMLElement | null): HTMLElement | false;

package/dist/types-ts4.5/ui/PortalProvider/PortalProviderThemesProvider.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { ThemeModes } from '@atlaskit/theme/types';
+export declare function PortalProviderThemeProviders(props: {
+    mode: ThemeModes;
+    children: React.ReactNode;
+}): JSX.Element;

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

@@ -0,0 +1,51 @@
+import React from 'react';
+import { IntlShape, WrappedComponentProps } from 'react-intl-next';
+import type { ThemeModes } from '@atlaskit/theme/types';
+import { FireAnalyticsCallback } from '../../analytics';
+import { EventDispatcher } from '../../event-dispatcher';
+export type BasePortalProviderProps = {
+    render: (portalProviderAPI: PortalProviderAPI) => React.ReactChild | JSX.Element | null;
+    onAnalyticsEvent?: FireAnalyticsCallback;
+    useAnalyticsContext?: boolean;
+    themeMode?: ThemeModes;
+} & WrappedComponentProps;
+export type Portals = Map<HTMLElement, React.ReactChild>;
+export type PortalRendererState = {
+    portals: Portals;
+};
+type MountedPortal = {
+    children: () => React.ReactChild | null;
+    hasAnalyticsContext: boolean;
+    hasIntlContext: boolean;
+};
+export declare class PortalProviderAPI extends EventDispatcher {
+    portals: Map<HTMLElement, MountedPortal>;
+    context: any;
+    intl: IntlShape;
+    onAnalyticsEvent?: FireAnalyticsCallback;
+    useAnalyticsContext?: boolean;
+    themeMode?: ThemeModes;
+    constructor(intl: IntlShape, onAnalyticsEvent?: FireAnalyticsCallback, analyticsContext?: boolean, themeMode?: ThemeModes);
+    setContext: (context: any) => void;
+    render(children: () => React.ReactChild | JSX.Element | null, container: HTMLElement, hasAnalyticsContext?: boolean, hasIntlContext?: boolean): void;
+    forceUpdate({ intl, themeMode, }: {
+        intl: IntlShape;
+        themeMode: ThemeModes | undefined;
+    }): void;
+    remove(container: HTMLElement): void;
+}
+export declare const PortalProvider: React.FC<import("react-intl-next").WithIntlProps<BasePortalProviderProps>> & {
+    WrappedComponent: React.ComponentType<BasePortalProviderProps>;
+};
+type PortalProviderWithThemeProvidersProps = Omit<BasePortalProviderProps, 'intl' | 'themeMode'>;
+export declare const PortalProviderWithThemeProviders: ({ onAnalyticsEvent, useAnalyticsContext, render, }: PortalProviderWithThemeProvidersProps) => JSX.Element;
+export declare class PortalRenderer extends React.Component<{
+    portalProviderAPI: PortalProviderAPI;
+}, PortalRendererState> {
+    constructor(props: {
+        portalProviderAPI: PortalProviderAPI;
+    });
+    handleUpdate: (portals: Portals) => void;
+    render(): JSX.Element;
+}
+export {};

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

@@ -0,0 +1,43 @@
+import type { RefObject } from 'react';
+import React from 'react';
+import { Resizable } from 're-resizable';
+import type { RichMediaLayout } from '@atlaskit/adf-schema';
+import type { DispatchAnalyticsEvent } from '../../analytics';
+import type { HandleStyles } from '../../resizer/types';
+import type { EnabledHandles, Props as ResizableMediaSingleProps } from './types';
+export interface ResizableNumberSize {
+    width: number;
+    height: number;
+}
+export type ResizerProps = Omit<ResizableMediaSingleProps, 'height' | 'width'> & {
+    selected?: boolean;
+    enable: EnabledHandles;
+    calcNewSize: (newWidth: number, stop: boolean) => {
+        layout: RichMediaLayout;
+        width: number | null;
+    };
+    snapPoints: number[];
+    scaleFactor?: number;
+    highlights: (width: number, snapPoints: number[]) => number[] | string[];
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    nodeType?: 'media' | 'embed';
+    innerPadding?: number;
+    height?: number;
+    width: number;
+    ratio?: string;
+    handleComponentFunc?: (side: string) => React.ReactElement<any> | undefined;
+    handleStyles?: HandleStyles;
+};
+export type ResizerState = {
+    isResizing: boolean;
+};
+export default class Resizer extends React.Component<ResizerProps, ResizerState> {
+    resizable: RefObject<Resizable>;
+    state: {
+        isResizing: boolean;
+    };
+    private handleResizeStart;
+    private handleResize;
+    private handleResizeStop;
+    render(): JSX.Element;
+}

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

@@ -0,0 +1,2 @@
+import { MediaSingleWrapperProps as MediaSingleDimensionHelperProps } from '../MediaSingle/styled';
+export declare const wrapperStyle: (props: MediaSingleDimensionHelperProps) => import("@emotion/react").SerializedStyles;

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

@@ -0,0 +1,26 @@
+import { RichMediaLayout } from '@atlaskit/adf-schema';
+import { EditorView } from '@atlaskit/editor-prosemirror/view';
+import { MediaClientConfig } from '@atlaskit/media-core';
+import type { DispatchAnalyticsEvent } from '../../analytics';
+import type { getPosHandler } from '../../react-node-view';
+import type { GridType } from '../../types';
+import type { MediaSingleProps } from '../../ui';
+export type EnabledHandles = {
+    left?: boolean;
+    right?: boolean;
+};
+export type Props = MediaSingleProps & {
+    updateSize: (width: number | null, layout: RichMediaLayout) => void;
+    displayGrid: ((show: boolean, type: GridType, highlight: number[] | string[]) => void) | undefined;
+    getPos: getPosHandler;
+    view: EditorView;
+    lineLength: number;
+    gridSize: number;
+    containerWidth: number;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    allowBreakoutSnapPoints?: boolean;
+    selected?: boolean;
+    viewMediaClientConfig?: MediaClientConfig;
+    fullWidthMode?: boolean;
+    updateWidth?: (newWidth: number) => void;
+};

package/dist/types-ts4.5/ui/ResizerLegacy/utils.d.ts

@@ -0,0 +1,6 @@
+export declare const snapTo: (target: number, points: number[]) => number;
+export declare const handleSides: Array<'left' | 'right'>;
+export declare const imageAlignmentMap: {
+    left: string;
+    right: string;
+};

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

@@ -0,0 +1,5 @@
+import type { RefObject } from 'react';
+export declare const EDIT_AREA_ID = "ak-editor-textarea";
+export type UseStickyToolbarType = boolean | RefObject<HTMLElement> | {
+    offsetTop: number;
+};

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

@@ -0,0 +1,14 @@
+/** @jsx jsx */
+import React from 'react';
+import { WrappedComponentProps } from 'react-intl-next';
+import { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import { UnsupportedContentTooltipPayload } from '../../utils';
+export interface Props {
+    node?: PMNode;
+    children?: React.ReactNode;
+    dispatchAnalyticsEvent?: (payload: UnsupportedContentTooltipPayload) => void;
+}
+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/UnsupportedInline/index.d.ts

@@ -0,0 +1,14 @@
+/** @jsx jsx */
+import React from 'react';
+import { WrappedComponentProps } from 'react-intl-next';
+import { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import { UnsupportedContentTooltipPayload } from '../../utils';
+export interface Props {
+    node?: PMNode;
+    children?: React.ReactNode;
+    dispatchAnalyticsEvent?: (payload: UnsupportedContentTooltipPayload) => void;
+}
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<Props & WrappedComponentProps<"intl">>;
+};
+export default _default;