@atlaskit/editor-core 182.2.0 → 183.0.6

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

@@ -0,0 +1,49 @@
+import { KeyboardEvent } from 'react';
+import { ActivityProvider, ActivityItem } from '@atlaskit/activity-provider';
+import { INPUT_METHOD } from '../../plugins/analytics';
+export declare type RecentSearchInputTypes = INPUT_METHOD.TYPEAHEAD | INPUT_METHOD.MANUAL;
+export interface ChildProps {
+    activityProvider: ActivityProvider | null;
+    inputProps: {
+        onChange(input: string): void;
+        onKeyDown(event: KeyboardEvent<any>): void;
+        onSubmit(): void;
+        value: string;
+    };
+    currentInputMethod?: RecentSearchInputTypes;
+    clearValue(): void;
+    renderRecentList(): React.ReactNode;
+}
+export interface RecentSearchSubmitOptions {
+    text: string;
+    url: string;
+    inputMethod: RecentSearchInputTypes;
+}
+export interface RecentSearchProps {
+    defaultUrl?: string;
+    onSubmit(options: RecentSearchSubmitOptions): void;
+    onBlur(options: RecentSearchSubmitOptions): void;
+    render(state: ChildProps): React.ReactNode;
+    limit?: number;
+}
+export interface RecentSearchState {
+    items: Array<ActivityItem>;
+    selectedIndex: number;
+    isLoading: boolean;
+    url: string;
+}
+export declare type LinkSearchListItemData = {
+    objectId: string;
+    name: string;
+    container: string;
+    url: string;
+    iconUrl?: string | never;
+    icon?: React.ReactChild | never;
+    lastViewedDate?: Date;
+    lastUpdatedDate?: Date;
+    prefetch?: boolean;
+} & ({
+    iconUrl: string;
+} | {
+    icon: React.ReactChild;
+});

package/dist/types-ts4.0/ui/LinkSearch/withActivityProvider.d.ts

@@ -0,0 +1,66 @@
+import React from 'react';
+import { ActivityProvider } from '@atlaskit/activity-provider';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import type { Providers } from '@atlaskit/editor-common/provider-factory';
+import type { Diff } from '@atlaskit/editor-common/utils';
+export interface ExpandedActivityProviderProps {
+    providerFactory: ProviderFactory;
+}
+export interface WithActivityProviderProps {
+    activityProvider: ActivityProvider;
+}
+export default function withActivityProvider<Props>(WrappedComponent: React.ComponentType<Props & WithActivityProviderProps>): {
+    new (props: Readonly<Diff<Props, WithActivityProviderProps> & ExpandedActivityProviderProps>): {
+        renderNode: (providers: Providers) => JSX.Element;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<Diff<Props, WithActivityProviderProps> & ExpandedActivityProviderProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callBack?: (() => void) | undefined): void;
+        readonly props: Readonly<Diff<Props, WithActivityProviderProps> & ExpandedActivityProviderProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<Diff<Props, WithActivityProviderProps> & ExpandedActivityProviderProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Diff<Props, WithActivityProviderProps> & ExpandedActivityProviderProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<Diff<Props, WithActivityProviderProps> & ExpandedActivityProviderProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Diff<Props, WithActivityProviderProps> & ExpandedActivityProviderProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Diff<Props, WithActivityProviderProps> & ExpandedActivityProviderProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Diff<Props, WithActivityProviderProps> & ExpandedActivityProviderProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Diff<Props, WithActivityProviderProps> & ExpandedActivityProviderProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: Diff<Props, WithActivityProviderProps> & ExpandedActivityProviderProps, context?: any): {
+        renderNode: (providers: Providers) => JSX.Element;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<Diff<Props, WithActivityProviderProps> & ExpandedActivityProviderProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callBack?: (() => void) | undefined): void;
+        readonly props: Readonly<Diff<Props, WithActivityProviderProps> & ExpandedActivityProviderProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<Diff<Props, WithActivityProviderProps> & ExpandedActivityProviderProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Diff<Props, WithActivityProviderProps> & ExpandedActivityProviderProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<Diff<Props, WithActivityProviderProps> & ExpandedActivityProviderProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Diff<Props, WithActivityProviderProps> & ExpandedActivityProviderProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Diff<Props, WithActivityProviderProps> & ExpandedActivityProviderProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Diff<Props, WithActivityProviderProps> & ExpandedActivityProviderProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Diff<Props, WithActivityProviderProps> & ExpandedActivityProviderProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    contextType?: React.Context<any> | undefined;
+};

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

