@atlaskit/editor-common 69.3.0 → 69.4.0

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

@@ -0,0 +1,27 @@
+export declare enum ShadowKeys {
+    SHOW_LEFT_SHADOW = "showLeftShadow",
+    SHOW_RIGHT_SHADOW = "showRightShadow"
+}
+export declare 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.0/ui/Popup/index.d.ts

@@ -0,0 +1,66 @@
+import React from 'react';
+import { 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;
+    ariaLabel?: string;
+    forcePlacement?: boolean;
+    allowOutOfBounds?: boolean;
+    rect?: DOMRect;
+    scheduleExtraLayoutUpdates?: boolean;
+    waitForExtraLayoutUpdates?: boolean;
+}
+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 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 cancelRequestAnimationFrames;
+    private scheduledUpdatePosition;
+    onResize: () => void;
+    UNSAFE_componentWillReceiveProps(newProps: Props): void;
+    resizeObserver: ResizeObserver | undefined;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    private renderPopup;
+    render(): JSX.Element | null;
+}
+export { findOverflowScrollParent } from './utils';
+export type { Position } from './utils';

package/dist/types-ts4.0/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): 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): string;
+export declare function calculatePlacement(target: HTMLElement, boundariesElement: HTMLElement, fitWidth?: number, fitHeight?: number, alignX?: string, alignY?: string, forcePlacement?: 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.0/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.0/ui/PortalProvider/index.d.ts

@@ -0,0 +1,50 @@
+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 declare type BasePortalProviderProps = {
+    render: (portalProviderAPI: PortalProviderAPI) => React.ReactChild | JSX.Element | null;
+    onAnalyticsEvent?: FireAnalyticsCallback;
+    useAnalyticsContext?: boolean;
+    themeMode?: ThemeModes;
+} & WrappedComponentProps;
+export declare type Portals = Map<HTMLElement, React.ReactChild>;
+export declare type PortalRendererState = {
+    portals: Portals;
+};
+declare 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>;
+};
+export declare const PortalProviderWithThemeProviders: (props: Omit<BasePortalProviderProps, 'intl' | 'themeMode'>) => 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.0/ui/UnsupportedBlock/index.d.ts

@@ -0,0 +1,14 @@
+/** @jsx jsx */
+import React from 'react';
+import { Node as PMNode } from 'prosemirror-model';
+import { WrappedComponentProps } from 'react-intl-next';
+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.0/ui/UnsupportedInline/index.d.ts

@@ -0,0 +1,14 @@
+/** @jsx jsx */
+import React from 'react';
+import { Node as PMNode } from 'prosemirror-model';
+import { WrappedComponentProps } from 'react-intl-next';
+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.0/ui/WidthProvider/index.d.ts

@@ -0,0 +1,29 @@
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+export declare type Breakpoints = 'S' | 'M' | 'L';
+export declare type WidthConsumerContext = {
+    width: number;
+    breakpoint: Breakpoints;
+};
+export declare function getBreakpoint(width?: number): Breakpoints;
+export declare function createWidthContext(width?: number): WidthConsumerContext;
+export declare const WidthContext: React.Context<WidthConsumerContext>;
+declare const Consumer: React.Consumer<WidthConsumerContext>;
+export declare type WidthProviderState = {
+    width?: number;
+};
+declare type WidthProviderProps = {
+    className?: string;
+};
+export declare class WidthProvider extends React.Component<WidthProviderProps, WidthProviderState> {
+    state: {
+        width: number;
+    };
+    constructor(props: any);
+    render(): jsx.JSX.Element;
+    setWidth: ((width: number) => void) & {
+        cancel(): void;
+    };
+}
+export { Consumer as WidthConsumer };

package/dist/types-ts4.0/ui/WithCreateAnalyticsEvent/index.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+export declare type Props = {
+    render: (createAnalyticsEvent?: CreateUIAnalyticsEvent) => React.ReactNode;
+};
+export declare const WithCreateAnalyticsEvent: React.ComponentType<Props>;

package/dist/types-ts4.0/ui/clear-next-sibling-margin-top.d.ts

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

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

