@atlaskit/editor-core 183.0.9 → 183.0.12

package/dist/types-ts4.5/types/performance-tracking.d.ts

@@ -0,0 +1,323 @@
+export type TTITracking = {
+    /**
+     * @description Whether ttiTracking should be enabled
+     * @default: false
+     */
+    enabled: boolean;
+    /**
+     * @description Time between long tasks that tti measurement considers long enough to treat page as interactive in ms
+     * @default: 1000
+     */
+    ttiIdleThreshold?: number;
+    /**
+     * @description Time in [seconds] after which to stop tti measurements, used to prevent issues when page never becomes responsive, e.g. infinite loops in rendering / etc...
+     * @default: 60
+     */
+    ttiCancelTimeout?: number;
+    /**
+     * @description Control whether TTI severity is tracked. When this is false the severity is not recorded.
+     * @default false
+     */
+    trackSeverity?: boolean;
+    /**
+     * @description Control for calculating tti severity level (NORMAL/DEGRADED/BLOCKING). Depends on trackSeverity being true.
+     * @default 40000
+     */
+    ttiSeverityNormalThreshold?: number;
+    /**
+     * @description Control for calculating tti severity level (NORMAL/DEGRADED/BLOCKING). Depends on trackSeverity being true.
+     * @default 60000
+     */
+    ttiSeverityDegradedThreshold?: number;
+    /**
+     * @description Control for calculating ttiFromInvocation severity level (NORMAL/DEGRADED/BLOCKING). Depends on trackSeverity being true.
+     * @default 5000
+     */
+    ttiFromInvocationSeverityNormalThreshold?: number;
+    /**
+     * @description Control for calculating ttiFromInvocation severity level (NORMAL/DEGRADED/BLOCKING). Depends on trackSeverity being true.
+     * @default 8000
+     */
+    ttiFromInvocationSeverityDegradedThreshold?: number;
+};
+export type TransactionTracking = {
+    /**
+     * @description Whether transactionTracking should be enabled. When this is false no measurements are taken and no events are sent.
+     * @default false
+     **/
+    enabled: boolean;
+    /**
+     * @description Enable timing using browser performance API. This option has been added to verify memory leaks.
+     * @default false
+     **/
+    usePerformanceMarks?: boolean;
+    /**
+     * @description The nth transaction after which a `dispatchTransaction` event is sent. Depends on enabled being true.
+     * @default 100
+     **/
+    samplingRate?: number;
+    /**
+     * @description Transactions that need longer to dispatch than [slowThreshold]ms generate a `dispatchTransaction` event. Depends on enabled being true.
+     * @default 300
+     **/
+    slowThreshold?: number;
+    /**
+     * @description Transactions that need longer to dispatch than [outlierThreshold]ms AND have outlier plugins generate a `dispatchTransaction` event. Depends on enabled being true.
+     * @default 30
+     **/
+    outlierThreshold?: number;
+    /**
+     * @description The factor by which statistically significant outliers in plugin execution times are computed where t = p75 + (p75 - p25) * outlierFactor.
+     * @default 3
+     **/
+    outlierFactor?: number;
+};
+export type UITracking = {
+    /**
+     * @description Whether tracking of WithPluginState should be enabled. When this is false no measurements are taken and no events are sent.
+     * @default false
+     **/
+    enabled: boolean;
+    /**
+     * @description The nth re-render of WithPluginState after which an analytics event is sent. Depends on enabled being true.
+     * @default 100
+     **/
+    samplingRate?: number;
+    /**
+     * @description WithPluginState render that exceeds [slowThreshold]ms generate analytics event. Depends on enabled being true.
+     * @default 4
+     **/
+    slowThreshold?: number;
+};
+export type CatchAllTracking = {
+    /**
+     * @description Control whether a second operational event with a rough performance measurement is sent for every regular analytics event
+     * @default false
+     */
+    enabled: boolean;
+};
+export type NodeViewTracking = {
+    /**
+     * @description Control whether
+      NodeView performance is tracked. When this is false no measurements are taken and no events are sent.
+     * @default false
+     */
+    enabled: boolean;
+    /**
+     * @description The nth re-render of NodeView after which an analytics event is sent. Depends on enabled being true.
+     * @default false
+     */
+    samplingRate?: 100;
+    /**
+     * @description NodeView render that exceeds the threshold generate analytics event. Depends on enabled being true.
+     * @default 7
+     */
+    slowThreshold?: number;
+};
+export type BrowserFreezetracking = {
+    enabled?: boolean;
+    /**
+     * @description Control whether browser freeze interaction type is tracked. When this is false the interaction type is not recorded.
+     * @default false
+     */
+    trackInteractionType?: boolean;
+    /**
+     * @description Control whether browser freeze severity is tracked. When this is false the severity is not recorded.
+     * @default false
+     */
+    trackSeverity?: boolean;
+    /**
+     * @description Control for calculating severity level (NORMAL/DEGRADED/BLOCKING). Depends on severityTracking being true.
+     * @default 2000
+     */
+    severityNormalThreshold?: number;
+    /**
+     * @description Control for calculating severity level (NORMAL/DEGRADED/BLOCKING). Depends on severityTracking being true.
+     * @default 3000
+     */
+    severityDegradedThreshold?: number;
+};
+export type ProseMirrorRenderedTracking = {
+    enabled?: boolean;
+    /**
+     * @description Control whether proseMirror rendered event severity is tracked. When this is false the severity is not recorded.
+     * @default false
+     */
+    trackSeverity: boolean;
+    /**
+     * @description Control for calculating severity level (NORMAL/DEGRADED/BLOCKING). Depends on severityTracking being true.
+     * @default 2000
+     */
+    severityNormalThreshold: number;
+    /**
+     * @description Control for calculating severity level (NORMAL/DEGRADED/BLOCKING). Depends on severityTracking being true.
+     * @default 3000
+     */
+    severityDegradedThreshold: number;
+};
+export interface InputTracking {
+    /**
+     * @description Control whether samples of typing performance are taken. When this is false no measurements are taken and no events are sent.
+     * @default false
+     */
+    enabled: boolean;
+    /**
+     * @description Control whether samples of typing performance are taken. Depends on enabled being true.
+     * @default false
+     */
+    countNodes?: boolean;
+    /**
+     * @description Control for which nth transaction a typing performance sample is taken. Depends on enabled being true.
+     * @default 100
+     */
+    samplingRate?: number;
+    /**
+     * @description input events that exceed [slowThreshold]ms generate analytics event. Depends on enabled being true.
+     * @default 300
+     */
+    slowThreshold?: number;
+    /**
+     * @description input events that exceed [freezeThreshold]ms generate analytics event. Depends on enabled being true.
+     * @default 600
+     */
+    freezeThreshold?: number;
+    /**
+     * @description Control whether input tracking severity is tracked. When this is false the severity is not recorded.
+     * @default false
+     */
+    trackSeverity?: boolean;
+    /**
+     * @description Control for calculating severity level (NORMAL/DEGRADED/BLOCKING). Depends on severityTracking being true.
+     * @default 100
+     */
+    severityNormalThreshold?: number;
+    /**
+     * @description Control for calculating severity level (NORMAL/DEGRADED/BLOCKING). Depends on severityTracking being true.
+     * @default 500
+     */
+    severityDegradedThreshold?: number;
+    /**
+     * @description Track individual keypress processing time when multiple keypress happened in one frame.
+     * @default false
+     */
+    trackSingleKeypress?: boolean;
+    /**
+     * @description Track keypress processing time including browser rendering time.
+     * @default false
+     */
+    trackRenderingTime?: boolean;
+}
+export type ContentRetrievalTracking = {
+    /**
+     * @description Control whether editor content retrieval success and failure events are dispatched.
+     * When this is false no events are sampled or sent.
+     * @default false
+     */
+    enabled: boolean;
+    /**
+     * @description Control how frequently/at what rate successful editor content retrieval events are dispatched.
+     * @default 100
+     */
+    successSamplingRate?: number;
+    /**
+     * @description Control how frequently/at what rate failed editor content retrieval events are dispatched.
+     * @default 100
+     */
+    failureSamplingRate?: number;
+    /**
+     * @description Control whether the failed editor content retrieval event includes the error stack trace.
+     * @default false
+     */
+    reportErrorStack?: boolean;
+};
+export type OnChangeCallbackTracking = {
+    /**
+     * @description Whether onChange callback tracking should be enabled. Requires TransactionTracking
+     * to be enabled.
+     * @default: false
+     */
+    enabled: boolean;
+};
+export type OnEditorReadyCallbackTracking = {
+    /**
+     * @description Control whether onEditorReady callback tracking should be enabled.
+     * @default false
+     */
+    enabled: boolean;
+};
+export type PasteTracking = {
+    /**
+     * @description Control whether paste tracking should be enabled.
+     * @default false
+     */
+    enabled: boolean;
+};
+export type RenderTracking = {
+    /**
+     * @description Control whether editor render tracking should be enabled.
+     * @default false
+     */
+    editor: {
+        enabled: boolean;
+        useShallow?: boolean;
+    };
+    reactEditorView: {
+        enabled: boolean;
+        useShallow?: boolean;
+    };
+};
+export type PerformanceTracking = {
+    /**
+     * @description Control whether measurements for all analytics events are performed
+     */
+    catchAllTracking?: CatchAllTracking;
+    /**
+     * @description Control whether time to interactive is tracked
+     */
+    ttiTracking?: TTITracking;
+    /**
+     * @description Control whether transactions are tracked
+     */
+    inputTracking?: InputTracking;
+    /**
+     * @description Control whether transactions are tracked
+     */
+    transactionTracking?: TransactionTracking;
+    /**
+     * @description Control whether editor ui is tracked
+     */
+    uiTracking?: UITracking;
+    /**
+     * @description Control whether nodeviews are tracked
+     */
+    nodeViewTracking?: NodeViewTracking;
+    /**
+     * @description Control whether browser freezes / long tasks are tracked
+     */
+    bFreezeTracking?: BrowserFreezetracking;
+    /**
+     * @description Control whether proseMirror rendered event is tracked
+     */
+    proseMirrorRenderedTracking?: ProseMirrorRenderedTracking;
+    /**
+     * @description Control whether editor content retrieval events are tracked
+     */
+    contentRetrievalTracking?: ContentRetrievalTracking;
+    /**
+     * @description Control onChange callback is tracked. Requires TransactionTracking to be enabled,
+     * and uses the sampling rate in TransactionTracking.
+     */
+    onChangeCallbackTracking?: OnChangeCallbackTracking;
+    /**
+     * @description Control whether onEditorReady callback is tracked.
+     */
+    onEditorReadyCallbackTracking?: OnEditorReadyCallbackTracking;
+    /**
+     * @description Control whether paste is tracked.
+     */
+    pasteTracking?: PasteTracking;
+    /**
+     * @description Control whether render of different component is tracked.
+     */
+    renderTracking?: RenderTracking;
+};

