@atlaskit/editor-core 188.6.0 → 188.7.3

package/dist/types-ts4.5/types/editor-props.d.ts

@@ -0,0 +1,262 @@
+import type { ReactElement } from 'react';
+import type { Node, Schema } from '@atlaskit/editor-prosemirror/model';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { ActivityProvider } from '@atlaskit/activity-provider';
+import type { CardOptions } from '@atlaskit/editor-common/card';
+import type { ExtensionHandlers, ExtensionProvider } from '@atlaskit/editor-common/extensions';
+import type { EditorPresetBuilder } from '@atlaskit/editor-common/preset';
+import type { ContextIdentifierProvider, Providers, SearchProvider } from '@atlaskit/editor-common/provider-factory';
+import type { AllEditorPresetPluginTypes, Transformer, LinkingOptions, TextFormattingOptions, QuickInsertOptions } from '@atlaskit/editor-common/types';
+import type { ErrorReportingHandler } from '@atlaskit/editor-common/utils';
+import type { PluginConfig as TablesPluginConfig } from '@atlaskit/editor-plugin-table/types';
+import type { MentionProvider } from '@atlaskit/mention/resource';
+import type { TaskDecisionProvider } from '@atlaskit/task-decision';
+import type EditorActions from '../actions';
+import type { AnnotationProviders } from '../plugins/annotation/types';
+import type { BlockTypePluginOptions } from '@atlaskit/editor-plugin-block-type';
+import type { CodeBlockOptions } from '../plugins/code-block/types';
+import type { CollabEditOptions } from '@atlaskit/editor-common/collab';
+import type { DatePluginConfig } from '../plugins/date';
+import type { FindReplaceOptions } from '../plugins/find-replace/types';
+import type { LayoutPluginOptions } from '../plugins/layout/types';
+import type { MediaOptions, MediaState } from '@atlaskit/editor-plugin-media/types';
+import type { MentionPluginConfig } from '../plugins/mentions/types';
+import type { PanelPluginConfig } from '../plugins/panel/types';
+import type { PlaceholderTextOptions } from '../plugins/placeholder-text/types';
+import type { TextColorPluginConfig } from '../plugins/text-color/pm-plugins/main';
+import type { MenuItem } from '@atlaskit/editor-common/ui-menu';
+import type { EditorAppearance } from './editor-appearance';
+import type { EditorOnChangeHandler } from './editor-onchange';
+import type { EditorPlugin } from './editor-plugin';
+import type { EmptyStateHandler } from './empty-state-handler';
+import type { ExtensionConfig } from './extension-config';
+import type { PerformanceTracking } from './performance-tracking';
+import type { UseStickyToolbarType } from '@atlaskit/editor-common/ui';
+export type { UseStickyToolbarType };
+export type ReactComponents = ReactElement<any> | ReactElement<any>[];
+type ExtensionProviders = (ExtensionProvider | Promise<ExtensionProvider>)[];
+type ExtensionProvidersWithEditorAction = (editorActions?: EditorActions) => ExtensionProviders;
+export type ExtensionProvidersProp = ExtensionProviders | ExtensionProvidersWithEditorAction;
+export type FeedbackInfo = {
+    product?: string;
+    packageVersion?: string;
+    packageName?: string;
+    labels?: Array<string>;
+    sessionId?: string;
+    contentId?: string;
+    tabId?: string;
+};
+export type BeforeAndAfterToolbarComponents = {
+    before: ReactComponents;
+    after: ReactComponents;
+};
+export type PrimaryToolbarComponents = BeforeAndAfterToolbarComponents | ReactComponents;
+interface EditorBaseProps {
+    appearance?: EditorAppearance;
+    contentComponents?: ReactComponents;
+    primaryToolbarIconBefore?: ReactElement;
+    secondaryToolbarComponents?: ReactComponents;
+    persistScrollGutter?: boolean;
+    quickInsert?: QuickInsertOptions;
+    shouldFocus?: boolean;
+    disabled?: boolean;
+    contextPanel?: ReactComponents;
+    errorReporterHandler?: ErrorReportingHandler;
+    contentTransformerProvider?: (schema: Schema) => Transformer<string>;
+    maxHeight?: number;
+    minHeight?: number;
+    placeholder?: string;
+    placeholderBracketHint?: string;
+    defaultValue?: Node | string | Object;
+    assistiveLabel?: string;
+    popupsMountPoint?: HTMLElement;
+    popupsBoundariesElement?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    editorActions?: EditorActions;
+    onEditorReady?: (editorActions: EditorActions) => void;
+    onDestroy?: () => void;
+    onChange?: EditorOnChangeHandler;
+    onCancel?: (editorView: EditorView) => void;
+    /**
+     * @description The nth keystroke after which an input time taken event is sent, 0 to disable it
+     * @default 100
+     * @deprecated Use performanceTracking.inputSampling instead https://product-fabric.atlassian.net/browse/ED-10260
+     */
+    inputSamplingLimit?: number;
+    extensionProviders?: ExtensionProvidersProp;
+    UNSAFE_useAnalyticsContext?: boolean;
+    /**
+     * @default undefined
+     * @description Enables valid transaction events to be tracked in analytics (at a sampled rate)
+     */
+    trackValidTransactions?: {
+        samplingRate: number;
+    } | boolean;
+    /**
+     * @default undefined
+     * @description
+     * Enables the sticky toolbar in the comment/standard editor.
+     * If a boolean is specified and it's `true`, the sticky toolbar will be enabled, sticking to the top of the scroll parent.
+     * Instead a reference can be specified to an existing sticky toolbar on the page that the editor toolbar should stay below (experimental).
+     * if {offsetTop: number} is passed in, the toolbar is sticky and the toolbar's 'top' will be set to the offsetTop
+     * so the toolbar will sticks to `{offsetTop}` below the scroll parent.
+     */
+    useStickyToolbar?: UseStickyToolbarType;
+    /**
+     * @default undefined
+     * @description
+     * Short lived feature flags for experiments and gradual rollouts
+     * Flags are expected to follow these rules or they are filtered out
+     *
+     * 1. cased in kebab-case (match [a-z-])
+     * 2. have boolean values
+     *
+     * @example
+     * ```tsx
+     * (<Editor featureFlags={{ 'my-feature': true }} />);
+     * getFeatureFlags()?.myFeature === true;
+     * ```
+     *
+     * @example
+     * ```tsx
+     * (<Editor featureFlags={{ 'my-feature': 'thing' }} />);
+     * getFeatureFlags()?.myFeature === undefined;
+     * ```
+     *
+     * @example
+     * ```tsx
+     * (<Editor featureFlags={{ 'product.my-feature': false }} />);
+     * getFeatureFlags()?.myFeature === undefined;
+     * getFeatureFlags()?.productMyFeature === undefined;
+     * ```
+     */
+    featureFlags?: {
+        [featureFlag: string]: string | boolean;
+    };
+}
+export interface EditorSharedPropsWithPlugins {
+    onSave?: (editorView: EditorView) => void;
+    /**
+     * @description Control performance metric measurements and tracking
+     */
+    performanceTracking?: PerformanceTracking;
+    sanitizePrivateContent?: boolean;
+    media?: MediaOptions;
+    collabEdit?: CollabEditOptions;
+    primaryToolbarComponents?: PrimaryToolbarComponents;
+    allowUndoRedoButtons?: boolean;
+    /**
+     *  Configure and extend editor linking behaviour
+     */
+    linking?: LinkingOptions;
+}
+export interface EditorProps extends EditorBaseProps, EditorPluginFeatureProps, EditorSharedPropsWithPlugins, EditorProviderProps {
+    /**
+     * @deprecated Do not use outside of Editor team.
+     * This has subtle side effects - you __WILL__ break functionality without implementer knowledge of editor-core internals
+     */
+    dangerouslyAppendPlugins?: {
+        /**
+         * @deprecated Do not use outside of Editor team.
+         */
+        __plugins: EditorPlugin[];
+    };
+}
+export interface EditorNextProps extends EditorBaseProps, EditorSharedPropsWithPlugins, EditorProviderProps {
+    preset: EditorPresetBuilder<string[], AllEditorPresetPluginTypes[]>;
+}
+export interface EditorProviderProps {
+    activityProvider?: Promise<ActivityProvider>;
+    searchProvider?: Promise<SearchProvider>;
+    annotationProviders?: AnnotationProviders;
+    collabEditProvider?: Providers['collabEditProvider'];
+    presenceProvider?: Promise<any>;
+    emojiProvider?: Providers['emojiProvider'];
+    taskDecisionProvider?: Promise<TaskDecisionProvider>;
+    legacyImageUploadProvider?: Providers['imageUploadProvider'];
+    mentionProvider?: Promise<MentionProvider>;
+    autoformattingProvider?: Providers['autoformattingProvider'];
+    macroProvider?: Providers['macroProvider'];
+    contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
+}
+export interface EditorPluginFeatureProps {
+    allowExpand?: boolean | {
+        allowInsertion?: boolean;
+        allowInteractiveExpand?: boolean;
+    };
+    allowNestedTasks?: boolean;
+    allowBlockType?: BlockTypePluginOptions['allowBlockType'];
+    allowTasksAndDecisions?: boolean;
+    allowBreakout?: boolean;
+    allowRule?: boolean;
+    allowHelpDialog?: boolean;
+    allowJiraIssue?: boolean;
+    allowPanel?: boolean | PanelPluginConfig;
+    allowExtension?: boolean | ExtensionConfig;
+    allowConfluenceInlineComment?: boolean;
+    allowTemplatePlaceholders?: boolean | PlaceholderTextOptions;
+    allowDate?: boolean | DatePluginConfig;
+    allowLayouts?: boolean | LayoutPluginOptions;
+    allowStatus?: boolean | {
+        menuDisabled: boolean;
+    };
+    allowTextAlignment?: boolean;
+    allowIndentation?: boolean;
+    showIndentationButtons?: boolean;
+    /**
+     * This enables new insertion behaviour only for horizontal rule and media single in certain conditions.
+     * The idea of this new behaviour is to have a consistent outcome regardless of the insertion method.
+     **/
+    allowNewInsertionBehaviour?: boolean;
+    allowFindReplace?: boolean | FindReplaceOptions;
+    /**
+     * Enable experimental support for the "border" mark.
+     * Refer to ADF Change proposal #65 for more details.
+     * @deprecated Use allowBorderMark instead.
+     */
+    UNSAFE_allowBorderMark?: boolean;
+    /**
+     * Enable support for the "border" mark.
+     * Refer to ADF Change proposal #65 for more details.
+     */
+    allowBorderMark?: boolean;
+    /**
+     * Enable support for the "fragment" mark.
+     * Refer to ADF Change proposal #60 for more details.
+     */
+    allowFragmentMark?: boolean;
+    /**
+     * Set this to false to opt out of the default behaviour of auto scrolling into view
+     * whenever the document is changed
+     */
+    autoScrollIntoView?: boolean;
+    elementBrowser?: {
+        showModal?: boolean;
+        replacePlusMenu?: boolean;
+        helpUrl?: string;
+        emptyStateHandler?: EmptyStateHandler;
+    };
+    maxContentSize?: number;
+    saveOnEnter?: boolean;
+    feedbackInfo?: FeedbackInfo;
+    mention?: MentionPluginConfig;
+    /**
+     * flag to indicate display name instead of nick name should be inserted for mentions
+     * default: false, which inserts the nick name
+     * @deprecated Use mention.mentionInsertDisplayName instead
+     */
+    mentionInsertDisplayName?: boolean;
+    uploadErrorHandler?: (state: MediaState) => void;
+    waitForMediaUpload?: boolean;
+    extensionHandlers?: ExtensionHandlers;
+    allowTextColor?: boolean | TextColorPluginConfig;
+    allowTables?: boolean | TablesPluginConfig;
+    insertMenuItems?: MenuItem[];
+    /** @deprecated Use linking.smartLinks prop instead. */
+    UNSAFE_cards?: CardOptions;
+    /** @deprecated Use linking.smartLinks prop instead. */
+    smartLinks?: CardOptions;
+    allowAnalyticsGASV3?: boolean;
+    codeBlock?: CodeBlockOptions;
+    textFormatting?: TextFormattingOptions;
+}