@@ -0,0 +1,7 @@
+import { EditorState } from 'prosemirror-state';
+import { IntlShape } from 'react-intl-next';
+import { NodeType } from 'prosemirror-model';
+import { FloatingToolbarItem } from '../../plugins/floating-toolbar/types';
+import { Command } from '../../types';
+declare const buildLayoutButtons: (state: EditorState, intl: IntlShape, nodeType: NodeType, allowResizing?: boolean | undefined, allowResizingInTables?: boolean | undefined, allowWrapping?: boolean, allowAlignment?: boolean) => FloatingToolbarItem<Command>[];
+export default buildLayoutButtons;

package/dist/types-ts4.0/ui/MediaAndEmbedsToolbar/toolbar-messages.d.ts

@@ -0,0 +1,12 @@
+export declare const toolbarMessages: {
+    wrapLeft: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    wrapRight: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};

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

@@ -0,0 +1,46 @@
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+import { KeyboardEvent, PureComponent } from 'react';
+import { FocusEvent } from '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;
+}
+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.0/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.0/ui/PluginSlot/index.d.ts

@@ -0,0 +1,37 @@
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+import { EditorView } from 'prosemirror-view';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import { EditorAppearance, UIComponentFactory } from '../../types';
+import { EventDispatcher } from '../../event-dispatcher';
+import EditorActions from '../../actions';
+import { DispatchAnalyticsEvent } from '../../plugins/analytics';
+export interface Props {
+    items?: Array<UIComponentFactory>;
+    editorView?: EditorView;
+    editorActions?: EditorActions;
+    eventDispatcher?: EventDispatcher;
+    providerFactory: ProviderFactory;
+    appearance?: EditorAppearance;
+    popupsMountPoint?: HTMLElement;
+    popupsBoundariesElement?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    containerElement: HTMLElement | null;
+    disabled: boolean;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    contentArea?: HTMLElement;
+    wrapperElement: HTMLElement | null;
+}
+export default class PluginSlot extends React.Component<Props, any> {
+    static displayName: string;
+    transitionEvent: "transitionend" | undefined;
+    shouldComponentUpdate(nextProps: Props): boolean;
+    componentDidMount(): void;
+    UNSAFE_componentWillReceiveProps(nextProps: Props): void;
+    componentWillUnmount(): void;
+    forceComponentUpdate: (event: TransitionEvent) => void;
+    removeModeChangeListener: (contentArea?: HTMLElement | undefined) => void;
+    addModeChangeListener: (contentArea?: HTMLElement | undefined) => void;
+    render(): jsx.JSX.Element | null;
+}

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,51 @@
+import React from 'react';
+import { EventDispatcher } from '../../event-dispatcher';
+import { FireAnalyticsCallback } from '@atlaskit/editor-common/analytics';
+import { IntlShape, WrappedComponentProps } from 'react-intl-next';
+import type { ThemeModes } from '@atlaskit/theme/types';
+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>;
+};
+declare 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.0/ui/Resizer/index.d.ts

@@ -0,0 +1,41 @@
+import React from 'react';
+import { RefObject } from 'react';
+import { Resizable } from 're-resizable';
+import { RichMediaLayout } from '@atlaskit/adf-schema';
+import { Props as ResizableMediaSingleProps, EnabledHandles } from './types';
+import { DispatchAnalyticsEvent } from '../../plugins/analytics';
+export interface ResizableNumberSize {
+    width: number;
+    height: number;
+}
+export declare 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;
+};
+export declare 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.0/ui/Resizer/styled.d.ts

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

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

