@atlaskit/editor-common 76.9.1 → 76.9.2

package/dist/types-ts4.5/styles/shared/resizer.d.ts

@@ -0,0 +1,9 @@
+export declare const resizerItemClassName = "resizer-item";
+export declare const resizerHoverZoneClassName = "resizer-hover-zone";
+export declare const resizerHandleClassName = "resizer-handle";
+export declare const resizerHandleTrackClassName: string;
+export declare const resizerHandleThumbClassName: string;
+export declare const resizerDangerClassName: string;
+export declare const handleWrapperClass = "resizer-handle-wrapper";
+export declare const resizerHandleZIndex = 1;
+export declare const resizerStyles: import("@emotion/react").SerializedStyles;

package/dist/types-ts4.5/styles/shared/rule.d.ts

@@ -0,0 +1,2 @@
+import { ThemeProps } from '@atlaskit/theme/types';
+export declare const ruleSharedStyles: (props: ThemeProps) => import("@emotion/react").SerializedStyles;

package/dist/types-ts4.5/styles/shared/shadow.d.ts

@@ -0,0 +1,15 @@
+/**
+ * TODO: This is close to working and removes a tone of JS from OverflowShadow component
+ *
+ *  background: linear-gradient(to right, white 30%, rgba(255, 255, 255, 0)),
+ *         linear-gradient(to right, rgba(255, 255, 255, 0), white 70%) 100% 0,
+ *        linear-gradient(to right, rgba(0, 0, 0, 0.2), rgba(0, 0, 0, 0)),
+ *         linear-gradient(to right, rgba(0, 0, 0, 0), rgba(0, 0, 0, 0.2)) 100% 0;
+ *       background-repeat: no-repeat;
+ *       background-color: white;
+ *       background-size: 40px 100%, 40px 100%, 14px 100%, 14px 100%;
+ *
+ *      background-attachment: local, local, scroll, scroll;
+ */
+declare const shadowSharedStyle: import("@emotion/react").SerializedStyles;
+export { shadowSharedStyle };

package/dist/types-ts4.5/styles/shared/smart-card.d.ts

@@ -0,0 +1,8 @@
+export declare const SmartCardSharedCssClassName: {
+    INLINE_CARD_CONTAINER: string;
+    BLOCK_CARD_CONTAINER: string;
+    EMBED_CARD_CONTAINER: string;
+    DATASOURCE_CONTAINER: string;
+    LOADER_WRAPPER: string;
+};
+export declare const smartCardSharedStyles: string;

package/dist/types-ts4.5/styles/shared/smartCard.d.ts

@@ -0,0 +1,3 @@
+export declare const DATASOURCE_INNER_CONTAINER_CLASSNAME = "datasourceView-content-inner-wrap";
+export declare const FLOATING_TOOLBAR_LINKPICKER_CLASSNAME = "card-floating-toolbar--link-picker";
+export declare const smartCardStyles: import("@emotion/react").SerializedStyles;

package/dist/types-ts4.5/styles/shared/status.d.ts

@@ -0,0 +1,4 @@
+export declare const StatusSharedCssClassName: {
+    STATUS_CONTAINER: string;
+    STATUS_LOZENGE: string;
+};

package/dist/types-ts4.5/styles/shared/table.d.ts

