@atlaskit/editor-core 188.7.0 → 188.7.5

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

@@ -0,0 +1,64 @@
+import type { DecorationSet } from '@atlaskit/editor-prosemirror/view';
+import type { EditorState, Transaction, ReadonlyTransaction } from '@atlaskit/editor-prosemirror/state';
+import type { CloseSelectionOptions } from './constants';
+import type { UiComponentFactoryParams } from '@atlaskit/editor-common/types';
+import type { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
+import type { TypeAheadStats, TypeAheadItemRenderProps, TypeAheadInsert, TypeAheadSelectItem, TypeAheadItem, TypeAheadForceSelect, TypeAheadHandler } from '@atlaskit/editor-common/types';
+import type { TypeAheadInputMethod } from '@atlaskit/editor-plugin-type-ahead';
+export type { TypeAheadStats, TypeAheadItemRenderProps, TypeAheadInsert, TypeAheadSelectItem, TypeAheadItem, TypeAheadForceSelect, TypeAheadHandler, TypeAheadInputMethod, };
+export type OnSelectItem = (props: {
+    index: number;
+    item: TypeAheadItem;
+}) => void;
+export interface TypeAheadStatsSerializable extends TypeAheadStats {
+    serialize: () => TypeAheadStats;
+}
+export interface TypeAheadStatsModifier extends TypeAheadStatsSerializable {
+    increaseArrowUp: () => void;
+    increaseArrowDown: () => void;
+}
+export interface TypeAheadStatsMobileModifier extends TypeAheadStatsSerializable {
+    resetTime: () => void;
+    closeTime: () => void;
+}
+export type TypeAheadPluginState = {
+    decorationSet: DecorationSet;
+    decorationElement: HTMLElement | null;
+    typeAheadHandlers: Array<TypeAheadHandler>;
+    query: string;
+    items: Array<TypeAheadItem>;
+    triggerHandler?: TypeAheadHandler;
+    selectedIndex: number;
+    stats: TypeAheadStatsSerializable | null;
+    inputMethod: TypeAheadInputMethod | null;
+};
+export type OnInsertSelectedItemProps = {
+    mode: SelectItemMode;
+    index: number;
+    query: string;
+};
+export type OnItemMatchProps = {
+    mode: SelectItemMode;
+    query: string;
+};
+export type OnInsertSelectedItem = (props: OnInsertSelectedItemProps) => void;
+export type OnItemMatch = (props: OnItemMatchProps) => boolean;
+export type OnTextInsertProps = {
+    forceFocusOnEditor: boolean;
+    setSelectionAt: CloseSelectionOptions;
+    text: string;
+};
+export type OnTextInsert = (props: OnTextInsertProps) => void;
+export type InsertionTransactionMeta = (editorState: EditorState) => Transaction | false;
+type PopupMountPoints = Pick<UiComponentFactoryParams, 'popupsMountPoint' | 'popupsBoundariesElement' | 'popupsScrollableElement'>;
+export type PopupMountPointReference = Record<'current', PopupMountPoints | null>;
+export type CreateTypeAheadDecorations = (tr: ReadonlyTransaction, options: {
+    triggerHandler: TypeAheadHandler;
+    inputMethod: TypeAheadInputMethod;
+    reopenQuery?: string;
+}) => {
+    decorationSet: DecorationSet;
+    decorationElement: HTMLElement | null;
+    stats: TypeAheadStatsSerializable | null;
+};
+export type RemoveTypeAheadDecorations = (decorationSet?: DecorationSet) => boolean;

package/dist/types-ts4.5/plugins/type-ahead/ui/AssistiveText.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="lodash" />
+/** @jsx jsx */
+import debounce from 'lodash/debounce';
+import React from 'react';
+import { jsx } from '@emotion/react';
+type Cancelable = ReturnType<typeof debounce>;
+type AssistiveTextProps = {
+    assistiveText: string;
+    isInFocus: boolean;
+    id: string;
+    statusDebounceMillis?: number;
+    debounce?: boolean;
+};
+type AssistiveTextState = {
+    bump: boolean;
+    debounced: boolean;
+    silenced: boolean;
+};
+declare class AssistveTextComponent extends React.Component<AssistiveTextProps, AssistiveTextState> {
+    static defaultProps: AssistiveTextProps;
+    debounceStatusUpdate: (() => void) & Cancelable;
+    state: {
+        bump: boolean;
+        debounced: boolean;
+        silenced: boolean;
+    };
+    componentWillMount(): void;
+    componentWillUnmount(): void;
+    componentWillReceiveProps(): void;
+    render(): jsx.JSX.Element;
+}
+export declare const AssistiveText: typeof AssistveTextComponent;
+export {};

package/dist/types-ts4.5/plugins/type-ahead/ui/InputQuery.d.ts

@@ -0,0 +1,26 @@
+/** @jsx jsx */
+import React from 'react';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import { CloseSelectionOptions } from '../constants';
+import { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
+type InputQueryProps = {
+    triggerQueryPrefix: string;
+    onQueryChange: (query: string) => void;
+    onItemSelect: (mode: SelectItemMode) => void;
+    selectNextItem: () => void;
+    selectPreviousItem: () => void;
+    cancel: (props: {
+        forceFocusOnEditor: boolean;
+        setSelectionAt: CloseSelectionOptions;
+        addPrefixTrigger: boolean;
+        text: string;
+    }) => void;
+    onQueryFocus: () => void;
+    forceFocus: boolean;
+    onUndoRedo?: (inputType: 'historyUndo' | 'historyRedo') => boolean;
+    reopenQuery?: string;
+    editorView: EditorView;
+    items: any[];
+};
+export declare const InputQuery: React.FC<InputQueryProps>;
+export {};

package/dist/types-ts4.5/plugins/type-ahead/ui/TypeAheadList.d.ts

@@ -0,0 +1,25 @@
+/** @jsx jsx */
+import React from 'react';
+import { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
+import type { WrappedComponentProps } from 'react-intl-next';
+import type { TypeAheadHandler, TypeAheadItem } from '../types';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+export declare const TypeAheadList: React.FC<import("react-intl-next").WithIntlProps<{
+    items: Array<TypeAheadItem>;
+    selectedIndex: number;
+    editorView: EditorView;
+    onItemClick: (mode: SelectItemMode, index: number) => void;
+    fitHeight: number;
+    decorationElement: HTMLElement;
+    triggerHandler?: TypeAheadHandler | undefined;
+} & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<{
+        items: Array<TypeAheadItem>;
+        selectedIndex: number;
+        editorView: EditorView;
+        onItemClick: (mode: SelectItemMode, index: number) => void;
+        fitHeight: number;
+        decorationElement: HTMLElement;
+        triggerHandler?: TypeAheadHandler | undefined;
+    } & WrappedComponentProps<"intl">>;
+};

package/dist/types-ts4.5/plugins/type-ahead/ui/TypeAheadListItem.d.ts

@@ -0,0 +1,18 @@
+/** @jsx jsx */
+import React from 'react';
+import type { TypeAheadItem } from '../types';
+import { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
+export declare const ICON_HEIGHT = 40;
+export declare const ICON_WIDTH = 40;
+export declare const ITEM_PADDING = 12;
+export declare const itemIcon: import("@emotion/react").SerializedStyles;
+type TypeAheadListItemProps = {
+    item: TypeAheadItem;
+    itemsLength: number;
+    itemIndex: number;
+    selectedIndex: number;
+    ariaLabel?: string;
+    onItemClick: (mode: SelectItemMode, index: number) => void;
+};
+export declare const TypeAheadListItem: React.FC<TypeAheadListItemProps>;
+export {};

package/dist/types-ts4.5/plugins/type-ahead/ui/TypeAheadPopup.d.ts

@@ -0,0 +1,29 @@
+/** @jsx jsx */
+import React from 'react';
+import type { EditorView, DecorationSet } from '@atlaskit/editor-prosemirror/view';
+import type { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
+import type { FireAnalyticsCallback } from '@atlaskit/editor-common/analytics';
+import { CloseSelectionOptions } from '../constants';
+import type { TypeAheadHandler, TypeAheadItem, OnSelectItem } from '../types';
+type TypeAheadPopupProps = {
+    triggerHandler: TypeAheadHandler;
+    editorView: EditorView;
+    anchorElement: HTMLElement;
+    popupsMountPoint?: HTMLElement;
+    popupsBoundariesElement?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    fireAnalyticsCallback: FireAnalyticsCallback;
+    items: Array<TypeAheadItem>;
+    selectedIndex: number;
+    setSelectedItem: OnSelectItem;
+    decorationSet: DecorationSet;
+    isEmptyQuery: boolean;
+    onItemInsert: (mode: SelectItemMode, index: number) => void;
+    cancel: (params: {
+        setSelectionAt: CloseSelectionOptions;
+        addPrefixTrigger: boolean;
+        forceFocusOnEditor: boolean;
+    }) => void;
+};
+export declare const TypeAheadPopup: React.FC<TypeAheadPopupProps>;
+export {};

package/dist/types-ts4.5/plugins/type-ahead/ui/WrapperTypeAhead.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import type { TypeAheadHandler, TypeAheadInputMethod } from '../types';
+type WrapperProps = {
+    triggerHandler: TypeAheadHandler;
+    editorView: EditorView;
+    anchorElement: HTMLElement;
+    getDecorationPosition: () => number | undefined;
+    shouldFocusCursorInsideQuery: boolean;
+    onUndoRedo?: (inputType: 'historyUndo' | 'historyRedo') => boolean;
+    reopenQuery?: string;
+    popupsMountPoint?: HTMLElement;
+    popupsBoundariesElement?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    createAnalyticsEvent?: CreateUIAnalyticsEvent;
+    inputMethod?: TypeAheadInputMethod;
+};
+export declare const WrapperTypeAhead: React.FC<WrapperProps>;
+export {};

package/dist/types-ts4.5/plugins/type-ahead/ui/hooks/use-item-insert.d.ts

@@ -0,0 +1,7 @@
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { TypeAheadHandler, TypeAheadItem, OnItemMatch, OnTextInsert, OnInsertSelectedItem } from '../../types';
+export declare const useItemInsert: (triggerHandler: TypeAheadHandler, editorView: EditorView, items: Array<TypeAheadItem>) => [
+    OnInsertSelectedItem,
+    OnTextInsert,
+    OnItemMatch
+];

package/dist/types-ts4.5/plugins/type-ahead/ui/hooks/use-load-items.d.ts

@@ -0,0 +1,3 @@
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { TypeAheadItem, TypeAheadHandler } from '../../types';
+export declare const useLoadItems: (triggerHandler: TypeAheadHandler, editorView: EditorView, query: string) => Array<TypeAheadItem>;

package/dist/types-ts4.5/plugins/type-ahead/ui/hooks/use-on-force-select.d.ts

@@ -0,0 +1,11 @@
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { TypeAheadHandler, TypeAheadItem } from '../../types';
+type Props = {
+    triggerHandler: TypeAheadHandler;
+    items: Array<TypeAheadItem>;
+    query: string;
+    editorView: EditorView;
+    closePopup: () => void;
+};
+export declare const useOnForceSelect: ({ triggerHandler, items, query, editorView, closePopup, }: Props) => void;
+export {};

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

@@ -0,0 +1,27 @@
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { TypeAheadHandler, TypeAheadItem } from './types';
+import type { IntlShape } from 'react-intl-next';
+export declare const isTypeAheadHandler: (handler: any) => handler is TypeAheadHandler;
+/** Is a typeahead plugin open? */
+export declare const isTypeAheadOpen: (editorState: EditorState) => boolean;
+export declare const getPluginState: (editorState: EditorState) => import("./types").TypeAheadPluginState | undefined;
+export declare const getTypeAheadHandler: (editorState: EditorState) => TypeAheadHandler | undefined;
+export declare const getTypeAheadQuery: (editorState: EditorState) => string | undefined;
+export declare const isTypeAheadAllowed: (state: EditorState) => boolean;
+export declare const findHandler: (id: string, state: EditorState) => TypeAheadHandler | null;
+export declare const findHandlerByTrigger: ({ trigger, editorState, }: {
+    trigger: string;
+    editorState: EditorState;
+}) => TypeAheadHandler | null;
+type MoveSelectedIndexProps = {
+    editorView: EditorView;
+    direction: 'next' | 'previous';
+};
+export declare const moveSelectedIndex: ({ editorView, direction }: MoveSelectedIndexProps) => () => void;
+type TypeAheadAssistiveLabels = {
+    popupAriaLabel: string;
+    listItemAriaLabel?: string;
+};
+export declare const getTypeAheadListAriaLabels: (trigger: string | undefined, intl: IntlShape, item?: TypeAheadItem) => TypeAheadAssistiveLabels;
+export {};

package/dist/types-ts4.5/plugins/undo-redo/attach-input-meta.d.ts

@@ -0,0 +1,5 @@
+import type { HigherOrderCommand } from '../../types/command';
+import type { InputSource } from './enums';
+type AttachInputMeta = (inputSource: InputSource) => HigherOrderCommand;
+export declare const attachInputMeta: AttachInputMeta;
+export {};

package/dist/types-ts4.5/plugins/undo-redo/commands.d.ts

@@ -0,0 +1,4 @@
+export declare const undoFromKeyboard: import("../..").Command;
+export declare const redoFromKeyboard: import("../..").Command;
+export declare const undoFromToolbar: import("../..").Command;
+export declare const redoFromToolbar: import("../..").Command;

package/dist/types-ts4.5/plugins/undo-redo/enums.d.ts

@@ -0,0 +1,4 @@
+export declare enum InputSource {
+    TOOLBAR = "toolbar",
+    KEYBOARD = "keyboard"
+}

package/dist/types-ts4.5/plugins/undo-redo/index.d.ts

@@ -0,0 +1,3 @@
+import type { UndoRedoPlugin } from './types';
+declare const undoRedoPlugin: UndoRedoPlugin;
+export default undoRedoPlugin;

package/dist/types-ts4.5/plugins/undo-redo/pm-plugins/keymaps.d.ts

@@ -0,0 +1,2 @@
+import type { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+export declare function keymapPlugin(): SafePlugin;

package/dist/types-ts4.5/plugins/undo-redo/pm-plugins/main.d.ts

@@ -0,0 +1,2 @@
+import { PMPluginFactory } from '../../../types';
+export declare const createPlugin: PMPluginFactory;

package/dist/types-ts4.5/plugins/undo-redo/pm-plugins/plugin-key.d.ts

@@ -0,0 +1,2 @@
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+export declare const pluginKey: PluginKey<any>;

package/dist/types-ts4.5/plugins/undo-redo/types.d.ts

@@ -0,0 +1,7 @@
+import type { NextEditorPlugin } from '@atlaskit/editor-common/types';
+import type { TypeAheadPlugin } from '@atlaskit/editor-plugin-type-ahead';
+export type UndoRedoPlugin = NextEditorPlugin<'undoRedoPlugin', {
+    dependencies: [
+        TypeAheadPlugin
+    ];
+}>;

package/dist/types-ts4.5/plugins/undo-redo/ui/ToolbarUndoRedo/index.d.ts

@@ -0,0 +1,24 @@
+/** @jsx jsx */
+import { PureComponent } from 'react';
+import { jsx } from '@emotion/react';
+import type { WrappedComponentProps } from 'react-intl-next';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { HistoryPluginState } from '../../../history/types';
+import type { UndoRedoPlugin } from '../../types';
+import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+export interface Props {
+    undoDisabled?: boolean;
+    redoDisabled?: boolean;
+    disabled?: boolean;
+    isReducedSpacing?: boolean;
+    historyState: HistoryPluginState;
+    editorView: EditorView;
+    api: ExtractInjectionAPI<UndoRedoPlugin> | undefined;
+}
+export declare class ToolbarUndoRedo extends PureComponent<Props & WrappedComponentProps> {
+    render(): jsx.JSX.Element;
+}
+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/plugins/view-update-subscription/index.d.ts

@@ -0,0 +1,19 @@
+import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { NextEditorPlugin } from '@atlaskit/editor-common/types';
+type UpdateArgs = {
+    newEditorState: EditorState;
+    oldEditorState: EditorState;
+    transactions: readonly Transaction[];
+};
+export type ViewUpdateSubscription = (args: UpdateArgs) => void;
+export declare const trackerStore: WeakMap<EditorView, Tracker>;
+declare class Tracker {
+    private subscriptions;
+    constructor();
+    update: (props: UpdateArgs) => void;
+    add: (subscription: ViewUpdateSubscription) => void;
+    remove: (subscription: ViewUpdateSubscription) => void;
+}
+declare const createViewUpdateSubscriptionPlugin: NextEditorPlugin<'viewUpdateSubscription'>;
+export default createViewUpdateSubscriptionPlugin;

package/dist/types-ts4.5/plugins/view-update-subscription/subscribe/toolbarAndPickerUpdates.d.ts

@@ -0,0 +1,12 @@
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { DatePluginSharedState } from '../../date';
+import type { ConfigWithNodeInfo } from '@atlaskit/editor-plugin-floating-toolbar';
+import type { StatusState } from '../../status/types';
+type SubscribeToToolbarAndPickerUpdatesCallbackArgs = {
+    dateState?: DatePluginSharedState;
+    statusState?: StatusState;
+    toolbarConfig: ConfigWithNodeInfo | null | undefined;
+};
+type SubscribeToToolbarAndPickerUpdates = (editorView: EditorView, cb: (args: SubscribeToToolbarAndPickerUpdatesCallbackArgs) => void) => () => void;
+export declare const subscribeToToolbarAndPickerUpdates: SubscribeToToolbarAndPickerUpdates;
+export {};

package/dist/types-ts4.5/plugins/view-update-subscription/subscribe/type-ahead-updates.d.ts

@@ -0,0 +1,9 @@
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { TypeAheadPluginState } from '../../type-ahead/types';
+type Props = {
+    oldPluginState: TypeAheadPluginState;
+    newPluginState: TypeAheadPluginState;
+};
+type SubscribeTypeAheadUpdates = (editorView: EditorView, cb: (props: Props) => void) => () => void;
+export declare const subscribeTypeAheadUpdates: SubscribeTypeAheadUpdates;
+export {};

package/dist/types-ts4.5/preset-default.d.ts

@@ -0,0 +1 @@
+export { createDefaultPreset } from './labs/next/presets/default';

package/dist/types-ts4.5/preset-universal.d.ts

@@ -0,0 +1 @@
+export { default as useUniversalPreset } from './labs/next/presets/useUniversalPreset';

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

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { PublicPluginAPI } from '@atlaskit/editor-common/types';
+export type SetEditorAPI = (editorApi: PublicPluginAPI<any>) => void;
+export interface EditorAPIContextType {
+    editorApi?: PublicPluginAPI<any>;
+    setEditorApi?: SetEditorAPI;
+}
+export declare const EditorAPIContext: React.Context<EditorAPIContextType>;
+interface EditorAPIProviderProps {
+    children: React.ReactNode;
+}
+export declare const PresetContextProvider: ({ children }: EditorAPIProviderProps) => JSX.Element;
+export declare const usePresetContext: () => PublicPluginAPI<any> | undefined;
+export declare const useSetPresetContext: () => SetEditorAPI | undefined;
+export {};

package/dist/types-ts4.5/stories/examples.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import Editor from '../editor';
+declare const _default: {
+    title: string;
+    component: typeof Editor;
+    decorators: ((...args: any) => any)[];
+};
+export default _default;
+export declare const EditorExample: (args: any) => JSX.Element;

package/dist/types-ts4.5/test-utils.d.ts

@@ -0,0 +1,40 @@
+import type { Schema } from '@atlaskit/editor-prosemirror/model';
+import type { Plugin } from '@atlaskit/editor-prosemirror/state';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { EditorPluginInjectionAPI } from '@atlaskit/editor-common/preset';
+import { EditorPresetBuilder } from '@atlaskit/editor-common/preset';
+import type { AllEditorPresetPluginTypes, ReactHookFactory, UIComponentFactory } from '@atlaskit/editor-common/types';
+import type { LightPMPlugin, LightPMPluginFactoryParams, OnEditorViewStateUpdated } from './create-editor/get-plugins';
+import type { MarkConfig, NodeConfig } from './types/pm-config';
+export type { LightEditorPlugin } from './create-editor/get-plugins';
+export type { DispatchAnalyticsEvent } from './plugins/analytics/types';
+export type { FeatureFlags } from './types/feature-flags';
+export interface LightEditorConfig {
+    nodes: NodeConfig[];
+    marks: MarkConfig[];
+    plugins: Array<LightPMPlugin>;
+    contentComponents: UIComponentFactory[];
+    pluginHooks: ReactHookFactory[];
+    onEditorViewStateUpdatedCallbacks: Array<OnEditorViewStateUpdated>;
+}
+export declare function getFireAnalytics(editorView: EditorView): any;
+type PluginData = {
+    plugins: Plugin[];
+    schema: Schema;
+    onEditorViewStateUpdatedCallbacks: Array<OnEditorViewStateUpdated>;
+    editorConfig: LightEditorConfig;
+};
+export declare const createPMSchemaAndPlugins: (inputPreset?: EditorPresetBuilder<string[], AllEditorPresetPluginTypes[]>) => (pluginFactoryParams: Omit<LightPMPluginFactoryParams, 'schema'> & {
+    pluginInjectionAPI: EditorPluginInjectionAPI;
+}) => PluginData;
+export { EventDispatcher } from './event-dispatcher';
+export type { Dispatch } from './event-dispatcher';
+export { GapCursorSelection, Side as GapCursorSide, } from '@atlaskit/editor-common/selection';
+export declare function setTextSelection(view: EditorView, anchor: number, head?: number): void;
+/**
+ * Given a selector, checks if an element matching the selector exists in the
+ * document.
+ * @param selector
+ * @returns true if element matching selector exists in document, false otherwise
+ */
+export declare const isElementBySelectorInDocument: (selector: string) => boolean;

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

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

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

@@ -0,0 +1,5 @@
+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;

package/dist/types-ts4.5/types/dom-at-pos.d.ts

@@ -0,0 +1,4 @@
+export type DomAtPos = (pos: number) => {
+    node: Node;
+    offset: number;
+};

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

@@ -0,0 +1,50 @@
+import type { RefObject, ReactElement } from 'react';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { DispatchAnalyticsEvent } from '@atlaskit/editor-common/analytics';
+import type { ExtensionHandlers } from '@atlaskit/editor-common/extensions';
+import type { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import type { ReactHookFactory } from '@atlaskit/editor-common/types';
+import type EditorActions from '../actions';
+import type { EventDispatcher } from '../event-dispatcher';
+import type { CollabEditOptions } from '@atlaskit/editor-common/collab';
+import type { PrimaryToolbarComponents, ReactComponents } from '../types/editor-props';
+import type { UseStickyToolbarType } from '@atlaskit/editor-common/ui';
+import type { UIComponentFactory } from '../types/ui-components';
+import type { MenuItem } from '@atlaskit/editor-common/ui-menu';
+import type { ToolbarUIComponentFactory } from '../ui/Toolbar/types';
+import type { EditorAppearance } from './editor-appearance';
+import type { FeatureFlags } from './feature-flags';
+export interface EditorAppearanceComponentProps {
+    appearance?: EditorAppearance;
+    onSave?: (editorView: EditorView) => void;
+    onCancel?: (editorView: EditorView) => void;
+    providerFactory: ProviderFactory;
+    editorActions?: EditorActions;
+    editorDOMElement: JSX.Element;
+    editorView?: EditorView;
+    eventDispatcher?: EventDispatcher;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    maxHeight?: number;
+    minHeight?: number;
+    contentComponents?: UIComponentFactory[];
+    pluginHooks?: ReactHookFactory[];
+    primaryToolbarComponents?: ToolbarUIComponentFactory[];
+    primaryToolbarIconBefore?: ReactElement;
+    secondaryToolbarComponents?: UIComponentFactory[];
+    customContentComponents?: ReactComponents;
+    customPrimaryToolbarComponents?: PrimaryToolbarComponents;
+    customSecondaryToolbarComponents?: ReactComponents;
+    insertMenuItems?: MenuItem[];
+    contextPanel?: ReactComponents;
+    popupsMountPoint?: HTMLElement;
+    popupsBoundariesElement?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    extensionHandlers?: ExtensionHandlers;
+    disabled?: boolean;
+    collabEdit?: CollabEditOptions;
+    persistScrollGutter?: boolean;
+    enableToolbarMinWidth?: boolean;
+    featureFlags: FeatureFlags;
+    useStickyToolbar?: UseStickyToolbarType;
+    innerRef?: RefObject<HTMLDivElement>;
+}

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

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

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

@@ -0,0 +1,25 @@
+import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { ReactHookFactory, UIComponentFactory } from '@atlaskit/editor-common/types';
+import type { ToolbarUIComponentFactory } from '../ui/Toolbar/types';
+import type { MarkConfig, NodeConfig } from './pm-config';
+import type { PMPlugin } from './pm-plugin';
+type EditorViewStateUpdatedCallbackProps = {
+    readonly originalTransaction: Readonly<Transaction>;
+    readonly transactions: readonly Transaction[];
+    readonly oldEditorState: Readonly<EditorState>;
+    readonly newEditorState: Readonly<EditorState>;
+};
+export interface EditorConfig {
+    nodes: NodeConfig[];
+    marks: MarkConfig[];
+    pmPlugins: Array<PMPlugin>;
+    contentComponents: UIComponentFactory[];
+    pluginHooks: ReactHookFactory[];
+    primaryToolbarComponents: ToolbarUIComponentFactory[];
+    secondaryToolbarComponents: UIComponentFactory[];
+    onEditorViewStateUpdatedCallbacks: Array<{
+        pluginName: string;
+        callback: (props: EditorViewStateUpdatedCallbackProps) => void;
+    }>;
+}
+export {};

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

@@ -0,0 +1,19 @@
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { OnEditorViewStateUpdated } from '../create-editor/get-plugins';
+import type { EventDispatcher } from '../event-dispatcher';
+import type { MenuItem } from '@atlaskit/editor-common/ui-menu';
+import type { ToolbarUIComponentFactory } from '../ui/Toolbar/types';
+import type { UIComponentFactory } from './ui-components';
+export interface EditorInstance {
+    editorView: EditorView;
+    eventDispatcher: EventDispatcher;
+    contentComponents: UIComponentFactory[];
+    primaryToolbarComponents: ToolbarUIComponentFactory[];
+    secondaryToolbarComponents: UIComponentFactory[];
+    onEditorViewStateUpdatedCallbacks: {
+        pluginName: string;
+        callback: OnEditorViewStateUpdated;
+    }[];
+    contentTransformer?: Transformer<string>;
+    insertMenuItems?: MenuItem[];
+}

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

@@ -0,0 +1,4 @@
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+export type EditorOnChangeHandler = (editorView: EditorView, meta: {
+    source: 'local' | 'remote';
+}) => void;

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

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