@@ -0,0 +1,25 @@
+export { default as Caption } from './Caption';
+export { default as MediaSingle, DEFAULT_IMAGE_WIDTH, DEFAULT_IMAGE_HEIGHT, wrappedLayouts, shouldAddDefaultWrappedWidth, } from './MediaSingle';
+export type { Props as MediaSingleProps } from './MediaSingle';
+export { MediaSingleDimensionHelper } from './MediaSingle/styled';
+export type { MediaSingleWrapperProps as MediaSingleDimensionHelperProps } from './MediaSingle/styled';
+export { layoutSupportsWidth, calcPxFromColumns, calcPctFromPx, calcPxFromPct, calcColumnsFromPx, snapToGrid, } from './MediaSingle/grid';
+export { mediaLinkStyle } from './MediaSingle/link';
+export { default as Popup, findOverflowScrollParent } from './Popup';
+export type { Position as PopupPosition, Props as PopupProps } from './Popup';
+export { default as UnsupportedBlock } from './UnsupportedBlock';
+export { default as UnsupportedInline } from './UnsupportedInline';
+export { BaseTheme, mapBreakpointToLayoutMaxWidth } from './BaseTheme';
+export { default as withOuterListeners } from './with-outer-listeners';
+export type { CardEventClickHandler, CardSurroundings, EventHandlers, LinkEventClickHandler, MentionEventHandler, MentionEventHandlers, SmartCardEventClickHandler, } from './EventHandlers';
+export { WidthConsumer, WidthProvider, getBreakpoint } from './WidthProvider';
+export type { WidthConsumerContext, Breakpoints } from './WidthProvider';
+export { default as overflowShadow, shadowClassNames } from './OverflowShadow';
+export type { OverflowShadowOptions, OverflowShadowProps, OverflowShadowState, } from './OverflowShadow';
+export { shadowObserverClassNames, ShadowObserver, } from './OverflowShadow/shadowObserver';
+export { WithCreateAnalyticsEvent } from './WithCreateAnalyticsEvent';
+export { messages as expandMessages, sharedExpandStyles, ExpandIconWrapper, expandLayoutWrapperStyle, ExpandLayoutWrapperWithRef, } from './Expand';
+export type { StyleProps as ExpandStyleProps } from './Expand';
+export { ErrorMessage, HelperMessage, ValidMessage } from './Messages';
+export { clearNextSiblingMarginTopStyle, clearNextSiblingBlockMarkMarginTopStyle, } from './clear-next-sibling-margin-top';
+export { IntlErrorBoundary, REACT_INTL_ERROR_MESSAGE, } from './IntlErrorBoundary';

package/dist/types-ts4.0/ui/unsupported-content-helper.d.ts

@@ -0,0 +1,3 @@
+import { Node as PMNode } from 'prosemirror-model';
+import { IntlShape } from 'react-intl-next';
+export declare function getUnsupportedContent(message: any, prefix: string, node?: PMNode, intl?: IntlShape): any;

package/dist/types-ts4.0/ui/with-outer-listeners.d.ts

@@ -0,0 +1,8 @@
+import { ComponentClass, StatelessComponent } from 'react';
+declare type SimpleEventHandler<T> = (event: T) => void;
+export interface WithOutsideClickProps {
+    handleClickOutside?: SimpleEventHandler<MouseEvent>;
+    handleEscapeKeydown?: SimpleEventHandler<KeyboardEvent>;
+}
+export default function withOuterListeners<P>(Component: ComponentClass<P> | StatelessComponent<P>): ComponentClass<P & WithOutsideClickProps>;
+export {};

package/dist/types-ts4.0/ui-color/ColorPalette/Color/index.d.ts

@@ -0,0 +1,19 @@
+/** @jsx jsx */
+import React, { PureComponent } from 'react';
+import { jsx } from '@emotion/react';
+export interface Props {
+    value: string;
+    label: string;
+    tabIndex?: number;
+    isSelected?: boolean;
+    onClick: (value: string, label: string) => void;
+    borderColor: string;
+    checkMarkColor?: string;
+    autoFocus?: boolean;
+}
+declare class Color extends PureComponent<Props> {
+    render(): jsx.JSX.Element;
+    onMouseDown: (e: React.MouseEvent<{}>) => void;
+    onClick: (e: React.MouseEvent<{}>) => void;
+}
+export default Color;

package/dist/types-ts4.0/ui-color/ColorPalette/Color/styles.d.ts