@@ -0,0 +1,26 @@
+import { RichMediaLayout } from '@atlaskit/adf-schema';
+import type { MediaSingleProps } from '@atlaskit/editor-common/ui';
+import { MediaClientConfig } from '@atlaskit/media-core';
+import { GridType } from '../../plugins/grid/types';
+import { EditorView } from 'prosemirror-view';
+import { getPosHandler } from '../../nodeviews/types';
+import { DispatchAnalyticsEvent } from '../../plugins/analytics';
+export declare type EnabledHandles = {
+    left?: boolean;
+    right?: boolean;
+};
+export declare type Props = MediaSingleProps & {
+    updateSize: (width: number | null, layout: RichMediaLayout) => void;
+    displayGrid: (show: boolean, type: GridType, highlight?: number[] | string[]) => void;
+    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.0/ui/Resizer/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.0/ui/Toolbar/Toolbar.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { ToolbarProps } from './toolbar-types';
+export declare const Toolbar: React.FunctionComponent<ToolbarProps>;

package/dist/types-ts4.0/ui/Toolbar/ToolbarInner.d.ts

@@ -0,0 +1,8 @@
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+import { ToolbarInnerProps } from './toolbar-types';
+export declare class ToolbarInner extends React.Component<ToolbarInnerProps> {
+    shouldComponentUpdate(nextProps: ToolbarInnerProps): boolean;
+    render(): jsx.JSX.Element | null;
+}

package/dist/types-ts4.0/ui/Toolbar/ToolbarWithSizeDetector.d.ts

@@ -0,0 +1,4 @@
+/** @jsx jsx */
+import React from 'react';
+import { ToolbarWithSizeDetectorProps } from './toolbar-types';
+export declare const ToolbarWithSizeDetector: React.FunctionComponent<ToolbarWithSizeDetectorProps>;

package/dist/types-ts4.0/ui/Toolbar/hooks.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+export declare const useElementWidth: (ref: React.RefObject<HTMLElement>, { skip }: {
+    skip: boolean;
+}) => number | undefined;

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

@@ -0,0 +1,4 @@
+export { ToolbarWithSizeDetector as default } from './ToolbarWithSizeDetector';
+export { Toolbar } from './Toolbar';
+export type { ToolbarProps } from './toolbar-types';
+export { ToolbarSize } from './types';

package/dist/types-ts4.0/ui/Toolbar/toolbar-size.d.ts

@@ -0,0 +1,4 @@
+import { EditorAppearance } from '../../types';
+import { ToolbarSize } from './types';
+export declare const toolbarSizeToWidth: (toolbarSize: ToolbarSize, appearance?: EditorAppearance | undefined) => number;
+export declare const widthToToolbarSize: (toolbarWidth: number, appearance?: EditorAppearance | undefined) => ToolbarSize;

package/dist/types-ts4.0/ui/Toolbar/toolbar-types.d.ts

@@ -0,0 +1,34 @@
+import { EditorView } from 'prosemirror-view';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import { EditorAppearance } from '../../types/editor-appearance';
+import { ToolbarSize, ToolbarUIComponentFactory } from './types';
+import { EventDispatcher } from '../../event-dispatcher';
+import EditorActions from '../../actions';
+import { DispatchAnalyticsEvent } from '../../plugins/analytics';
+export interface ToolbarBreakPoint {
+    width: number;
+    size: ToolbarSize;
+}
+export interface ToolbarProps {
+    items?: Array<ToolbarUIComponentFactory>;
+    editorView: EditorView;
+    editorActions?: EditorActions;
+    eventDispatcher: EventDispatcher;
+    providerFactory: ProviderFactory;
+    appearance?: EditorAppearance;
+    popupsMountPoint?: HTMLElement;
+    popupsBoundariesElement?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    disabled: boolean;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    toolbarSize: ToolbarSize;
+    containerElement: HTMLElement | null;
+    hasMinWidth?: boolean;
+    twoLineEditorToolbar?: boolean;
+}
+export declare type ToolbarWithSizeDetectorProps = Omit<ToolbarProps, 'toolbarSize'>;
+export interface ToolbarInnerProps extends ToolbarProps {
+    isToolbarReducedSpacing: boolean;
+    isReducedSpacing?: boolean;
+}
+export declare const toolbarTestIdPrefix = "ak-editor-toolbar-button";

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

@@ -0,0 +1,2 @@
+export { ToolbarSize, ToolbarWidths, ToolbarWidthsFullPage, } from '@atlaskit/editor-common/types';
+export type { ToolbarUiComponentFactoryParams, ToolbarUIComponentFactory, } from '@atlaskit/editor-common/types';

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

@@ -0,0 +1,30 @@
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+import { EditorAppearance } from '../../types';
+import { EditorView } from 'prosemirror-view';
+import React, { ReactNode } from 'react';
+import { UseStickyToolbarType } from '../../types/editor-props';
+import { IntlShape } from 'react-intl-next/src/types';
+export interface KeyDownHandlerContext {
+    handleArrowLeft: () => void;
+    handleArrowRight: () => void;
+    handleTab: () => void;
+}
+export declare const KeyDownHandlerContext: React.Context<KeyDownHandlerContext>;
+/**
+ * This component is a wrapper of main toolbar which listens to keydown events of children
+ * and handles left/right arrow key navigation for all focusable elements
+ * @param
+ * @returns
+ */
+export declare const ToolbarArrowKeyNavigationProvider: ({ children, editorView, childComponentSelector, handleEscape, disableArrowKeyNavigation, isShortcutToFocusToolbar, editorAppearance, useStickyToolbar, intl, }: {
+    children: ReactNode;
+    editorView?: EditorView<any> | undefined;
+    childComponentSelector: string;
+    handleEscape?: ((event: KeyboardEvent) => void) | undefined;
+    disableArrowKeyNavigation?: boolean | undefined;
+    isShortcutToFocusToolbar?: ((event: KeyboardEvent) => boolean) | undefined;
+    editorAppearance?: EditorAppearance | undefined;
+    useStickyToolbar?: UseStickyToolbarType | undefined;
+    intl: IntlShape;
+}) => jsx.JSX.Element;

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

@@ -0,0 +1,4 @@
+import { ToolbarButton, TOOLBAR_BUTTON } from '@atlaskit/editor-common/ui-menu';
+export type { ToolbarButtonRef } from '@atlaskit/editor-common/ui-menu';
+export { TOOLBAR_BUTTON };
+export default ToolbarButton;

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

@@ -0,0 +1,45 @@
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+import { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+export declare type EditorProduct = 'bitbucket' | 'jira' | 'confluence' | 'stride' | undefined;
+export interface Props {
+    /** @deprecated  To pass package version use feedbackInfo property – <Editor feedbackInfo={{ packageVersion }} /> */
+    packageVersion?: string;
+    /** @deprecated  'To pass package name use feedbackInfo property – <Editor feedbackInfo={{ packageName }} /> */
+    packageName?: string;
+    product?: EditorProduct;
+    popupsMountPoint?: HTMLElement;
+    popupsBoundariesElement?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    /** @deprecated 'To pass feedback labels use feedbackInfo property – <Editor feedbackInfo={{ labels }} />' */
+    labels?: string[];
+}
+export interface State {
+    jiraIssueCollectorScriptLoading: boolean;
+    showOptOutOption?: boolean;
+    target?: HTMLElement;
+}
+declare global {
+    interface Window {
+        jQuery: any;
+        ATL_JQ_PAGE_PROPS: any;
+    }
+}
+export default class ToolbarFeedback extends PureComponent<Props, State> {
+    static contextTypes: {
+        editorActions: PropTypes.Validator<object>;
+    };
+    state: State;
+    constructor(props: Props);
+    private handleRef;
+    showJiraCollectorDialogCallback?: () => void;
+    private getFeedbackInfo;
+    render(): jsx.JSX.Element | null;
+    private collectFeedback;
+    private toggleShowOptOutOption;
+    private openJiraIssueCollector;
+    private openFeedbackPopup;
+    private openLearnMorePage;
+    private hasJquery;
+}

package/dist/types-ts4.0/ui/ToolbarFeedback/styles.d.ts

@@ -0,0 +1,6 @@
+export declare const buttonContent: import("@emotion/react").SerializedStyles;
+export declare const wrapper: import("@emotion/react").SerializedStyles;
+export declare const confirmationPopup: import("@emotion/react").SerializedStyles;
+export declare const confirmationText: import("@emotion/react").SerializedStyles;
+export declare const confirmationHeader: import("@emotion/react").SerializedStyles;
+export declare const confirmationImg: import("@emotion/react").SerializedStyles;

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

@@ -0,0 +1,11 @@
+import React from 'react';
+import { PositionType } from '@atlaskit/tooltip/types';
+import { WrappedComponentProps } from 'react-intl-next';
+interface Props {
+    title?: string;
+    titlePosition?: PositionType;
+}
+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/ToolbarHelp/messages.d.ts

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

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

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { EditorView } from 'prosemirror-view';
+export interface Props {
+    editorView?: EditorView;
+}
+declare const WidthEmitter: ({ editorView }: Props) => JSX.Element;
+export default WidthEmitter;

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

@@ -0,0 +1,18 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import EditorActions from '../../actions';
+export interface WithEditorActionsProps {
+    render(actions: EditorActions): React.ReactElement<any> | null;
+}
+export default class WithEditorActions extends React.Component<WithEditorActionsProps, any> {
+    static contextTypes: {
+        editorActions: PropTypes.Validator<object>;
+    };
+    context: {
+        editorActions: EditorActions;
+    };
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    private onContextUpdate;
+    render(): React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+}

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

@@ -0,0 +1,11 @@
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+export interface Props {
+    animate: boolean;
+    children?: any;
+}
+export default class WithFlash extends React.Component<Props> {
+    private toggle;
+    render(): jsx.JSX.Element;
+}

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

@@ -0,0 +1,11 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+export default class WithHelpTrigger extends React.Component<{
+    render: (openHelp: () => void) => React.ReactNode;
+}, any> {
+    static contextTypes: {
+        editorActions: PropTypes.Validator<object>;
+    };
+    openHelp: () => void;
+    render(): React.ReactNode;
+}

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

@@ -0,0 +1,3 @@
+import { Props, State, WithPluginState, PerformanceOptions, PluginsConfig } from '@atlaskit/editor-common/with-plugin-state';
+export type { Props, State, PerformanceOptions, PluginsConfig };
+export default WithPluginState;

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

@@ -0,0 +1,12 @@
+export { shortcutStyle } from '@atlaskit/editor-shared-styles/shortcut';
+export { scrollbarStyles } from '@atlaskit/editor-shared-styles/scrollbar';
+export declare const buttonGroupStyle: import("@emotion/react").SerializedStyles;
+export declare const separatorStyles: import("@emotion/react").SerializedStyles;
+export declare const wrapperStyle: import("@emotion/react").SerializedStyles;
+export declare const wrapperSmallStyle: import("@emotion/react").SerializedStyles;
+export declare const expandIconWrapperStyle: import("@emotion/react").SerializedStyles;
+export declare const triggerWrapperStyles: import("@emotion/react").SerializedStyles;
+export declare const buttonContentStyle: import("@emotion/react").SerializedStyles;
+export declare const buttonContentReducedSpacingStyle: import("@emotion/react").SerializedStyles;
+export declare const clickSelectWrapperStyle: import("@emotion/react").SerializedStyles;
+export declare const centeredToolbarContainer: import("@emotion/react").SerializedStyles;

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

@@ -0,0 +1,2 @@
+import { withReactEditorViewOuterListeners } from '@atlaskit/editor-common/ui-react';
+export default withReactEditorViewOuterListeners;