@@ -0,0 +1,35 @@
+import type { TableLayout } from '@atlaskit/adf-schema';
+import type { ThemeProps } from '@atlaskit/theme/types';
+export declare const tableMarginTop = 24;
+export declare const tableMarginBottom = 16;
+export declare const tableMarginTopWithControl = 14;
+export declare const tableMarginSides = 8;
+export declare const tableCellMinWidth = 48;
+export declare const tableNewColumnMinWidth = 140;
+export declare const tableCellBorderWidth = 1;
+export declare const tableCellPadding = 8;
+export declare const tableResizeHandleWidth = 6;
+export declare const TableSharedCssClassName: {
+    TABLE_CONTAINER: string;
+    TABLE_NODE_WRAPPER: string;
+    TABLE_LEFT_SHADOW: string;
+    TABLE_RIGHT_SHADOW: string;
+    TABLE_STICKY_SHADOW: string;
+    TABLE_STICKY_WRAPPER: string;
+    TABLE_STICKY_SCROLLBAR_CONTAINER: string;
+    TABLE_STICKY_SENTINEL_TOP: string;
+    TABLE_STICKY_SENTINEL_BOTTOM: string;
+    TABLE_STICKY_SCROLLBAR_SENTINEL_TOP: string;
+    TABLE_STICKY_SCROLLBAR_SENTINEL_BOTTOM: string;
+    TABLE_SHADOW_SENTINEL_LEFT: string;
+    TABLE_SHADOW_SENTINEL_RIGHT: string;
+    TABLE_CELL_NODEVIEW_CONTENT_DOM: string;
+    TABLE_CELL_WRAPPER: string;
+    TABLE_HEADER_CELL_WRAPPER: string;
+    TABLE_ROW_CONTROLS_WRAPPER: string;
+    TABLE_COLUMN_CONTROLS_DECORATIONS: string;
+    TABLE_RESIZER_CONTAINER: string;
+};
+declare const tableSharedStyle: (props: ThemeProps) => import("@emotion/react").SerializedStyles;
+export declare const calcTableWidth: (layout: TableLayout, containerWidth?: number, addControllerPadding?: boolean) => number | 'inherit';
+export { tableSharedStyle };

package/dist/types-ts4.5/styles/shared/tableCell.d.ts

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

package/dist/types-ts4.5/styles/shared/task-decision.d.ts

@@ -0,0 +1,6 @@
+export declare const TaskDecisionSharedCssClassName: {
+    DECISION_CONTAINER: string;
+    TASK_CONTAINER: string;
+    TASK_ITEM: string;
+};
+export declare const tasksAndDecisionsStyles: import("@emotion/react").SerializedStyles;

package/dist/types-ts4.5/styles/shared/text-color.d.ts

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

package/dist/types-ts4.5/styles/shared/unsupported-content.d.ts

@@ -0,0 +1,5 @@
+export declare const UnsupportedSharedCssClassName: {
+    BLOCK_CONTAINER: string;
+    INLINE_CONTAINER: string;
+};
+export declare const unsupportedStyles: import("@emotion/react").SerializedStyles;

package/dist/types-ts4.5/styles/shared/whitespace.d.ts

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

package/dist/types-ts4.5/transforms/expand.d.ts

@@ -0,0 +1,5 @@
+import { Schema, Slice } from '@atlaskit/editor-prosemirror/model';
+import type { EditorState, Selection } from '@atlaskit/editor-prosemirror/state';
+export declare const findExpand: (state: EditorState, selection?: Selection | null) => import("prosemirror-utils/dist/types").FindResult;
+export declare const transformSliceToRemoveOpenExpand: (slice: Slice, schema: Schema) => Slice;
+export declare const transformSliceNestedExpandToExpand: (slice: Slice, schema: Schema) => Slice;

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

@@ -0,0 +1,6 @@
+import { Schema, Slice } from '@atlaskit/editor-prosemirror/model';
+/**
+ * Lift content out of "open" top-level bodiedExtensions.
+ * Will not work if bodiedExtensions are nested, or when bodiedExtensions are not in the top level
+ */
+export declare const transformSliceToRemoveOpenBodiedExtension: (slice: Slice, schema: Schema) => Slice;

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

@@ -0,0 +1,3 @@
+export { unwrapContentFromLayout, removeLayoutFromFirstChild, removeLayoutFromLastChild, transformSliceToRemoveOpenLayoutNodes, } from './layout';
+export { findExpand, transformSliceToRemoveOpenExpand, transformSliceNestedExpandToExpand, } from './expand';
+export { transformSliceToRemoveOpenBodiedExtension } from './extension';

package/dist/types-ts4.5/transforms/layout.d.ts

@@ -0,0 +1,15 @@
+import { Fragment, Node, Schema, Slice } from '@atlaskit/editor-prosemirror/model';
+export declare function unwrapContentFromLayout(maybeLayoutSection: Node): Node | Node[];
+export declare function removeLayoutFromFirstChild(node: Node, i: number): Node | Node[];
+export declare function removeLayoutFromLastChild(node: Node, i: number, fragment: Fragment): Node | Node[];
+/**
+ * When we have a slice that cuts across a layoutSection/layoutColumn
+ * we can end up with unexpected behaviour on paste/drop where a user
+ * is able to add columns to a layoutSection. By 'lifting' any content
+ * inside an 'open' layoutSection/layoutColumn to the top level, we
+ * can ensure prevent this.
+ *
+ * We only care about slices with non-zero openStart / openEnd's here
+ * as we're totally fine for people to copy/paste a full layoutSection
+ */
+export declare function transformSliceToRemoveOpenLayoutNodes(slice: Slice, schema: Schema): Slice;

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