@@ -0,0 +1,4 @@
+/** this is not new usage - old code extracted from editor-core */
+export declare const buttonStyle: import("@emotion/react").SerializedStyles;
+/** this is not new usage - old code extracted from editor-core */
+export declare const buttonWrapperStyle: import("@emotion/react").SerializedStyles;

package/dist/types-ts4.0/ui-color/ColorPalette/Palettes/cellBackgroundColorPalette.d.ts

@@ -0,0 +1,3 @@
+import { PaletteColor } from './type';
+declare const cellBackgroundColorPalette: Array<PaletteColor>;
+export default cellBackgroundColorPalette;

package/dist/types-ts4.0/ui-color/ColorPalette/Palettes/common.d.ts

@@ -0,0 +1,2 @@
+/** this is not new usage - old code extracted from editor-core */
+export declare const DEFAULT_BORDER_COLOR: string;

package/dist/types-ts4.0/ui-color/ColorPalette/Palettes/getColorMessage.d.ts

@@ -0,0 +1,2 @@
+import { MessageDescriptor } from 'react-intl-next';
+export default function getColorMessage(messages: Record<string | number, MessageDescriptor>, color: string): MessageDescriptor | undefined;

package/dist/types-ts4.0/ui-color/ColorPalette/Palettes/index.d.ts

@@ -0,0 +1,2 @@
+export type { PaletteColor } from './type';
+export { DEFAULT_BORDER_COLOR } from './common';

package/dist/types-ts4.0/ui-color/ColorPalette/Palettes/paletteMessages.d.ts

@@ -0,0 +1,113 @@
+declare const _default: {
+    white: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'light-blue': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'light-teal': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'light-green': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'light-yellow': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'light-red': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'light-purple': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'light-gray': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    blue: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    teal: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    green: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    yellow: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    red: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    orange: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    purple: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    gray: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'dark-blue': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'dark-teal': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'dark-green': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'dark-yellow': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'dark-red': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'dark-purple': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};
+export default _default;

package/dist/types-ts4.0/ui-color/ColorPalette/Palettes/panelBackgroundPalette.d.ts

@@ -0,0 +1,4 @@
+import { PaletteColor } from './type';
+/** this is not new usage - old code extracted from editor-core */
+export declare const panelBackgroundPalette: PaletteColor[];
+export declare const panelDarkModeBackgroundPalette: PaletteColor[];

package/dist/types-ts4.0/ui-color/ColorPalette/Palettes/statusColorPalette.d.ts

@@ -0,0 +1,4 @@
+import { PaletteColor } from './type';
+/** this is not new usage - old code extracted from editor-core */
+export declare const lightModeStatusColorPalette: PaletteColor[];
+export declare const darkModeStatusColorPalette: PaletteColor[];

package/dist/types-ts4.0/ui-color/ColorPalette/Palettes/textColorPalette.d.ts

@@ -0,0 +1,3 @@
+import { PaletteColor } from './type';
+export declare const textColorPalette: Array<PaletteColor>;
+export declare const textColorPaletteExtended: Array<PaletteColor>;

package/dist/types-ts4.0/ui-color/ColorPalette/Palettes/type.d.ts

@@ -0,0 +1,8 @@
+import { MessageDescriptor } from 'react-intl-next';
+export interface PaletteColor {
+    value: string;
+    label: string;
+    border: string;
+    message?: MessageDescriptor;
+}
+export declare type Palette = Array<PaletteColor>;

package/dist/types-ts4.0/ui-color/ColorPalette/index.d.ts

@@ -0,0 +1,15 @@
+/** @jsx jsx */
+import React from 'react';
+import { WrappedComponentProps } from 'react-intl-next';
+import { PaletteColor } from './Palettes/type';
+interface Props {
+    palette: PaletteColor[];
+    selectedColor: string | null;
+    onClick: (value: string, label: string) => void;
+    cols?: number;
+    className?: string;
+}
+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.0/ui-color/ColorPalette/styles.d.ts

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

package/dist/types-ts4.0/ui-color/index.d.ts