package/dist/types-ts4.5/types/pm-config.d.ts

@@ -0,0 +1 @@
+export type { NodeConfig, MarkConfig, NodeViewConfig, } from '@atlaskit/editor-common/types';

package/dist/types-ts4.5/types/pm-plugin-list.d.ts

@@ -0,0 +1,9 @@
+import { TransactionTracker } from '../utils/performance/track-transactions';
+import { EditorConfig } from './editor-config';
+import { PerformanceTracking } from './performance-tracking';
+import { PMPluginFactoryParams } from './pm-plugin';
+export type PMPluginCreateConfig = PMPluginFactoryParams & {
+    editorConfig: EditorConfig;
+    performanceTracking?: PerformanceTracking;
+    transactionTracker?: TransactionTracker;
+};

package/dist/types-ts4.5/types/pm-plugin.d.ts

@@ -0,0 +1 @@
+export type { PMPluginFactoryParams, PMPluginFactory, PMPlugin, } from '@atlaskit/editor-common/types';

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

@@ -0,0 +1 @@
+export type { UiComponentFactoryParams, UIComponentFactory, } from '@atlaskit/editor-common/types';

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

@@ -0,0 +1,10 @@
+/** @jsx jsx */
+import React from 'react';
+import { EditorView } from 'prosemirror-view';
+export interface Props {
+    editorView?: EditorView;
+    children?: any;
+    editorDisabled?: boolean;
+}
+export declare const ClickAreaBlock: React.FC<Props>;
+export default ClickAreaBlock;

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