@@ -0,0 +1,12 @@
+export declare enum TypeAheadAvailableNodes {
+    EMOJI = "emojiTypeAhead",
+    MENTION = "mentionTypeAhead",
+    QUICK_INSERT = "quickInsertTypeAhead"
+}
+export declare enum SelectItemMode {
+    SHIFT_ENTER = "shift-enter",
+    ENTER = "enter",
+    SPACE = "space",
+    SELECTED = "selected",
+    TAB = "tab"
+}

package/dist/types-ts4.5/types/annotation/emitter.d.ts

@@ -0,0 +1,33 @@
+import { AnnotationId, AnnotationMarkStates, AnnotationTypes } from '@atlaskit/adf-schema';
+export interface AnnotationState<Type> {
+    annotationType: Type;
+    id: AnnotationId;
+    state: AnnotationMarkStates | null;
+}
+export declare enum AnnotationUpdateEvent {
+    SET_ANNOTATION_FOCUS = "SET_ANNOTATION_FOCUS",
+    SET_ANNOTATION_STATE = "SET_ANNOTATION_STATE",
+    REMOVE_ANNOTATION_FOCUS = "REMOVE_ANNOTATION_FOCUS",
+    ON_ANNOTATION_CLICK = "ON_ANNOTATION_CLICK"
+}
+type SetFocusPayload = Record<'annotationId', AnnotationId>;
+export type OnAnnotationClickPayload = {
+    annotationIds: Array<AnnotationId>;
+    eventTarget: HTMLElement;
+};
+type SetStatePayload = Record<AnnotationId, AnnotationState<AnnotationTypes.INLINE_COMMENT>>;
+export type AnnotationUpdateEventPayloads = {
+    [AnnotationUpdateEvent.ON_ANNOTATION_CLICK]: OnAnnotationClickPayload;
+    [AnnotationUpdateEvent.SET_ANNOTATION_FOCUS]: SetFocusPayload;
+    [AnnotationUpdateEvent.SET_ANNOTATION_STATE]: SetStatePayload;
+};
+type Callback<T> = T extends keyof AnnotationUpdateEventPayloads ? (payload: AnnotationUpdateEventPayloads[T]) => void : () => void;
+export declare class AnnotationUpdateEmitter {
+    private emitter;
+    emit<T extends keyof AnnotationUpdateEventPayloads>(event: T, params: AnnotationUpdateEventPayloads[T]): boolean;
+    emit<T extends AnnotationUpdateEvent>(event: T): boolean;
+    on<T extends AnnotationUpdateEvent>(event: T, listener: Callback<T>): void;
+    off<T extends AnnotationUpdateEvent>(event: T, listener: Callback<T>): void;
+    listeners(event: AnnotationUpdateEvent): Function[];
+}
+export {};

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