@@ -0,0 +1,9 @@
+export { default as ColorPalette } from './ColorPalette';
+export { default as Color } from './ColorPalette/Color';
+export { default as cellBackgroundColorPalette } from './ColorPalette/Palettes/cellBackgroundColorPalette';
+export { default as colorPaletteMessages } from './ColorPalette/Palettes/paletteMessages';
+export { panelBackgroundPalette, panelDarkModeBackgroundPalette, } from './ColorPalette/Palettes/panelBackgroundPalette';
+export { lightModeStatusColorPalette, darkModeStatusColorPalette, } from './ColorPalette/Palettes/statusColorPalette';
+export { textColorPalette, textColorPaletteExtended, } from './ColorPalette/Palettes/textColorPalette';
+export { DEFAULT_BORDER_COLOR } from './ColorPalette/Palettes/common';
+export type { PaletteColor } from './ColorPalette/Palettes/type';

package/dist/types-ts4.0/ui-menu/Dropdown/index.d.ts

@@ -0,0 +1,35 @@
+import React, { PureComponent } from 'react';
+import { OpenChangedEvent } from '../../ui/DropList';
+export interface Props {
+    mountTo?: HTMLElement;
+    boundariesElement?: HTMLElement;
+    scrollableElement?: HTMLElement;
+    trigger: React.ReactElement<any>;
+    isOpen?: boolean;
+    onOpenChange?: (attrs: OpenChangedEvent) => void;
+    fitWidth?: number;
+    fitHeight?: number;
+    zIndex?: number;
+}
+export interface State {
+    target?: HTMLElement;
+    popupPlacement: [
+        string,
+        string
+    ];
+}
+/**
+ * Wrapper around @atlaskit/droplist which uses Popup and Portal to render
+ * droplist outside of "overflow: hidden" containers when needed.
+ *
+ * Also it controls popper's placement.
+ */
+export declare class Dropdown extends PureComponent<Props, State> {
+    constructor(props: Props);
+    private handleRef;
+    private updatePopupPlacement;
+    private renderDropdown;
+    render(): JSX.Element;
+}
+declare const DropdownWithOuterListeners: React.FC<Props & import("../../ui-react/with-react-editor-view-outer-listeners").WithOutsideClickProps>;
+export default DropdownWithOuterListeners;

package/dist/types-ts4.0/ui-menu/DropdownMenu/index.d.ts

@@ -0,0 +1,19 @@
+/** @jsx jsx */
+import { PureComponent } from 'react';
+import { jsx } from '@emotion/react';
+import { Props, State } from './types';
+export type { MenuItem } from './types';
+/**
+ * Wrapper around @atlaskit/droplist which uses Popup and Portal to render
+ * dropdown-menu outside of "overflow: hidden" containers when needed.
+ *
+ * Also it controls popper's placement.
+ */
+export default class DropdownMenuWrapper extends PureComponent<Props, State> {
+    state: State;
+    private handleRef;
+    private updatePopupPlacement;
+    private handleClose;
+    private renderDropdownMenu;
+    render(): jsx.JSX.Element;
+}

package/dist/types-ts4.0/ui-menu/DropdownMenu/types.d.ts

@@ -0,0 +1,46 @@
+import React from 'react';
+import { EditorActionsOptions as EditorActions } from '../../types';
+export interface Props {
+    mountTo?: HTMLElement;
+    boundariesElement?: HTMLElement;
+    scrollableElement?: HTMLElement;
+    isOpen?: boolean;
+    onOpenChange?: (attrs: any) => void;
+    onItemActivated?: (attrs: any) => void;
+    onMouseEnter?: (attrs: any) => void;
+    onMouseLeave?: (attrs: any) => void;
+    fitWidth?: number;
+    fitHeight?: number;
+    offset?: Array<number>;
+    zIndex?: number;
+    items: Array<{
+        items: MenuItem[];
+    }>;
+    shouldUseDefaultRole?: boolean;
+}
+export interface MenuItem {
+    key?: string;
+    content: string | React.ReactChild | React.ReactFragment;
+    value: {
+        name: string;
+    };
+    shortcut?: string;
+    elemBefore?: React.ReactElement<any>;
+    elemAfter?: React.ReactElement<any>;
+    tooltipDescription?: string;
+    tooltipPosition?: string;
+    isActive?: boolean;
+    isDisabled?: boolean;
+    handleRef?: any;
+    className?: string;
+    'aria-label'?: React.AriaAttributes['aria-label'];
+    'aria-haspopup'?: React.AriaAttributes['aria-haspopup'];
+    onClick?: (editorActions: EditorActions) => void;
+}
+export interface State {
+    target?: HTMLElement;
+    popupPlacement: [
+        string,
+        string
+    ];
+}