@atlaskit/editor-common 76.9.1 → 76.9.2

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

@@ -0,0 +1,30 @@
+import type React from 'react';
+import type { UiComponentFactoryParams } from './ui-components';
+export declare enum ToolbarSize {
+    XXL = 6,
+    XL = 5,
+    L = 4,
+    M = 3,
+    S = 2,
+    XXXS = 1
+}
+export declare enum ToolbarWidths {
+    XXL = 610,
+    XL = 540,
+    L = 460,
+    M = 450,
+    S = 410
+}
+export declare enum ToolbarWidthsFullPage {
+    XXL = 650,
+    XL = 580,
+    L = 540,
+    M = 490,
+    S = 410
+}
+export type ToolbarUiComponentFactoryParams = UiComponentFactoryParams & {
+    toolbarSize: ToolbarSize;
+    isToolbarReducedSpacing: boolean;
+    isLastItem?: boolean;
+};
+export type ToolbarUIComponentFactory = (params: ToolbarUiComponentFactoryParams) => React.ReactElement<any> | null;

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

@@ -0,0 +1,72 @@
+import type { ReactElement } from 'react';
+import { Fragment, Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { TypeAheadPayload } from '../analytics/types/type-ahead';
+import type { SelectItemMode, TypeAheadAvailableNodes } from '../type-ahead';
+type TypeAheadForceSelectProps = {
+    query: string;
+    items: Array<TypeAheadItem>;
+    editorState: EditorState;
+};
+export interface TypeAheadStats {
+    startedAt: number;
+    endedAt: number;
+    keyCount: {
+        arrowUp: number;
+        arrowDown: number;
+    };
+}
+export type TypeAheadItemRenderProps = {
+    onClick: () => void;
+    onHover: () => void;
+    isSelected: boolean;
+};
+export type TypeAheadInsert = (node?: PMNode | Object | string | Fragment, opts?: {
+    selectInlineNode?: boolean;
+}) => Transaction;
+export type TypeAheadSelectItem = (state: EditorState, item: TypeAheadItem, insert: TypeAheadInsert, meta: {
+    mode: SelectItemMode;
+    stats: TypeAheadStats;
+    query: string;
+    sourceListItem: Array<TypeAheadItem>;
+}) => Transaction | false;
+export type TypeAheadItem = {
+    title: string;
+    description?: string;
+    keyshortcut?: string;
+    key?: string | number;
+    icon?: () => ReactElement<any>;
+    render?: (props: TypeAheadItemRenderProps) => React.ReactElement<TypeAheadItemRenderProps> | null;
+    [key: string]: any;
+};
+export type TypeAheadForceSelect = (props: TypeAheadForceSelectProps) => TypeAheadItem | undefined;
+export type TypeAheadHandler = {
+    id: TypeAheadAvailableNodes;
+    /** Pattern that will trigger the TypeAhead */
+    trigger: string;
+    /** Custom regex must have a capture group around trigger so it's possible to
+     * use it without needing to scan through all triggers again */
+    customRegex?: string;
+    headless?: boolean;
+    /** Handler returns typeahead item based on query. Used to find which item to insert. */
+    forceSelect?: TypeAheadForceSelect;
+    onInvokeAnalytics?: TypeAheadPayload;
+    /** Handler executes logic when TypeAhead opens */
+    onOpen?: (editorState: EditorState) => void;
+    /** Handler returns an array of TypeAheadItem based on query to be displayed in the TypeAhead */
+    getItems: (props: {
+        query: string;
+        editorState: EditorState;
+    }) => Promise<Array<TypeAheadItem>>;
+    /** Handler returns a transaction which inserts the TypeAheadItem into the doc */
+    selectItem: TypeAheadSelectItem;
+    /** Handler executes logic when TypeAhead is dismissed */
+    dismiss?: (props: {
+        editorState: EditorState;
+        query: string;
+        stats: TypeAheadStats;
+        wasItemInserted?: boolean;
+    }) => void;
+    getHighlight?: (state: EditorState) => JSX.Element | null;
+};
+export {};

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

@@ -0,0 +1,23 @@
+import type React from 'react';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { DispatchAnalyticsEvent } from '../analytics/types/dispatch-analytics-event';
+import type { EventDispatcher } from '../event-dispatcher';
+import type { ProviderFactory } from '../provider-factory';
+import type { EditorActionsOptions } from './editor-actions';
+import type { EditorAppearance } from './editor-appearance';
+export type UiComponentFactoryParams = {
+    editorView: EditorView;
+    editorActions: EditorActionsOptions;
+    eventDispatcher: EventDispatcher;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    providerFactory: ProviderFactory;
+    appearance: EditorAppearance;
+    popupsMountPoint?: HTMLElement;
+    popupsBoundariesElement?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    containerElement: HTMLElement | null;
+    disabled: boolean;
+    wrapperElement: HTMLElement | null;
+};
+export type UIComponentFactory = (params: UiComponentFactoryParams) => React.ReactElement<any> | null;
+export type ReactHookFactory = (params: Pick<UiComponentFactoryParams, 'editorView' | 'containerElement'>) => void;

package/dist/types-ts4.5/ufo/experience-store.d.ts

@@ -0,0 +1,33 @@
+import { EditorView } from '@atlaskit/editor-prosemirror/view';
+import { UFOExperience } from '@atlaskit/ufo';
+import type { CustomData, ExperienceConfig } from '@atlaskit/ufo/types';
+export declare const experienceConfig: ExperienceConfig;
+export declare enum EditorExperience {
+    loadEditor = "load",
+    typing = "type",
+    interaction = "interact",
+    editSession = "edit-session"
+}
+export declare const RELIABILITY_INTERVAL = 30000;
+type TypeOfEditorExperience = typeof EditorExperience;
+type ValueOfEditorExperience = TypeOfEditorExperience[keyof TypeOfEditorExperience];
+export declare class ExperienceStore {
+    private static stores;
+    private experiences;
+    private constructor();
+    static getInstance(view: EditorView, options?: {
+        forceNewInstance?: boolean;
+    }): ExperienceStore;
+    get(experienceId: string): UFOExperience | undefined;
+    getActive(experienceId: string): UFOExperience | undefined;
+    getAll(): UFOExperience[];
+    start(experienceId: ValueOfEditorExperience, startTime?: number): void;
+    addMetadata(experienceId: string, metadata: CustomData): void;
+    mark(experienceId: string, mark: string, value: number): void;
+    success(experienceId: string, metadata?: CustomData): Promise<boolean | null> | undefined;
+    fail(experienceId: string, metadata?: CustomData): void;
+    abort(experienceId: string, metadata?: CustomData): void;
+    abortAll(metadata?: CustomData): void;
+    failAll(metadata?: CustomData): void;
+}
+export {};

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

@@ -0,0 +1 @@
+export { ExperienceStore, EditorExperience, RELIABILITY_INTERVAL, } from './experience-store';

package/dist/types-ts4.5/ui/Announcer/announcer.d.ts

@@ -0,0 +1,23 @@
+import type { AriaAttributes, Ref } from 'react';
+import React from 'react';
+type AnnouncerProps = {
+    ref?: Ref<HTMLDivElement>;
+    /** Set 'false' for announcing only changed text
+     * (not announce duplicate part of string after second render),
+     * and 'true' for announcing all the string after each render */
+    ariaAtomic?: AriaAttributes['aria-atomic'];
+    /** Set politeness settings */
+    ariaLive?: AriaAttributes['aria-live'];
+    /** Used to describe what types of changes have occurred to an aria-live region */
+    ariaRelevant?: AriaAttributes['aria-relevant'];
+    /** Role used to set attribute role. See more details https://dequeuniversity.com/library/aria/liveregion-playground#configOptions */
+    role?: 'status' | 'log' | 'alert' | 'timer' | 'marquee';
+    /** Text message that will be announced */
+    text: string;
+    /** Debounce delay.
+     *  Set delay (ms) to prevent announce the same string multiple times.
+     *  It can be useful for cases when the parent component re-renders with the same announcer's text. */
+    delay?: number;
+};
+declare const _default: React.NamedExoticComponent<AnnouncerProps>;
+export default _default;

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

@@ -0,0 +1,15 @@
+import React from 'react';
+import { Breakpoints } from '../WidthProvider';
+export declare function mapBreakpointToLayoutMaxWidth(breakpoint: Breakpoints): 760 | 680;
+type BaseThemeWrapperProps = {
+    breakpoint: Breakpoints;
+    children: React.ReactNode;
+    baseFontSize?: number;
+};
+export declare function BaseThemeWrapper({ baseFontSize, children, }: BaseThemeWrapperProps): JSX.Element;
+type BaseThemeProps = {
+    children: React.ReactNode;
+    baseFontSize?: number;
+};
+export declare function BaseTheme({ children, baseFontSize }: BaseThemeProps): JSX.Element;
+export {};

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

@@ -0,0 +1,19 @@
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+import { WrappedComponentProps } from 'react-intl-next';
+type Props = {
+    selected?: boolean;
+    hasContent?: boolean;
+    children?: React.ReactNode;
+    dataAttributes?: {
+        'data-renderer-start-pos': number;
+    };
+};
+export declare class CaptionComponent extends React.Component<Props & WrappedComponentProps> {
+    render(): jsx.JSX.Element;
+}
+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/Caption/messages.d.ts

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

package/dist/types-ts4.5/ui/ContextPanel/context.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+export type ContextPanelContext = {
+    width: number;
+    positionedOverEditor: boolean;
+    broadcastWidth: (width: number) => void;
+    broadcastPosition: (positionedOverEditor: boolean) => void;
+};
+export declare const ContextPanel: React.Context<ContextPanelContext>;
+export type ContextPanelProviderState = {
+    width?: number;
+    positionedOverEditor?: boolean;
+};
+export declare class ContextPanelWidthProvider extends React.Component<any, ContextPanelProviderState> {
+    state: {
+        width: number;
+        positionedOverEditor: boolean;
+    };
+    constructor(props: any);
+    broadcastSidebarWidth: (width: number) => void;
+    broadcastPosition: (positionedOverEditor: boolean) => void;
+    render(): JSX.Element;
+}
+declare const Provider: React.Provider<ContextPanelContext>, Consumer: React.Consumer<ContextPanelContext>;
+export { Provider as ContextPanelProvider, Consumer as ContextPanelConsumer };

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

@@ -0,0 +1,21 @@
+/** @jsx jsx */
+import type { ReactNode } from 'react';
+import { Component } from 'react';
+import type { WithAnalyticsEventsProps } from '@atlaskit/analytics-next';
+interface Props extends WithAnalyticsEventsProps {
+    isOpen?: boolean;
+    trigger?: typeof Component;
+    position: string;
+    onOpenChange?: (event: OpenChangedEvent) => void;
+    onPositioned?: () => void;
+    testId?: string;
+    shouldFitContainer: boolean;
+    children?: ReactNode;
+    id?: string;
+}
+export type OpenChangedEvent = {
+    isOpen: boolean;
+    event: MouseEvent | KeyboardEvent;
+};
+declare const _default: import("react").ForwardRefExoticComponent<Pick<Omit<Props, keyof WithAnalyticsEventsProps> & import("react").RefAttributes<any> & import("@atlaskit/analytics-next").WithContextProps, "key" | "id" | "children" | "position" | "testId" | "analyticsContext" | "shouldFitContainer" | "onPositioned" | "isOpen" | "trigger" | "onOpenChange"> & import("react").RefAttributes<any>>;
+export default _default;

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

@@ -0,0 +1,22 @@
+import { PureComponent } from 'react';
+import type { EmojiResourceConfig } from '@atlaskit/emoji/resource';
+import type { EmojiId } from '@atlaskit/emoji/types';
+import { ProviderFactory } from '../../provider-factory';
+export interface EmojiProps extends EmojiId {
+    allowTextFallback?: boolean;
+    providers?: ProviderFactory;
+    fitToHeight?: number;
+    showTooltip?: boolean;
+    resourceConfig?: EmojiResourceConfig;
+}
+export default class EmojiNode extends PureComponent<EmojiProps, {}> {
+    static displayName: string;
+    static defaultProps: {
+        showTooltip: boolean;
+    };
+    private providerFactory;
+    constructor(props: EmojiProps);
+    componentWillUnmount(): void;
+    private renderWithProvider;
+    render(): JSX.Element;
+}

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

@@ -0,0 +1,25 @@
+import React from 'react';
+import type { DispatchAnalyticsEvent, ErrorEventPayload } from '../../analytics';
+import { ACTION } from '../../analytics';
+type ErrorCrashPayload = Extract<ErrorEventPayload, {
+    action: ACTION.EDITOR_CRASHED;
+}>;
+interface ErrorBoundaryProps {
+    component: ErrorCrashPayload['actionSubject'];
+    componentId?: ErrorCrashPayload['actionSubjectId'];
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    fallbackComponent?: React.ReactNode;
+}
+interface ErrorBoundaryState {
+    errorCaptured: boolean;
+}
+export declare class ErrorBoundary extends React.Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    state: {
+        errorCaptured: boolean;
+    };
+    hasFallback(): boolean;
+    shouldRecover(): boolean;
+    componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void;
+    render(): React.ReactNode;
+}
+export {};

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