package/dist/types-ts4.5/types/editor-react-context.d.ts

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

package/dist/types-ts4.5/types/empty-state-handler.d.ts

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

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

@@ -0,0 +1,5 @@
+export interface ExtensionConfig {
+    allowBreakout?: boolean;
+    allowAutoSave?: boolean;
+    allowExtendFloatingToolbars?: boolean;
+}

package/dist/types-ts4.5/types/feature-flags.d.ts

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

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

@@ -0,0 +1,5 @@
+export interface MessageDescriptor {
+    id: string;
+    description: string;
+    defaultMessage: string;
+}

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

@@ -0,0 +1,18 @@
+export type { AllowedBlockTypes } from '@atlaskit/editor-common/types';
+export type { EditorInstance } from './editor-instance';
+export type { EditorConfig } from './editor-config';
+export type { NextEditorPlugin, EditorPlugin, PluginsOptions, } from './editor-plugin';
+export type { EditorReactContext } from './editor-react-context';
+export type { EditorProps, FeedbackInfo, ReactComponents, ExtensionProvidersProp, PrimaryToolbarComponents, } from './editor-props';
+export type { EditorAppearanceComponentProps } from './editor-appearance-component';
+export type { Command, CommandDispatch } from './command';
+export type { MessageDescriptor } from './i18n';
+export type { DomAtPos } from './dom-at-pos';
+export type { ExtensionConfig } from './extension-config';
+export type { EditorAppearance } from './editor-appearance';
+export type { ToolbarUIComponentFactory, ToolbarUiComponentFactoryParams, } from '../ui/Toolbar/types';
+export type { PMPlugin, PMPluginFactory, PMPluginFactoryParams, } from './pm-plugin';
+export type { PMPluginCreateConfig } from './pm-plugin-list';
+export type { NodeViewConfig, MarkConfig, NodeConfig } from './pm-config';
+export type { UIComponentFactory, UiComponentFactoryParams, } from './ui-components';
+export type { DisableSpellcheckByBrowser, Range, Browsers } from './browser';

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