@@ -0,0 +1,85 @@
+/// <reference types="react" />
+import type { AnnotationId, AnnotationTypes } from '@atlaskit/adf-schema';
+import type { JSONDocNode } from '@atlaskit/editor-json-transformer';
+import type { Step } from '@atlaskit/editor-prosemirror/transform';
+import type { AnnotationState, AnnotationUpdateEventPayloads, OnAnnotationClickPayload } from './emitter';
+import { AnnotationUpdateEmitter, AnnotationUpdateEvent } from './emitter';
+export type { AnnotationState };
+export type AnnotationByMatches = {
+    originalSelection: string;
+    numMatches: number;
+    matchIndex: number;
+    isAnnotationAllowed?: boolean;
+};
+type ActionResult = {
+    step: Step;
+    doc: JSONDocNode;
+} | false;
+export type AnnotationActionResult = ({
+    step: Step;
+    doc: JSONDocNode;
+} & AnnotationByMatches) | false;
+export type InlineCommentSelectionComponentProps = {
+    /**
+     * Range selected
+     */
+    range: Range;
+    /**
+     * Renderer/Editor DOM element ancestors wrapping the selection
+     */
+    wrapperDOM: HTMLElement;
+    /**
+     * If it is possible to add an inline comment on this range
+     */
+    isAnnotationAllowed: boolean;
+    /**
+     * Creates an annotation mark in the document with the given id.
+     */
+    onCreate: (annotationId: AnnotationId) => AnnotationActionResult;
+    /**
+     * Indicates that a draft comment was discarded/cancelled
+     */
+    onClose: () => void;
+    /**
+     * Call this function to surround the range with a HTML tag.
+     */
+    applyDraftMode: (keepNativeSelection?: boolean) => void;
+    /**
+     * Call this function to remove the draft HTML tags created by the applyDraftMode
+     */
+    removeDraftMode: () => void;
+    /**
+     * getAnnotationIndexMatch finds the { numMatch, matchIndex } tuple of the current selection
+     */
+    getAnnotationIndexMatch?: () => AnnotationByMatches | false;
+};
+type AnnotationInfo = {
+    id: AnnotationId;
+    type: AnnotationTypes.INLINE_COMMENT;
+};
+export type InlineCommentViewComponentProps = {
+    /**
+     * Existing annotations where the cursor is placed.
+     * These are provided in order, inner-most first.
+     */
+    annotations: Array<AnnotationInfo>;
+    /**
+     * eventTarget of the tapped annotation. Useful for UI positioning.
+     */
+    clickElementTarget?: HTMLElement;
+    deleteAnnotation: (annotationInfo: AnnotationInfo) => ActionResult;
+};
+interface AnnotationTypeProvider<Type> {
+    getState: (annotationIds: string[]) => Promise<AnnotationState<Type>[]>;
+    updateSubscriber?: AnnotationUpdateEmitter;
+    allowDraftMode?: boolean;
+}
+export type InlineCommentAnnotationProvider = AnnotationTypeProvider<AnnotationTypes.INLINE_COMMENT> & {
+    selectionComponent?: React.ComponentType<InlineCommentSelectionComponentProps>;
+    viewComponent?: React.ComponentType<InlineCommentViewComponentProps>;
+};
+export type AnnotationProviders = {
+    inlineComment: InlineCommentAnnotationProvider;
+};
+export { AnnotationUpdateEmitter, AnnotationUpdateEvent };
+export type { AnnotationUpdateEventPayloads, OnAnnotationClickPayload };

package/dist/types-ts4.5/types/block-type.d.ts

@@ -0,0 +1,4 @@
+export type HeadingLevels = 1 | 2 | 3 | 4 | 5 | 6;
+export type NormalTextLevel = 0;
+export type HeadingLevelsAndNormalText = HeadingLevels | NormalTextLevel;
+export type AllowedBlockTypes = 'heading' | 'blockquote' | 'hardBreak' | 'codeBlock';

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

@@ -0,0 +1 @@
+export type BreakoutMode = 'wide' | 'full-width' | 'center';

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

@@ -0,0 +1,6 @@
+import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+export type CommandDispatch = (tr: Transaction) => void;
+export type Command = (state: EditorState, dispatch?: CommandDispatch, view?: EditorView) => boolean;
+export type HigherOrderCommand = (command: Command) => Command;
+export type Predicate = (state: EditorState, view?: EditorView) => boolean;

package/dist/types-ts4.5/types/context-panel.d.ts

@@ -0,0 +1,3 @@
+import type React from 'react';
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+export type ContextPanelHandler = (state: EditorState) => React.ReactNode;

package/dist/types-ts4.5/types/copy-button.d.ts

@@ -0,0 +1,24 @@
+import type { IntlShape } from 'react-intl-next';
+import type { MarkType, NodeType } from '@atlaskit/editor-prosemirror/model';
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+import { Command } from './command';
+export type MarkOptions = {
+    state: EditorState;
+    formatMessage: IntlShape['formatMessage'];
+    nodeType?: undefined;
+    markType: MarkType;
+    onMouseEnter?: undefined;
+    onMouseLeave?: undefined;
+    onFocus?: Command;
+    onBlur?: Command;
+};
+export type NodeOptions = {
+    state: EditorState;
+    formatMessage: IntlShape['formatMessage'];
+    nodeType: NodeType | Array<NodeType>;
+    markType?: undefined;
+    onMouseEnter?: Command;
+    onMouseLeave?: Command;
+    onFocus?: Command;
+    onBlur?: Command;
+};

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