@@ -0,0 +1,36 @@
+import { SyntheticEvent } from 'react';
+import type { CardEvent, InlineCardEvent } from '@atlaskit/media-card';
+import type { Identifier } from '@atlaskit/media-client';
+export interface CardSurroundings {
+    collectionName: string;
+    list: Identifier[];
+}
+export type MentionEventHandler = (mentionId: string, text: string, event?: SyntheticEvent<HTMLSpanElement>) => void;
+export type CardEventClickHandler = (result: CardEvent | InlineCardEvent, surroundings?: CardSurroundings, analyticsEvent?: any) => void;
+export type LinkEventClickHandler = (event: SyntheticEvent<HTMLAnchorElement>, url?: string) => void;
+export type SmartCardEventClickHandler = (event: SyntheticEvent<HTMLAnchorElement>, url?: string) => void;
+export type OnUnhandledClickHandler = (event: React.MouseEvent) => void;
+export interface MentionEventHandlers {
+    onClick?: MentionEventHandler;
+    onMouseEnter?: MentionEventHandler;
+    onMouseLeave?: MentionEventHandler;
+}
+/** Callbacks for mouse events in the renderer */
+export interface EventHandlers {
+    /** This fires when there is a click in the renderer that wasn’t handled by anything in the
+     * renderer. Example usage of this callback: load the editor in place of the renderer when
+     * renderer text is clicked.
+     * See example at /examples.html?groupId=editor&packageId=editor-core&exampleId=full-page-click-to-edit
+     *  */
+    onUnhandledClick?: OnUnhandledClickHandler;
+    mention?: MentionEventHandlers;
+    media?: {
+        onClick?: CardEventClickHandler;
+    };
+    link?: {
+        onClick?: LinkEventClickHandler;
+    };
+    smartCard?: {
+        onClick?: SmartCardEventClickHandler;
+    };
+}

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