@@ -0,0 +1 @@
+export type { TTITracking, TransactionTracking, UITracking, CatchAllTracking, NodeViewTracking, BrowserFreezetracking, ProseMirrorRenderedTracking, InputTracking, ContentRetrievalTracking, OnChangeCallbackTracking, OnEditorReadyCallbackTracking, PasteTracking, RenderTracking, PerformanceTracking, } from '@atlaskit/editor-common/types';

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 type { EditorView } from '@atlaskit/editor-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 type { EditorView } from '@atlaskit/editor-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 type { EditorView } from '@atlaskit/editor-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 type { EditorView } from '@atlaskit/editor-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, 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 type { WrappedComponentProps } from 'react-intl-next';
+import type { 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/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 type { EditorAppearanceComponentProps } from '../../../types';
+import type { 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,9 @@
+import React from 'react';
+import type { UseStickyToolbarType } from '@atlaskit/editor-common/ui';
+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,3 @@
+import { jsx } from '@emotion/react';
+import { EditorAppearanceComponentProps } from '../../../types';
+export declare const FullPageEditor: (props: EditorAppearanceComponentProps) => jsx.JSX.Element;

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

@@ -0,0 +1,39 @@
+import type { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { ReactElement } from 'react';
+import React from 'react';
+import type { WrappedComponentProps } from 'react-intl-next';
+import type EditorActions from '../../../actions';
+import type { EventDispatcher } from '../../../event-dispatcher';
+import type { ReactComponents, EditorAppearance, UIComponentFactory } from '../../../types';
+import type { DispatchAnalyticsEvent } from '@atlaskit/editor-common/analytics';
+import type { ReactHookFactory } from '@atlaskit/editor-common/types';
+import type { FeatureFlags } from '../../../types/feature-flags';
+interface FullPageEditorContentAreaProps {
+    appearance: EditorAppearance | undefined;
+    contentComponents: UIComponentFactory[] | undefined;
+    pluginHooks: ReactHookFactory[] | 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;
+    wrapperElement: HTMLElement | null;
+    featureFlags?: FeatureFlags;
+}
+export declare const CONTENT_AREA_TEST_ID = "ak-editor-fp-content-area";
+type ScrollContainerRefs = {
+    scrollContainer: HTMLDivElement | null;
+    contentArea: HTMLDivElement | null;
+};
+export declare const FullPageContentArea: React.ForwardRefExoticComponent<Pick<import("react-intl-next").WithIntlProps<React.PropsWithChildren<FullPageEditorContentAreaProps & WrappedComponentProps<"intl"> & React.RefAttributes<ScrollContainerRefs>>>, "key" | "children" | "forwardedRef" | keyof FullPageEditorContentAreaProps> & React.RefAttributes<any>> & {
+    WrappedComponent: React.ComponentType<FullPageEditorContentAreaProps & WrappedComponentProps<"intl"> & React.RefAttributes<ScrollContainerRefs>>;
+};
+export {};

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

@@ -0,0 +1,38 @@
+/** @jsx jsx */
+import type { ReactElement } from 'react';
+import React from 'react';
+import { jsx } from '@emotion/react';
+import type { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { WrappedComponentProps } from 'react-intl-next';
+import type { EditorAppearance, ToolbarUIComponentFactory, PrimaryToolbarComponents } from '../../../types';
+import type { CollabEditOptions } from '@atlaskit/editor-common/collab';
+import type { DispatchAnalyticsEvent } from '../../../plugins/analytics';
+import type { EventDispatcher } from '../../../event-dispatcher';
+import type { EditorActions } from '../../..';
+import type { 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.MemoExoticComponent<(props: FullPageToolbarProps & WrappedComponentProps) => jsx.JSX.Element>;
+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;