@@ -0,0 +1,8 @@
+/** @jsx jsx */
+import React from 'react';
+import { EditorView } from 'prosemirror-view';
+export interface Props {
+    editorView?: EditorView;
+}
+export declare const ClickAreaInline: React.FC<Props>;
+export default ClickAreaInline;

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

@@ -0,0 +1,31 @@
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+import { EditorView } from 'prosemirror-view';
+export interface Props {
+    editorView?: EditorView;
+    minHeight: number;
+    children?: any;
+    persistScrollGutter?: boolean;
+    isExpanded?: boolean;
+    editorDisabled?: boolean;
+}
+/**
+ * Click Area is responsible for improving UX by ensuring the user
+ * can always tap beneath the content area, to insert more content.
+ *
+ * This is achieved by inserting a new empty paragraph at the end of
+ * the document (if one doesn't already exist).
+ *
+ * This is particularly important when the content exceeds the visible
+ * viewport height, and if the last content node captures text selection
+ * e.g. table, layouts, codeblock, etc.
+ *
+ * This relies on the Scroll Gutter plugin which inserts additional
+ * whitespace at the end of the document when it overflows the viewport.
+ */
+export default class ClickAreaMobile extends React.Component<Props> {
+    private clickElementRef;
+    private handleClick;
+    render(): jsx.JSX.Element;
+}

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