@@ -0,0 +1,42 @@
+import React from 'react';
+import { jsx } from '@emotion/react';
+import type { ThemeProps } from '@atlaskit/theme/types';
+export declare const messages: {
+    collapseNode: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    expandDefaultTitle: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    expandNode: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    expandPlaceholderText: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};
+export interface StyleProps {
+    expanded?: boolean;
+    focused?: boolean;
+    'data-node-type'?: 'expand' | 'nestedExpand';
+    'data-title'?: string;
+}
+export declare const ExpandIconWrapper: ({ children, expanded, }: React.HTMLAttributes<HTMLDivElement> & {
+    expanded: boolean;
+}) => jsx.JSX.Element;
+export declare const expandLayoutWrapperStyle: import("@emotion/react").SerializedStyles;
+export declare const ExpandLayoutWrapperWithRef: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<any>>;
+export declare const sharedExpandStyles: {
+    titleInputStyles: (props: ThemeProps) => import("@emotion/react").SerializedStyles;
+    titleContainerStyles: (props: ThemeProps) => import("@emotion/react").SerializedStyles;
+    containerStyles: (styleProps: StyleProps) => (themeProps: ThemeProps) => import("@emotion/react").SerializedStyles;
+    contentStyles: (styleProps: StyleProps) => (themeProps: ThemeProps) => import("@emotion/react").SerializedStyles;
+};