@@ -0,0 +1 @@
+export type DatasourceModalType = 'jira' | 'assets';

package/dist/types-ts4.5/types/doc-builder.d.ts

@@ -0,0 +1,26 @@
+import type { Schema } from '@atlaskit/editor-prosemirror/model';
+import type { Node } from '@atlaskit/editor-prosemirror/model';
+/**
+ * Represents a ProseMirror "position" in a document.
+ */
+type position = number;
+/**
+ * A useful feature of the builder is being able to declaratively mark positions
+ * in content using the curly braces e.g. `{<>}`.
+ *
+ * These positions are called "refs" (inspired by React), and are tracked on
+ * every node in the tree that has a ref on any of its descendants.
+ */
+export type Refs = {
+    [name: string]: position;
+};
+/**
+ * A standard ProseMirror Node that also tracks refs.
+ */
+export interface RefsNode extends Node {
+    refs: Refs;
+    ignoreContent?: boolean;
+    originalAttributes?: unknown;
+}
+export type DocBuilder = (schema: Schema) => RefsNode;
+export {};

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

@@ -0,0 +1,21 @@
+import type { JSONDocNode } from '@atlaskit/editor-json-transformer';
+import type { Node } from '@atlaskit/editor-prosemirror/model';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { ResolvedEditorState } from '../collab';
+import type { EventDispatcher } from '../event-dispatcher';
+export type ContextUpdateHandler = (editorView: EditorView, eventDispatcher: EventDispatcher) => void;
+export type ReplaceRawValue = Node | object | string;
+export interface EditorActionsOptions<T = any> {
+    focus(): boolean;
+    blur(): boolean;
+    clear(): boolean;
+    getValue(): Promise<T | JSONDocNode | undefined>;
+    getNodeByLocalId(id: string): Node | undefined;
+    getNodeByFragmentLocalId(id: string): Node | undefined;
+    getSelectedNode(): Node | undefined;
+    replaceDocument(rawValue: any): boolean;
+    replaceSelection(rawValue: ReplaceRawValue | Array<ReplaceRawValue>): boolean;
+    appendText(text: string): boolean;
+    isDocumentEmpty(): boolean;
+    getResolvedEditorState(): Promise<ResolvedEditorState | undefined>;
+}

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

@@ -0,0 +1 @@
+export type EditorAppearance = 'comment' | 'full-page' | 'full-width' | 'chromeless' | 'mobile';

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

@@ -0,0 +1,5 @@
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+export type EditorCommand = (props: {
+    tr: Transaction;
+}) => Transaction | null;
+export type EditorCommandWithMetadata = (...args: any) => EditorCommand;

package/dist/types-ts4.5/types/editor-container-width.d.ts

@@ -0,0 +1,19 @@
+export type EditorContainerWidth = {
+    /**
+     * Starts as offsetWidth of document body, and then
+     * updates to the editors content areas offsetWidth
+     * via the use of a contentComponent (via the
+     * container element prop).
+     */
+    width: number;
+    /**
+     * Starts as undefined, and then updates to the
+     * clientWidth of the dom element the EditorView
+     * is attached to.
+     *
+     * Then the WidthEmitter updates this whenever the
+     * context panel or editor widths change.
+     */
+    lineLength?: number;
+};
+export type GetEditorContainerWidth = () => EditorContainerWidth;

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