@@ -0,0 +1,14 @@
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+import { RenderOnClickHandler } from '../../Addon/types';
+import EditorActions from '../../../actions';
+export interface Props {
+    onClick: (actionOnClick: EditorActions, renderOnClick: RenderOnClickHandler) => void;
+    editorActions: EditorActions;
+    togglePopup: () => void;
+}
+export default class DropdownWrapper extends React.Component<Props, any> {
+    render(): jsx.JSX.Element;
+    private handleClick;
+}

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

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

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

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

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

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

package/dist/types-ts4.5/ui/Addon/click-area-helper.d.ts

@@ -0,0 +1,13 @@
+import { EditorView } from 'prosemirror-view';
+/**
+ * @see ED-14699 - check if editor is inside a modal to continue to bring cursor to input when
+ * any part of the editor container is clicked
+ *
+ * Handles two cases when a click event is fired:
+ *
+ * 1. if editor (e.g. comment inside of Jira ticket view) is inside modal then ensure focus and cursor is brought to the input
+ * 2. if another modal is open (e.g. delete confirmation modal for confluence table) then ignore clicks as they shouldn't influence editor state
+ */
+export declare const checkForModal: (target: HTMLElement) => boolean;
+declare const clickAreaClickHandler: (view: EditorView<any>, event: React.MouseEvent<any>) => false | undefined;
+export { clickAreaClickHandler };

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

@@ -0,0 +1,6 @@
+export type { AddonActions, AddonCommonProps, AddonConfiguration, AddonProps, RenderOnClickHandler, } from './types';
+export { default as Addon } from './DropdownItem';
+export { default as Dropdown } from './Dropdown';
+export { default as ClickAreaInline } from './ClickAreaInline';
+export { default as ClickAreaBlock } from './ClickAreaBlock';
+export { default as ClickAreaMobile } from './ClickAreaMobile';

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

@@ -0,0 +1,17 @@
+/// <reference types="react" />
+import EditorActions from '../../actions';
+export type RenderOnClickHandler = (editorActions: EditorActions, closePopup: () => void) => React.ReactElement<any>;
+export interface AddonActions {
+    actionOnClick?: (editorActions: EditorActions) => void;
+    renderOnClick?: RenderOnClickHandler;
+}
+export interface AddonCommonProps extends AddonActions {
+    icon: React.ReactElement<any>;
+}
+export interface AddonProps extends AddonCommonProps {
+    onClick?: (actions: AddonActions) => void;
+    children?: React.ReactElement<any>[];
+}
+export interface AddonConfiguration extends AddonCommonProps {
+    text: string;
+}

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