package/dist/types-ts4.5/ui/FloatingToolbar/Button.d.ts

@@ -0,0 +1,30 @@
+import React from 'react';
+import type { ButtonAppearance } from '../../types';
+export type { ButtonAppearance };
+export interface Props {
+    title?: string;
+    icon?: React.ReactElement<any>;
+    iconAfter?: React.ReactElement<any>;
+    onClick?: React.MouseEventHandler;
+    onKeyDown?: React.KeyboardEventHandler;
+    onMouseEnter?: <T>(event: React.MouseEvent<T>) => void;
+    onMouseLeave?: <T>(event: React.MouseEvent<T>) => void;
+    onFocus?: <T>(event: React.FocusEvent<T>) => void;
+    onBlur?: <T>(event: React.FocusEvent<T>) => void;
+    selected?: boolean;
+    disabled?: boolean;
+    appearance?: ButtonAppearance;
+    ariaHasPopup?: boolean | 'dialog' | 'menu' | 'listbox' | 'tree' | 'grid' | undefined;
+    ariaLabel?: string;
+    href?: string;
+    target?: string;
+    children?: React.ReactNode;
+    className?: string;
+    tooltipContent?: React.ReactNode;
+    testId?: string;
+    hideTooltipOnClick?: boolean;
+    tabIndex?: number | null | undefined;
+    areaControls?: string;
+}
+declare const _default: ({ title, icon, iconAfter, onClick, onKeyDown, onMouseEnter, onMouseLeave, onFocus, onBlur, selected, disabled, href, target, appearance, children, className, tooltipContent, testId, hideTooltipOnClick, ariaHasPopup, tabIndex, areaControls, ariaLabel, }: Props) => JSX.Element;
+export default _default;