@@ -0,0 +1,92 @@
+import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { ContextPanelHandler } from './context-panel';
+import type { FloatingToolbarHandler } from './floating-toolbar';
+import type { PMPlugin } from './plugin-factory';
+import type { MarkConfig, NodeConfig } from './prosemirror-config';
+import type { QuickInsertHandler } from './quick-insert';
+import type { ToolbarUIComponentFactory } from './toolbar';
+import type { TypeAheadHandler } from './type-ahead';
+import type { ReactHookFactory, UIComponentFactory } from './ui-components';
+export type PluginsOptions = {
+    [pluginName: string]: any;
+    /**
+     * Handler returns an array of QuickInsertItem that are added to the Element Browser, Insert Menu and Quick Insert
+     */
+    quickInsert?: QuickInsertHandler;
+    typeAhead?: TypeAheadHandler;
+    /**
+     * See: `FloatingToolbarConfig`
+     */
+    floatingToolbar?: FloatingToolbarHandler;
+    /**
+     * Handler returning a React component that is added to the context panel.
+     *
+     * See https://product-fabric.atlassian.net/wiki/spaces/E/pages/1406016239/Context+Panel
+     */
+    contextPanel?: ContextPanelHandler;
+};
+type EditorViewStateUpdatedCallbackProps = {
+    readonly originalTransaction: Readonly<Transaction>;
+    readonly transactions: readonly Transaction[];
+    readonly oldEditorState: Readonly<EditorState>;
+    readonly newEditorState: Readonly<EditorState>;
+};
+export interface EditorPlugin {
+    /**
+     * Name of a plugin, that other plugins can use to provide options to it or exclude via a preset.
+     */
+    name: string;
+    /**
+     * Options that will be passed to a plugin with a corresponding name if it exists and enabled.
+     */
+    pluginsOptions?: PluginsOptions;
+    /**
+     * List of ProseMirror-plugins. This is where we define which plugins will be added to EditorView (main-plugin, keybindings, input-rules, etc.).
+     */
+    pmPlugins?: (pluginOptions?: any) => Array<PMPlugin>;
+    /**
+     * A list of `NodeConfig`s with a name and a `NodeSpec`. (`NodeSpec` is imported from @atlaskit/adf-schema)
+     *
+     */
+    nodes?: () => NodeConfig[];
+    /**
+     * A list of `MarkConfig`s with a name and a `MarkSpec` (`MarkSpec` is imported from @atlaskit/adf-schema)
+     */
+    marks?: () => MarkConfig[];
+    /**
+     * Optional UI-component that lives inside the actual content-area (like mention-picker, floating toolbar for links, etc.)
+     *
+     * Handler returns a React component that is added to the top of the editor content area (PluginSlot).
+     * Although it’s common to specify a custom mount point (eg. date picker)
+     */
+    contentComponent?: UIComponentFactory;
+    /**
+     * Optional react hook that is mounted for all appearances
+     *
+     * This can be used to access React context, or other React specific code (ie. run `useEffect`)
+     * within a plugin that will run for all appearances without mounting any components.
+     *
+     * Example usages include analytics or width.
+     */
+    usePluginHook?: ReactHookFactory;
+    /**
+     * Optional UI-component that will be added to the toolbar at the top of the editor (doesn't exist in the compact-editor).
+     *
+     * Handler returns a React component that is added to the toolbar at the top of the editor
+     *
+     * Plugins use <ToolbarButton> component to maintain design consistency.
+     */
+    primaryToolbarComponent?: ToolbarUIComponentFactory;
+    /**
+     * Optional UI-component that will be added to the toolbar at the bottom right of the editor. (doesn't exist in the full-page editor)
+     * In compact mode this toolbar lives on the right-hand side of the editor.
+     */
+    secondaryToolbarComponent?: UIComponentFactory;
+    /**
+     * Called after EditorView state is updated.
+     */
+    onEditorViewStateUpdated?: (props: EditorViewStateUpdatedCallbackProps) => void;
+}
+export type getPosHandler = getPosHandlerNode | boolean;
+export type getPosHandlerNode = () => number | undefined;
+export {};

package/dist/types-ts4.5/types/editor-public-api.d.ts

@@ -0,0 +1,4 @@
+import type { EditorPresetBuilder } from '../preset/builder';
+import type { ExtractNextEditorPlugins, PublicPluginAPI } from './next-editor-plugin';
+export type ExtractPublicEditorAPI<T extends EditorPresetBuilder<any, any>> = T extends EditorPresetBuilder<any, infer Plugins> ? PublicPluginAPI<ExtractNextEditorPlugins<Plugins>> : PublicPluginAPI<[
+]>;

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

@@ -0,0 +1,6 @@
+import type { IntlShape } from 'react-intl-next';
+import type { UIAnalyticsEventHandler } from '@atlaskit/analytics-next';
+export type EditorReactContext = {
+    getAtlaskitAnalyticsEventHandlers: () => UIAnalyticsEventHandler[];
+    intl: IntlShape;
+};

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

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+export type EmptyStateHandler = (params: EmptyStateHandlerParams) => React.ReactElement<any> | null;
+export type EmptyStateHandlerParams = {
+    mode: string;
+    selectedCategory?: string;
+    searchTerm?: string;
+};