@@ -0,0 +1,17 @@
+import React from 'react';
+import { PureComponent } from 'react';
+import { AlignmentState } from '../../../plugins/alignment/pm-plugins/types';
+import { Keymap } from '../../../keymaps';
+export interface Props {
+    value: AlignmentState;
+    label: string;
+    isSelected?: boolean;
+    onClick: (value: AlignmentState, shouldClosePopup: boolean) => void;
+    content: React.ReactElement<any>;
+    shortcut?: Keymap;
+}
+declare class AlignmentButton extends PureComponent<Props> {
+    render(): JSX.Element;
+    onClick: (e: any) => void;
+}
+export default AlignmentButton;

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

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import { WrappedComponentProps } from 'react-intl-next';
+import { AlignmentState } from '../../plugins/alignment/pm-plugins/types';
+export interface Props {
+    selectedAlignment?: string;
+    onClick: (value: AlignmentState) => void;
+    className?: string;
+}
+declare const _default: import("react").FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: import("react").ComponentType<Props & WrappedComponentProps<"intl">>;
+};
+export default _default;

package/dist/types-ts4.5/ui/Alignment/messages.d.ts

@@ -0,0 +1,17 @@
+export declare const alignmentMessages: {
+    alignLeft: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    alignCenter: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    alignRight: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};

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

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

package/dist/types-ts4.5/ui/Appearance/Chromeless.d.ts

@@ -0,0 +1,11 @@
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+import { EditorAppearanceComponentProps } from '../../types';
+export default class Editor extends React.Component<EditorAppearanceComponentProps, any> {
+    static displayName: string;
+    private appearance;
+    private containerElement;
+    private renderChrome;
+    render(): jsx.JSX.Element;
+}

package/dist/types-ts4.5/ui/Appearance/Comment/Comment.d.ts

@@ -0,0 +1,7 @@
+/** @jsx jsx */
+import React from 'react';
+import { EditorAppearanceComponentProps } from '../../../types';
+import { WrappedComponentProps } from 'react-intl-next';
+export declare const CommentEditorWithIntl: React.FC<import("react-intl-next").WithIntlProps<EditorAppearanceComponentProps & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<EditorAppearanceComponentProps & WrappedComponentProps<"intl">>;
+};

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

@@ -0,0 +1,10 @@
+/** @jsx jsx */
+import React from 'react';
+import { UseStickyToolbarType } from '../../../types/editor-props';
+export declare const TableControlsPadding = 20;
+type MainToolbarProps = {
+    useStickyToolbar?: UseStickyToolbarType;
+};
+export declare const MainToolbar: React.FC<MainToolbarProps>;
+export declare const mainToolbarCustomComponentsSlotStyle: import("@emotion/react").SerializedStyles;
+export {};

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

@@ -0,0 +1 @@
+export { CommentEditorWithIntl as default } from './Comment';

package/dist/types-ts4.5/ui/Appearance/FullPage/FullPage.d.ts

@@ -0,0 +1,25 @@
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+import { EditorAppearanceComponentProps } from '../../../types';
+import { FeatureFlags } from '@atlaskit/editor-common/types';
+interface FullPageEditorState {
+    showKeyline: boolean;
+}
+export declare class FullPageEditor extends React.Component<EditorAppearanceComponentProps, FullPageEditorState> {
+    state: FullPageEditorState;
+    featureFlags: FeatureFlags;
+    static displayName: string;
+    private scrollContainer;
+    private contentArea;
+    private wrapperElementRef;
+    constructor(props: any);
+    private contentAreaRef;
+    private scrollContainerRef;
+    private updateToolbarKeyline;
+    private handleResize;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    render(): jsx.JSX.Element;
+}
+export {};

package/dist/types-ts4.5/ui/Appearance/FullPage/FullPageContentArea.d.ts