package/dist/types-ts4.5/ui/FloatingToolbar/Separator.d.ts

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

package/dist/types-ts4.5/ui/FloatingToolbar/SmallerEditIcon.d.ts

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

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

@@ -0,0 +1,20 @@
+export declare const iconOnlySpacing: {
+    '&&': {
+        padding: string;
+        /**
+          Increased specificity here because css for .hyperlink-open-link defined in
+          packages/editor/editor-core/src/ui/ContentStyles/index.tsx file
+          overrides padding left-right 2px with 4px.
+        */
+        '&&[href]': {
+            padding: string;
+        };
+    };
+    '& > span': {
+        margin: string;
+    };
+};
+export declare const getButtonStyles: (props: any) => {
+    background: any;
+    color: any;
+};

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

@@ -0,0 +1,15 @@
+import React from 'react';
+interface ErrorBoundaryProps {
+}
+interface ErrorBoundaryState {
+    missingIntlProviderInAncestry: boolean;
+}
+export declare const REACT_INTL_ERROR_MESSAGE = "<IntlProvider> needs to exist in the component ancestry";
+export declare class IntlErrorBoundary extends React.Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    state: {
+        missingIntlProviderInAncestry: boolean;
+    };
+    componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void;
+    render(): React.ReactNode;
+}
+export {};

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

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+interface WrapProps {
+    children: JSX.Element;
+}
+export default function IntlProviderIfMissingWrapper({ children }: WrapProps): JSX.Element;
+export {};

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

@@ -0,0 +1,47 @@
+import { Component, ReactNode } from 'react';
+import { Data } from 'popper.js';
+export type Props = {
+    content: ReactNode | null;
+    offset: string;
+    position: string;
+    onPositioned: () => void;
+};
+export type State = {
+    hasExtractedStyles: boolean;
+    position?: string;
+    transform?: string;
+    offsets: {
+        popper: {
+            left: number;
+            top: number;
+        };
+    };
+    cssPosition: string;
+    originalHeight: number | null;
+    maxHeight: number | null;
+};
+export default class Layer extends Component<Props, State> {
+    private popper;
+    private targetRef;
+    private contentRef;
+    static defaultProps: {
+        boundariesElement: string;
+        children: null;
+        content: null;
+        offset: string;
+        position: string;
+        zIndex: number;
+        lockScroll: boolean;
+        isAlwaysFixed: boolean;
+        onPositioned: () => void;
+    };
+    constructor(props: Props);
+    componentDidMount(): void;
+    UNSAFE_componentWillReceiveProps(nextProps: Props): void;
+    componentDidUpdate(prevProps: Props, prevState: State): void;
+    componentWillUnmount(): void;
+    calculateMaxHeight(originalHeight: number, currentHeight: number, positionTop: number, cssPosition: string): number | null;
+    extractStyles: (state: Data) => void;
+    applyPopper(props: Props): void;
+    render(): JSX.Element;
+}

