@atlaskit/editor-common 107.28.2 → 107.30.0

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

@@ -3,12 +3,12 @@ import { ProviderFactory } from '../../provider-factory';
 import { type ProfilecardProvider } from '../../provider-factory/profile-card-provider';
 import { type MentionEventHandlers } from '../EventHandlers';
 export interface MentionProps {
+    accessLevel?: string;
+    eventHandlers?: MentionEventHandlers;
     id: string;
+    localId?: string;
     providers?: ProviderFactory;
-    eventHandlers?: MentionEventHandlers;
     text: string;
-    accessLevel?: string;
-    localId?: string;
 }
 export interface MentionState {
     profilecardProvider: ProfilecardProvider | null;

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

@@ -3,16 +3,16 @@ import type { MentionProvider } from '@atlaskit/mention';
 import type { ProfilecardProvider } from '../../provider-factory/profile-card-provider';
 import type { MentionEventHandler } from '../EventHandlers';
 export interface Props {
+    accessLevel?: string;
     autoFocus?: boolean;
     id: string;
-    text: string;
-    accessLevel?: string;
+    localId?: string;
     mentionProvider?: Promise<MentionProvider>;
-    profilecardProvider: ProfilecardProvider;
     onClick?: MentionEventHandler;
     onMouseEnter?: MentionEventHandler;
     onMouseLeave?: MentionEventHandler;
-    localId?: string;
+    profilecardProvider: ProfilecardProvider;
     ssrPlaceholderId?: string;
+    text: string;
 }
 export default function MentionWithProfileCard({ autoFocus, id, text, accessLevel, mentionProvider, profilecardProvider, onClick, onMouseEnter, onMouseLeave, localId, ssrPlaceholderId, }: Props): React.JSX.Element;

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

@@ -3,13 +3,13 @@ import type { MentionProvider } from '@atlaskit/mention/resource';
 import type { ProfilecardProvider } from '../../provider-factory/profile-card-provider';
 import type { MentionEventHandlers } from '../EventHandlers';
 export interface Props {
-    id: string;
-    text: string;
     accessLevel?: string;
-    mentionProvider?: Promise<MentionProvider>;
-    profilecardProvider?: Promise<ProfilecardProvider>;
     eventHandlers?: MentionEventHandlers;
+    id: string;
     localId?: string;
+    mentionProvider?: Promise<MentionProvider>;
+    profilecardProvider?: Promise<ProfilecardProvider>;
+    text: string;
 }
 export interface State {
     profilecardProvider: ProfilecardProvider | null;

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

@@ -5,9 +5,9 @@ export declare const shadowClassNames: {
     LEFT_SHADOW: string;
 };
 export interface OverflowShadowProps {
+    disableTableOverflowShadow?: boolean;
     handleRef?: (ref: HTMLElement | null) => void;
     shadowClassNames?: string;
-    disableTableOverflowShadow?: boolean;
 }
 export interface OverflowShadowState {
     showLeftShadow: boolean;

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

@@ -18,8 +18,8 @@ export declare class ShadowObserver {
     private requestCallbackId?;
     readonly shadowStates: ShadowsStates;
     constructor({ scrollContainer, onUpdateShadows, }: {
-        scrollContainer: HTMLElement;
         onUpdateShadows: (eventData: ShadowsStates) => void;
+        scrollContainer: HTMLElement;
     });
     private init;
     private onIntersect;

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

@@ -6,30 +6,30 @@ import type { FocusEvent, KeyboardEvent } from 'react';
 import { PureComponent } from 'react';
 import { jsx } from '@emotion/react';
 export interface Props {
+    ariaActiveDescendant?: string;
+    ariaAutoComplete?: boolean;
+    ariaControls?: string;
+    ariaExpanded?: boolean;
+    ariaInvalid?: boolean;
+    ariaLabel?: string;
+    ariaRequired?: boolean;
     autoFocus?: boolean | FocusOptions;
     defaultValue?: string;
-    onChange?: (value: string) => void;
-    onSubmit?: (value: string) => void;
+    describedById?: string;
+    inputId?: string;
+    maxLength?: number;
+    onBlur?: Function;
     onCancel?: (e: KeyboardEvent) => void;
-    placeholder?: string;
-    onMouseDown?: Function;
+    onChange?: (value: string) => void;
     onKeyDown?: (e: KeyboardEvent<any>) => void;
-    onUndo?: Function;
+    onMouseDown?: Function;
     onRedo?: Function;
-    onBlur?: Function;
-    width?: number;
-    maxLength?: number;
-    testId?: string;
-    ariaLabel?: string;
-    describedById?: string;
-    ariaExpanded?: boolean;
-    ariaActiveDescendant?: string;
-    ariaControls?: string;
+    onSubmit?: (value: string) => void;
+    onUndo?: Function;
+    placeholder?: string;
     role?: string;
-    ariaAutoComplete?: boolean;
-    ariaRequired?: boolean;
-    ariaInvalid?: boolean;
-    inputId?: string;
+    testId?: string;
+    width?: number;
 }
 export interface State {
     value?: string;

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

@@ -1,35 +1,35 @@
 import React from 'react';
 import type { Position } from './utils';
 export interface Props {
-    zIndex?: number;
+    absoluteOffset?: Position;
     alignX?: 'left' | 'right' | 'center' | 'end';
     alignY?: 'top' | 'bottom' | 'start';
-    target?: HTMLElement;
+    allowOutOfBounds?: boolean;
+    /** `null` should only be used if we provide enough context to screen readers to exclude aria-label attribute */
+    ariaLabel?: string | null;
+    boundariesElement?: HTMLElement;
+    children?: React.ReactNode;
     fitHeight?: number;
     fitWidth?: number;
-    boundariesElement?: HTMLElement;
+    /** Enable focus trap to contain the user's focus within the popup */
+    focusTrap?: boolean;
+    forcePlacement?: boolean;
     mountTo?: HTMLElement;
     offset?: number[];
-    onUnmount?: () => void;
-    onPositionCalculated?: (position: Position) => Position;
     onPlacementChanged?: (placement: [
         string,
         string
     ]) => void;
-    shouldRenderPopup?: (position: Position) => boolean;
+    onPositionCalculated?: (position: Position) => Position;
+    onUnmount?: () => void;
+    preventOverflow?: boolean;
+    rect?: DOMRect;
     scrollableElement?: HTMLElement;
+    shouldRenderPopup?: (position: Position) => boolean;
     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;
-    children?: React.ReactNode;
+    target?: HTMLElement;
+    zIndex?: number;
 }
 export interface State {
     popup?: HTMLElement;

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

@@ -1,20 +1,20 @@
 export interface Position {
-    top?: number;
-    right?: number;
     bottom?: number;
     left?: number;
+    right?: number;
+    top?: number;
 }
 export interface CalculatePositionParams {
+    allowOutOfBounds?: boolean;
+    offset: number[];
     placement: [
         string,
         string
     ];
-    target?: HTMLElement;
     popup?: HTMLElement;
-    offset: number[];
-    stick?: boolean;
-    allowOutOfBounds?: boolean;
     rect?: DOMRect;
+    stick?: boolean;
+    target?: HTMLElement;
 }
 export declare function isBody(elem: HTMLElement | Element): boolean;
 export declare function isTextNode(elem: HTMLElement | Element): boolean;

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

@@ -1,10 +1,10 @@
 import React, { type ReactNode } from 'react';
 interface Props {
+    children: ReactNode;
     /** If true, the component will have pulse onboarding effect around it. */
     pulse?: boolean;
     /** The radius of the pulse effect. */
     radius?: number;
-    children: ReactNode;
 }
 /**
  * Wraps children with {@link SpotlightPulse} component.

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

@@ -6,27 +6,27 @@ 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;
+    width: 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;
+    enable: EnabledHandles;
     handleComponentFunc?: (side: string) => React.ReactElement<any> | undefined;
     handleStyles?: HandleStyles;
+    height?: number;
+    highlights: (width: number, snapPoints: number[]) => number[] | string[];
+    innerPadding?: number;
+    nodeType?: 'media' | 'embed';
+    ratio?: string;
+    scaleFactor?: number;
+    selected?: boolean;
+    snapPoints: number[];
+    width: number;
 };
 export type ResizerState = {
     isResizing: boolean;

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

@@ -10,17 +10,17 @@ export type EnabledHandles = {
     right?: boolean;
 };
 export type Props = MediaSingleProps & {
-    updateSize: (width: number | null, layout: RichMediaLayout) => void;
+    allowBreakoutSnapPoints?: boolean;
+    containerWidth: number;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
     displayGrid: ((show: boolean, type: GridType, highlight: number[] | string[]) => void) | undefined;
+    fullWidthMode?: boolean;
     getPos: getPosHandler;
-    view: EditorView;
-    lineLength: number;
     gridSize: number;
-    containerWidth: number;
-    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
-    allowBreakoutSnapPoints?: boolean;
+    lineLength: number;
     selected?: boolean;
-    viewMediaClientConfig?: MediaClientConfig;
-    fullWidthMode?: boolean;
+    updateSize: (width: number | null, layout: RichMediaLayout) => void;
     updateWidth?: (newWidth: number) => void;
+    view: EditorView;
+    viewMediaClientConfig?: MediaClientConfig;
 };

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

@@ -9,20 +9,20 @@ export interface OnTableSizeSelection {
 }
 type SimpleEventHandler<T> = (event: T) => void;
 export interface TableSelectorPopupProps {
-    onUnmount?: () => void;
-    onSelection: OnTableSizeSelection;
-    target?: HTMLElement;
-    popupsMountPoint?: HTMLElement;
-    popupsBoundariesElement?: HTMLElement;
-    popupsScrollableElement?: HTMLElement;
-    handleClickOutside?: SimpleEventHandler<MouseEvent>;
-    handleEscapeKeydown?: SimpleEventHandler<KeyboardEvent>;
-    isOpenedByKeyboard: boolean;
+    allowOutsideSelection?: boolean;
     defaultSize?: {
-        row: number;
         col: number;
+        row: number;
     };
-    allowOutsideSelection?: boolean;
+    handleClickOutside?: SimpleEventHandler<MouseEvent>;
+    handleEscapeKeydown?: SimpleEventHandler<KeyboardEvent>;
+    isOpenedByKeyboard: boolean;
+    onSelection: OnTableSizeSelection;
+    onUnmount?: () => void;
+    popupsBoundariesElement?: HTMLElement;
+    popupsMountPoint?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    target?: HTMLElement;
 }
 export declare const TableSelectorPopup: (props: TableSelectorPopupProps) => jsx.JSX.Element;
 export default TableSelectorPopup;

package/dist/types-ts4.5/ui/TableSelector/table-selector.d.ts

@@ -3,27 +3,27 @@ import type { WrappedComponentProps } from 'react-intl-next';
 export declare const TABLE_SELECTOR_BUTTON_GAP = 2;
 export declare const TABLE_SELECTOR_BUTTON_SIZE = 17;
 export interface TableSelectorButtonProps {
-    row: number;
     col: number;
+    handleInitialButtonFocus: () => void;
     isActive: boolean;
-    onClick: OnTableSizeSelection;
+    isFocused: boolean;
     label: string;
+    onClick: OnTableSizeSelection;
     onKeyDown: KeyboardEventHandler<HTMLButtonElement>;
-    isFocused: boolean;
-    handleInitialButtonFocus: () => void;
+    row: number;
 }
 export interface OnTableSizeSelection {
     (rowsCount: number, colsCount: number, event?: SyntheticEvent): void;
 }
 interface TableSelectorPopupProps {
+    handleInitialButtonFocus: () => void;
+    isFocused: boolean;
     maxCols: number;
     maxRows: number;
+    onKeyDown: KeyboardEventHandler<HTMLButtonElement>;
     onSelection: OnTableSizeSelection;
     selectedCol: number;
     selectedRow: number;
-    onKeyDown: KeyboardEventHandler<HTMLButtonElement>;
-    isFocused: boolean;
-    handleInitialButtonFocus: () => void;
 }
 declare const _default: import("react").FC<import("react-intl-next").WithIntlProps<TableSelectorPopupProps & WrappedComponentProps>> & {
     WrappedComponent: import("react").ComponentType<TableSelectorPopupProps & WrappedComponentProps>;

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

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

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

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

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

@@ -6,8 +6,8 @@ import React from 'react';
 import { jsx } from '@emotion/react';
 export type Breakpoints = 'S' | 'M' | 'L';
 export type WidthConsumerContext = {
-    width: number;
     breakpoint: Breakpoints;
+    width: number;
 };
 export declare function getBreakpoint(width?: number): Breakpoints;
 export declare function createWidthContext(width?: number): WidthConsumerContext;
@@ -17,9 +17,9 @@ export type WidthProviderState = {
     width?: number;
 };
 type WidthProviderProps = {
+    children?: React.ReactNode;
     className?: string;
     shouldCheckExistingValue?: boolean;
-    children?: React.ReactNode;
 };
 /**
  * 🧱 Internal function: Editor FE Platform

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

@@ -5,17 +5,17 @@
 import React, { type ReactElement } from 'react';
 import { jsx } from '@emotion/react';
 export interface Props {
-    value: string;
-    label: string;
-    tabIndex?: number;
-    isSelected?: boolean;
-    onClick: (value: string, label: string) => void;
-    onKeyDown?: (value: string, label: string, event: React.KeyboardEvent) => void;
+    autoFocus?: boolean;
     borderColor: string;
     checkMarkColor?: string;
-    autoFocus?: boolean;
-    hexToPaletteColor?: (hexColor: string) => string | undefined;
     decorator?: ReactElement;
+    hexToPaletteColor?: (hexColor: string) => string | undefined;
+    isSelected?: boolean;
+    label: string;
+    onClick: (value: string, label: string) => void;
+    onKeyDown?: (value: string, label: string, event: React.KeyboardEvent) => void;
+    tabIndex?: number;
+    value: string;
 }
 declare const Color: (props: Props) => jsx.JSX.Element;
 export default Color;

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

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

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

@@ -6,17 +6,15 @@ import React from 'react';
 import type { WrappedComponentProps } from 'react-intl-next';
 import type { PaletteColor, PaletteTooltipMessages } from './Palettes/type';
 interface Props {
-    selectedColor: string | null;
+    className?: string;
+    cols?: number;
     onClick: (value: string, label: string) => void;
     onKeyDown?: (value: string, label: string, event: React.KeyboardEvent) => void;
-    cols?: number;
-    className?: string;
     /**
      * paletteOptions is the prop, where any configuration related to
      * how palette should look or behave will be added.
      */
     paletteOptions: {
-        palette: PaletteColor[];
         /**
          * If hexToPaletteColor is passed, it will be called to convert
          *  hexCodes passed in palette props to DST token.
@@ -25,6 +23,7 @@ interface Props {
          *  mapping function to map tokens.
          */
         hexToPaletteColor?: (hexColor: string) => string | undefined;
+        palette: PaletteColor[];
         /**
          * We have pivoted from having logic inside ColorPalette determining
          *  which tooltip messages should be used to consumer of ColorPalette giving
@@ -35,6 +34,7 @@ interface Props {
          */
         paletteColorTooltipMessages?: PaletteTooltipMessages;
     };
+    selectedColor: string | null;
 }
 declare const _default: React.FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps>> & {
     WrappedComponent: React.ComponentType<Props & WrappedComponentProps>;

package/dist/types-ts4.5/ui-menu/ArrowKeyNavigationProvider/types.d.ts

@@ -1,6 +1,6 @@
 export interface KeyDownHandlerContext {
-    handleArrowRight: () => void;
     handleArrowLeft: () => void;
+    handleArrowRight: () => void;
     handleTab: () => void;
 }
 export type SimpleEventHandler<T> = (event: T) => void;
@@ -9,32 +9,32 @@ export declare enum ArrowKeyNavigationType {
     MENU = "menu"
 }
 export type ColorPaletteArrowKeyNavigationOptions = {
-    type: ArrowKeyNavigationType.COLOR;
-    selectedRowIndex: number;
-    selectedColumnIndex: number;
+    children?: React.ReactNode;
     isOpenedByKeyboard: boolean;
     isPopupPositioned: boolean;
-    children?: React.ReactNode;
+    selectedColumnIndex: number;
+    selectedRowIndex: number;
+    type: ArrowKeyNavigationType.COLOR;
 };
 export type ColorPaletteArrowKeyNavigationProps = ColorPaletteArrowKeyNavigationOptions & {
-    handleClose?: SimpleEventHandler<KeyboardEvent>;
     closeOnTab?: boolean;
     editorRef: React.RefObject<HTMLDivElement>;
+    handleClose?: SimpleEventHandler<KeyboardEvent>;
     ignoreEscapeKey?: boolean | false;
     popupsMountPoint?: HTMLElement | undefined;
 };
 export type MenuArrowKeyNavigationOptions = {
-    type: ArrowKeyNavigationType.MENU;
+    children?: React.ReactNode;
     disableArrowKeyNavigation?: boolean;
-    keyDownHandlerContext?: KeyDownHandlerContext;
     disableCloseOnArrowClick?: boolean;
-    children?: React.ReactNode;
+    keyDownHandlerContext?: KeyDownHandlerContext;
+    type: ArrowKeyNavigationType.MENU;
 };
 export type MenuArrowKeyNavigationProviderProps = MenuArrowKeyNavigationOptions & {
-    handleClose?: SimpleEventHandler<KeyboardEvent>;
-    onSelection?: (index: number) => void;
     closeOnTab?: boolean;
     editorRef: React.RefObject<HTMLDivElement>;
+    handleClose?: SimpleEventHandler<KeyboardEvent>;
+    onSelection?: (index: number) => void;
     popupsMountPoint?: HTMLElement | undefined;
 };
 export type ArrowKeyNavigationProviderOptions = ColorPaletteArrowKeyNavigationOptions | MenuArrowKeyNavigationOptions;

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

@@ -7,28 +7,28 @@ import type { WithAnalyticsEventsProps } from '@atlaskit/analytics-next';
 import type { PaletteColor, PaletteTooltipMessages } from '../../ui-color';
 import type { Position as PopupPosition } from '../../ui/Popup/utils';
 declare const _default: React.ForwardRefExoticComponent<Omit<Omit<{
+    absoluteOffset?: PopupPosition;
+    alignX?: "left" | "right" | "center" | "end";
+    colorPalette: PaletteColor[];
+    cols?: number;
     currentColor?: string;
-    title?: string;
+    hexToPaletteColor?: (hexColor: string) => string | undefined;
     isAriaExpanded?: boolean;
+    mountPoint?: HTMLElement;
     onChange?: (color: PaletteColor) => void;
-    colorPalette: PaletteColor[];
+    paletteColorTooltipMessages?: PaletteTooltipMessages;
     placement: string;
-    cols?: number;
-    alignX?: "left" | "right" | "center" | "end";
+    returnEscToButton?: boolean;
+    setDisableParentScroll?: (disable: boolean) => void;
     size?: {
-        width: string;
         height: string;
+        width: string;
     };
-    mountPoint?: HTMLElement;
-    setDisableParentScroll?: (disable: boolean) => void;
-    hexToPaletteColor?: (hexColor: string) => string | undefined;
-    paletteColorTooltipMessages?: PaletteTooltipMessages;
     /**
      * After picking the color the default behaviour is to focus the color picker button.
      * To prevent this use skipFocusButtonAfterPick.
      */
     skipFocusButtonAfterPick?: boolean;
-    absoluteOffset?: PopupPosition;
-    returnEscToButton?: boolean;
+    title?: string;
 }, keyof WithAnalyticsEventsProps> & React.RefAttributes<any> & import("@atlaskit/analytics-next").WithContextProps, "ref"> & React.RefAttributes<any>>;
 export default _default;

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

@@ -3,35 +3,35 @@ import type { WithOutsideClickProps } from '../../ui-react/with-react-editor-vie
 import type { OpenChangedEvent } from '../../ui/DropList';
 import type { ArrowKeyNavigationProviderOptions } from '../ArrowKeyNavigationProvider/types';
 export interface Props {
-    children?: React.ReactNode;
-    mountTo?: HTMLElement;
-    boundariesElement?: HTMLElement;
-    scrollableElement?: HTMLElement;
-    trigger?: React.ReactElement<any>;
-    isOpen?: boolean;
-    onOpenChange?: (attrs: OpenChangedEvent) => void;
-    fitWidth?: number;
-    fitHeight?: number;
-    zIndex?: number;
-    arrowKeyNavigationProviderOptions: ArrowKeyNavigationProviderOptions;
-    dropdownListId?: string;
     alignDropdownWithParentElement?: boolean;
-    target?: HTMLElement;
-    forcePlacement?: boolean;
     alignX?: 'left' | 'right' | 'center';
     alignY?: 'start' | 'bottom' | 'top';
+    arrowKeyNavigationProviderOptions: ArrowKeyNavigationProviderOptions;
+    boundariesElement?: HTMLElement;
+    children?: React.ReactNode;
+    dropdownListId?: string;
+    fitHeight?: number;
+    fitWidth?: number;
+    forcePlacement?: boolean;
+    isOpen?: boolean;
+    mountTo?: HTMLElement;
     offset?: [
         number,
         number
     ];
+    onOpenChange?: (attrs: OpenChangedEvent) => void;
+    scrollableElement?: HTMLElement;
     shouldFitContainer?: boolean;
+    target?: HTMLElement;
+    trigger?: React.ReactElement<any>;
+    zIndex?: number;
 }
 export interface State {
-    target?: HTMLElement;
     popupPlacement: [
         string,
         string
     ];
+    target?: HTMLElement;
 }
 /**
  * Wrapper around @atlaskit/droplist which uses Popup and Portal to render