@@ -0,0 +1,34 @@
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import { EditorView } from 'prosemirror-view';
+import React, { ReactElement } from 'react';
+import { WrappedComponentProps } from 'react-intl-next';
+import EditorActions from '../../../actions';
+import { EventDispatcher } from '../../../event-dispatcher';
+import { ReactComponents, EditorAppearance, UIComponentFactory } from '../../../types';
+import { DispatchAnalyticsEvent } from '../../../plugins/analytics';
+interface FullPageEditorContentAreaProps {
+    appearance: EditorAppearance | undefined;
+    contentArea: HTMLElement | undefined;
+    contentComponents: UIComponentFactory[] | undefined;
+    contextPanel: ReactComponents | undefined;
+    customContentComponents: ReactComponents | undefined;
+    disabled: boolean | undefined;
+    dispatchAnalyticsEvent: DispatchAnalyticsEvent | undefined;
+    editorActions: EditorActions | undefined;
+    editorDOMElement: ReactElement;
+    editorView: EditorView;
+    eventDispatcher: EventDispatcher | undefined;
+    popupsMountPoint: HTMLElement | undefined;
+    popupsBoundariesElement: HTMLElement | undefined;
+    popupsScrollableElement: HTMLElement | undefined;
+    providerFactory: ProviderFactory;
+    scrollContainer: HTMLElement | null;
+    contentAreaRef(ref: HTMLElement | null): void;
+    scrollContainerRef(ref: HTMLElement | null): void;
+    wrapperElement: HTMLElement | null;
+}
+export declare const CONTENT_AREA_TEST_ID = "ak-editor-fp-content-area";
+export declare const FullPageContentArea: React.FC<import("react-intl-next").WithIntlProps<FullPageEditorContentAreaProps & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<FullPageEditorContentAreaProps & WrappedComponentProps<"intl">>;
+};
+export {};

package/dist/types-ts4.5/ui/Appearance/FullPage/FullPageToolbar.d.ts

@@ -0,0 +1,36 @@
+/** @jsx jsx */
+import React, { ReactElement } from 'react';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import { EditorView } from 'prosemirror-view';
+import { WrappedComponentProps } from 'react-intl-next';
+import { EditorAppearance, ToolbarUIComponentFactory, PrimaryToolbarComponents } from '../../../types';
+import { CollabEditOptions } from '../../../plugins/collab-edit';
+import { DispatchAnalyticsEvent } from '../../../plugins/analytics';
+import { EventDispatcher } from '../../../event-dispatcher';
+import { EditorActions } from '../../..';
+import { FeatureFlags } from '../../../types/feature-flags';
+export interface FullPageToolbarProps {
+    appearance?: EditorAppearance;
+    providerFactory: ProviderFactory;
+    editorActions?: EditorActions;
+    editorDOMElement: JSX.Element;
+    editorView: EditorView;
+    eventDispatcher: EventDispatcher;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    primaryToolbarComponents?: ToolbarUIComponentFactory[];
+    customPrimaryToolbarComponents?: PrimaryToolbarComponents;
+    popupsMountPoint?: HTMLElement;
+    popupsBoundariesElement?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    disabled: boolean;
+    collabEdit?: CollabEditOptions;
+    showKeyline: boolean;
+    containerElement: HTMLElement | null;
+    beforeIcon?: ReactElement;
+    hasMinWidth?: boolean;
+    featureFlags?: FeatureFlags;
+}
+export declare const EditorToolbar: React.FunctionComponent<FullPageToolbarProps & WrappedComponentProps>;
+export declare const FullPageToolbar: React.FC<import("react-intl-next").WithIntlProps<FullPageToolbarProps & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<FullPageToolbarProps & WrappedComponentProps<"intl">>;
+};

package/dist/types-ts4.5/ui/Appearance/FullPage/MainToolbar.d.ts

@@ -0,0 +1,7 @@
+export declare const MAXIMUM_TWO_LINE_TOOLBAR_BREAKPOINT = 868;
+export declare const mainToolbarStyle: (showKeyline: boolean, twoLineEditorToolbar: boolean) => (false | import("@emotion/react").SerializedStyles)[];
+export declare const mainToolbarIconBeforeStyle: import("@emotion/react").SerializedStyles;
+export declare const mainToolbarFirstChildStyle: (twoLineEditorToolbar: boolean) => (false | import("@emotion/react").SerializedStyles)[];
+export declare const mainToolbarSecondChildStyle: (twoLineEditorToolbar: boolean) => (false | import("@emotion/react").SerializedStyles)[];
+export declare const nonCustomToolbarWrapperStyle: import("@emotion/react").SerializedStyles;
+export declare const customToolbarWrapperStyle: import("@emotion/react").SerializedStyles;