package/dist/types-ts4.5/ui/Layer/internal/helpers.d.ts

@@ -0,0 +1,5 @@
+export declare const POSITION_ATTRIBUTE_ENUM: {
+    values: string[];
+    default: string;
+};
+export declare function positionPropToPopperPosition(position: string): import("popper.js").default.Placement;

package/dist/types-ts4.5/ui/LinkSearch/const.d.ts

@@ -0,0 +1,4 @@
+export declare const RECENT_SEARCH_WIDTH_IN_PX = 420;
+export declare const RECENT_SEARCH_WIDTH_WITHOUT_ITEMS_IN_PX = 360;
+export declare const RECENT_SEARCH_HEIGHT_IN_PX = 360;
+export declare const LINKPICKER_HEIGHT_IN_PX = 570;

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

@@ -0,0 +1,25 @@
+import { RichMediaLayout as MediaSingleLayout } from '@atlaskit/adf-schema';
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+import { EditorContainerWidth } from '../../types';
+export declare const layoutSupportsWidth: (layout: MediaSingleLayout) => boolean;
+export declare function calcPxFromColumns(columns: number, lineLength: number, gridSize: number): number;
+export declare function calcColumnsFromPx(width: number, lineLength: number, gridSize: number): number;
+export declare function calcPxFromPct(pct: number, lineLength: number): number;
+export declare function calcPctFromPx(width: number, lineLength: number): number;
+export declare const wrappedLayouts: MediaSingleLayout[];
+export declare const calcPctWidth: (containerWidth: EditorContainerWidth, pctWidth?: number, origWidth?: number, origHeight?: number) => number | undefined;
+export declare const calcMediaPxWidth: (opts: {
+    origWidth: number;
+    origHeight: number;
+    state?: EditorState | undefined;
+    containerWidth: EditorContainerWidth;
+    layout?: MediaSingleLayout | undefined;
+    pctWidth?: number | undefined;
+    pos?: number | undefined;
+    resizedPctWidth?: number | undefined;
+    isFullWidthModeEnabled?: boolean | undefined;
+}) => number;
+export declare const snapToGrid: (gridWidth: number, width: number, height: number, lineLength: number, gridSize: number) => {
+    height: number;
+    width: number;
+};

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

@@ -0,0 +1,28 @@
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+import type { RichMediaLayout as MediaSingleLayout } from '@atlaskit/adf-schema';
+import type { MediaSingleSize, MediaSingleWidthType } from './types';
+export interface Props {
+    children: React.ReactNode;
+    layout: MediaSingleLayout;
+    width?: number;
+    height: number;
+    lineLength: number;
+    containerWidth?: number;
+    isLoading?: boolean;
+    className?: string;
+    /**
+     * @private
+     * @deprecated Use {@link Props.size.width} instead.
+     * Cleanup ticket: https://product-fabric.atlassian.net/browse/ED-19076
+     */
+    pctWidth?: number;
+    size?: MediaSingleSize;
+    nodeType?: string;
+    fullWidthMode?: boolean;
+    hasFallbackContainer?: boolean;
+    handleMediaSingleRef?: React.RefObject<HTMLDivElement>;
+}
+export type { MediaSingleWidthType, MediaSingleSize };
+export default function MediaSingle({ layout, width, height, containerWidth, isLoading, pctWidth, size, className, children: propsChildren, nodeType, fullWidthMode, lineLength: editorWidth, hasFallbackContainer, handleMediaSingleRef, }: Props): jsx.JSX.Element;

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

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