@atlaskit/editor-core 183.0.8 → 183.0.12

package/dist/types-ts4.5/plugins/code-block/nodeviews/code-block.d.ts

@@ -0,0 +1,21 @@
+import { EditorView } from 'prosemirror-view';
+import { Node } from 'prosemirror-model';
+import { getPosHandlerNode, getPosHandler } from '../../../nodeviews/';
+export declare class CodeBlockView {
+    node: Node;
+    dom: HTMLElement;
+    contentDOM: HTMLElement;
+    lineNumberGutter: HTMLElement;
+    getPos: getPosHandlerNode;
+    view: EditorView;
+    constructor(node: Node, view: EditorView, getPos: getPosHandlerNode);
+    updateDOMAndSelection(savedInnerHTML: string, newCursorPosition: number): void;
+    coalesceDOMElements(): void;
+    private ensureLineNumbers;
+    update(node: Node): boolean;
+    ignoreMutation(record: MutationRecord | {
+        type: 'selection';
+        target: Element;
+    }): boolean;
+}
+export declare const codeBlockNodeView: (node: Node, view: EditorView, getPos: getPosHandler) => CodeBlockView;

package/dist/types-ts4.5/plugins/code-block/plugin-key.d.ts

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

package/dist/types-ts4.5/plugins/code-block/pm-plugins/actions.d.ts

@@ -0,0 +1,4 @@
+export declare const ACTIONS: {
+    SET_COPIED_TO_CLIPBOARD: string;
+    SET_SHOULD_IGNORE_FOLLOWING_MUTATIONS: string;
+};

package/dist/types-ts4.5/plugins/code-block/pm-plugins/codeBlockCopySelectionPlugin.d.ts

@@ -0,0 +1,14 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from 'prosemirror-state';
+import type { EditorState, Transaction } from 'prosemirror-state';
+export declare const copySelectionPluginKey: PluginKey<any, any>;
+type CodeBlockCopySelectionPluginState = {
+    decorationStartAndEnd?: [
+        start: number,
+        end: number
+    ];
+};
+export declare function codeBlockCopySelectionPlugin(): SafePlugin<CodeBlockCopySelectionPluginState, any>;
+export declare function provideVisualFeedbackForCopyButton(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;
+export declare function removeVisualFeedbackForCopyButton(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;
+export {};

package/dist/types-ts4.5/plugins/code-block/pm-plugins/ide-ux.d.ts

@@ -0,0 +1,3 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+declare const _default: SafePlugin<any, any>;
+export default _default;

package/dist/types-ts4.5/plugins/code-block/pm-plugins/keymaps.d.ts

@@ -0,0 +1,4 @@
+import { Schema } from 'prosemirror-model';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+export declare function keymapPlugin(schema: Schema): SafePlugin | undefined;
+export default keymapPlugin;

package/dist/types-ts4.5/plugins/code-block/pm-plugins/main-state.d.ts

@@ -0,0 +1,8 @@
+import { EditorState } from 'prosemirror-state';
+export type CodeBlockState = {
+    pos: number | null;
+    contentCopied: boolean;
+    isNodeSelected: boolean;
+    shouldIgnoreFollowingMutations: boolean;
+};
+export declare const getPluginState: (state: EditorState) => CodeBlockState;

package/dist/types-ts4.5/plugins/code-block/pm-plugins/main.d.ts

@@ -0,0 +1,9 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { IntlShape } from 'react-intl-next';
+import type { EditorProps } from '../../../types';
+export declare const createPlugin: ({ useLongPressSelection, getIntl, appearance, allowCompositionInputOverride, }: {
+    useLongPressSelection?: boolean | undefined;
+    getIntl: () => IntlShape;
+    appearance: EditorProps['appearance'];
+    allowCompositionInputOverride?: boolean | undefined;
+}) => SafePlugin<any, any>;

package/dist/types-ts4.5/plugins/code-block/refresh-browser-selection.d.ts

@@ -0,0 +1,5 @@
+import { EditorState, Transaction } from 'prosemirror-state';
+declare const refreshBrowserSelection: () => void;
+declare const refreshBrowserSelectionOnChange: (transaction: Transaction, editorState: EditorState) => void;
+export default refreshBrowserSelectionOnChange;
+export { refreshBrowserSelection };

package/dist/types-ts4.5/plugins/code-block/styles.d.ts

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

package/dist/types-ts4.5/plugins/code-block/toolbar.d.ts

@@ -0,0 +1,14 @@
+import { FloatingToolbarHandler } from '../floating-toolbar/types';
+import { SelectOption } from '../floating-toolbar/ui/Select';
+export declare const messages: {
+    selectLanguage: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};
+export declare const getToolbarConfig: (allowCopyToClipboard?: boolean) => FloatingToolbarHandler;
+/**
+ * Filters language list based on both name and alias properties.
+ */
+export declare const languageListFilter: (option: SelectOption, rawInput: string) => any;

package/dist/types-ts4.5/plugins/code-block/types.d.ts

@@ -0,0 +1,7 @@
+import type { EditorAppearance } from '../../types';
+import { LongPressSelectionPluginOptions } from '../selection/types';
+export interface CodeBlockOptions extends LongPressSelectionPluginOptions {
+    allowCopyToClipboard?: boolean;
+    allowCompositionInputOverride?: boolean;
+    appearance?: EditorAppearance | undefined;
+}

package/dist/types-ts4.5/plugins/code-block/ui/class-names.d.ts

@@ -0,0 +1,8 @@
+export declare const codeBlockClassNames: {
+    container: string;
+    start: string;
+    end: string;
+    contentWrapper: string;
+    gutter: string;
+    content: string;
+};

package/dist/types-ts4.5/plugins/code-block/utils.d.ts

@@ -0,0 +1,5 @@
+import { Slice, Schema } from 'prosemirror-model';
+import { EditorState, Selection } from 'prosemirror-state';
+export declare function transformSliceToJoinAdjacentCodeBlocks(slice: Slice): Slice;
+export declare const transformSingleLineCodeBlockToCodeMark: (slice: Slice, schema: Schema) => Slice<any>;
+export declare const findCodeBlock: (state: EditorState, selection?: Selection<any> | null) => import("prosemirror-utils").ContentNodeWithPos | undefined;

package/dist/types-ts4.5/plugins/collab-edit/actions.d.ts

@@ -0,0 +1,10 @@
+import { Selection } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+import { CollabEventInitData, CollabEventRemoteData, CollabEventConnectionData, CollabEventPresenceData, CollabEventTelepointerData, CollabSendableSelection, PrivateCollabEditOptions } from './types';
+export declare const handleInit: (initData: CollabEventInitData, view: EditorView, options?: PrivateCollabEditOptions) => void;
+export declare const handleConnection: (connectionData: CollabEventConnectionData, view: EditorView) => void;
+export declare const handlePresence: (presenceData: CollabEventPresenceData, view: EditorView) => void;
+export declare const applyRemoteData: (remoteData: CollabEventRemoteData, view: EditorView, options: PrivateCollabEditOptions) => void;
+export declare const applyRemoteSteps: (json: any[], view: EditorView, userIds?: (number | string)[], options?: PrivateCollabEditOptions) => void;
+export declare const handleTelePointer: (telepointerData: CollabEventTelepointerData, view: EditorView) => void;
+export declare const getSendableSelection: (selection: Selection) => CollabSendableSelection;

package/dist/types-ts4.5/plugins/collab-edit/analytics.d.ts

@@ -0,0 +1,5 @@
+import { EditorState, Transaction } from 'prosemirror-state';
+import { FeatureFlags } from '@atlaskit/editor-common/types';
+export declare const addSynchronyErrorAnalytics: (state: EditorState, tr: Transaction, featureFlags: FeatureFlags) => (error: Error) => Transaction<any>;
+export type EntityEventType = 'error' | 'disconnected';
+export declare const addSynchronyEntityAnalytics: (state: EditorState, tr: Transaction) => (type: EntityEventType) => Transaction<any>;

package/dist/types-ts4.5/plugins/collab-edit/events/handlers.d.ts

@@ -0,0 +1,23 @@
+import { EditorView } from 'prosemirror-view';
+import type { CollabEventInitData, CollabEventConnectionData, CollabEventPresenceData, CollabEventTelepointerData, CollabEventRemoteData, CollabEventLocalStepData, CollabEditProvider } from '@atlaskit/editor-common/collab';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import { PrivateCollabEditOptions } from '../types';
+import { FeatureFlags } from '@atlaskit/editor-common/types';
+export type SynchronyEntity = {
+    on: (evt: 'disconnected' | 'error', handler: (...args: any) => void) => void;
+    off: (evt: 'disconnected' | 'error', handler: (...args: any) => void) => void;
+};
+export interface CollabHandlers {
+    initHandler: (data: CollabEventInitData) => void;
+    connectedHandler: (data: CollabEventConnectionData) => void;
+    dataHandler: (data: CollabEventRemoteData) => void;
+    presenceHandler: (data: CollabEventPresenceData) => void;
+    telepointerHandler: (data: CollabEventTelepointerData) => void;
+    localStepsHandler: (data: CollabEventLocalStepData) => void;
+    errorHandler: (error: any) => void;
+    entityHandler: ({ entity }: {
+        entity: SynchronyEntity;
+    }) => void;
+}
+export type Cleanup = () => void;
+export declare const subscribe: (currentDeps_0: EditorView<any>, currentDeps_1: CollabEditProvider<import("@atlaskit/editor-common/collab").CollabEventData>, currentDeps_2: PrivateCollabEditOptions, currentDeps_3: FeatureFlags, currentDeps_4?: ProviderFactory | undefined) => Cleanup;

package/dist/types-ts4.5/plugins/collab-edit/events/initialize.d.ts

@@ -0,0 +1,14 @@
+import { EditorView } from 'prosemirror-view';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import { CollabEditProvider } from '../provider';
+import { PrivateCollabEditOptions } from '../types';
+import { Cleanup } from './handlers';
+import { FeatureFlags } from '@atlaskit/editor-common/types';
+type Props = {
+    view: EditorView;
+    options: PrivateCollabEditOptions;
+    providerFactory: ProviderFactory;
+    featureFlags: FeatureFlags;
+};
+export declare const initialize: ({ options, providerFactory, view, featureFlags }: Props) => (provider: CollabEditProvider) => Cleanup;
+export {};

package/dist/types-ts4.5/plugins/collab-edit/events/send-transaction.d.ts

@@ -0,0 +1,11 @@
+import type { CollabEditProvider } from '@atlaskit/editor-common/collab';
+import { Transaction, EditorState } from 'prosemirror-state';
+type Props = {
+    originalTransaction: Transaction;
+    transactions: Transaction[];
+    oldEditorState: EditorState;
+    newEditorState: EditorState;
+    useNativePlugin: boolean;
+};
+export declare const sendTransaction: ({ originalTransaction, transactions, oldEditorState, newEditorState, useNativePlugin, }: Props) => (provider: CollabEditProvider) => void;
+export {};

package/dist/types-ts4.5/plugins/collab-edit/get-participants-count.d.ts

@@ -0,0 +1,2 @@
+import { EditorState } from 'prosemirror-state';
+export declare function getParticipantsCount(state?: EditorState): number;

package/dist/types-ts4.5/plugins/collab-edit/index.d.ts

@@ -0,0 +1,14 @@
+import { NextEditorPlugin } from '@atlaskit/editor-common/types';
+import { pluginKey } from './plugin';
+import { CollabEditOptions, PrivateCollabEditOptions } from './types';
+export type { CollabEditProvider } from './provider';
+import type featureFlagsPlugin from '@atlaskit/editor-plugin-feature-flags';
+export { pluginKey };
+export type { CollabEditOptions };
+declare const collabEditPlugin: NextEditorPlugin<'collabEdit', {
+    pluginConfiguration: PrivateCollabEditOptions;
+    dependencies: [
+        typeof featureFlagsPlugin
+    ];
+}>;
+export default collabEditPlugin;

package/dist/types-ts4.5/plugins/collab-edit/native-collab-provider-plugin.d.ts

@@ -0,0 +1,7 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { EditorState } from 'prosemirror-state';
+import type { CollabEditProvider } from '@atlaskit/editor-common/collab';
+export declare const nativeCollabProviderPlugin: ({ providerPromise, }: {
+    providerPromise: Promise<CollabEditProvider>;
+}) => SafePlugin<CollabEditProvider<import("@atlaskit/editor-common/collab").CollabEventData> | null, any>;
+export declare const getCollabProvider: (editorState: EditorState) => CollabEditProvider | null;

package/dist/types-ts4.5/plugins/collab-edit/participants.d.ts

@@ -0,0 +1,18 @@
+import { CollabParticipant } from './types';
+export interface ReadOnlyParticipants {
+    get(sessionId: string): CollabParticipant | undefined;
+    toArray(): ReadonlyArray<CollabParticipant>;
+    eq(other: ReadOnlyParticipants): boolean;
+}
+export declare class Participants implements ReadOnlyParticipants {
+    private participants;
+    constructor(participants?: Map<string, CollabParticipant>);
+    add(data: CollabParticipant[]): Participants;
+    remove(sessionIds: string[]): Participants;
+    update(sessionId: string, lastActive: number): Participants;
+    updateCursorPos(sessionId: string, cursorPos: number): Participants;
+    toArray(): CollabParticipant[];
+    get(sessionId: string): CollabParticipant | undefined;
+    size(): number;
+    eq(other: Participants): boolean;
+}

package/dist/types-ts4.5/plugins/collab-edit/plugin-key.d.ts

@@ -0,0 +1,3 @@
+import { PluginKey } from 'prosemirror-state';
+import type { PluginState as CollabPluginState } from './plugin-state';
+export declare const pluginKey: PluginKey<CollabPluginState, any>;

package/dist/types-ts4.5/plugins/collab-edit/plugin-state.d.ts

@@ -0,0 +1,23 @@
+import { ReadonlyTransaction } from 'prosemirror-state';
+import { DecorationSet } from 'prosemirror-view';
+import { Participants, ReadOnlyParticipants } from './participants';
+export declare const TELEPOINTER_DIM_CLASS = "telepointer-dim";
+/**
+ * Returns position where it's possible to place a decoration.
+ */
+export declare const getValidPos: (tr: ReadonlyTransaction, pos: number) => number;
+export declare class PluginState {
+    private decorationSet;
+    private participants;
+    private onError;
+    private sid?;
+    isReady: boolean;
+    get decorations(): DecorationSet<any>;
+    get activeParticipants(): ReadOnlyParticipants;
+    get sessionId(): string | undefined;
+    constructor(decorations: DecorationSet, participants: Participants, sessionId?: string, collabInitalised?: boolean, onError?: (err: Error) => void);
+    getInitial(sessionId: string): string;
+    apply(tr: ReadonlyTransaction): PluginState;
+    static eq(a: PluginState, b: PluginState): boolean;
+    static init(config: any): PluginState;
+}

package/dist/types-ts4.5/plugins/collab-edit/plugin.d.ts

@@ -0,0 +1,11 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import { Dispatch } from '../../event-dispatcher';
+import { PrivateCollabEditOptions, ProviderCallback } from './types';
+import { CollabEditProvider } from './provider';
+import { PluginState } from './plugin-state';
+import { pluginKey } from './plugin-key';
+import { FeatureFlags } from '@atlaskit/editor-common/types';
+export { PluginState, pluginKey };
+export type { CollabEditProvider };
+export declare const createPlugin: (dispatch: Dispatch, providerFactory: ProviderFactory, collabProviderCallback: ProviderCallback, options: PrivateCollabEditOptions, featureFlags: FeatureFlags) => SafePlugin<any, any>;

package/dist/types-ts4.5/plugins/collab-edit/provider/index.d.ts

@@ -0,0 +1 @@
+export type { CollabEditProvider } from './types';

package/dist/types-ts4.5/plugins/collab-edit/provider/types.d.ts

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

package/dist/types-ts4.5/plugins/collab-edit/styles.d.ts

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

package/dist/types-ts4.5/plugins/collab-edit/types.d.ts

@@ -0,0 +1,36 @@
+import { ReactElement } from 'react';
+import { Providers } from '@atlaskit/editor-common/provider-factory';
+import type { CollabEditProvider } from '@atlaskit/editor-common/collab';
+import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next/types';
+import { SyncUpErrorFunction } from '@atlaskit/editor-common/types';
+export type { CollabParticipant, CollabEventInitData, CollabEventRemoteData, CollabEventConnectionData, CollabEventPresenceData, CollabEventTelepointerData, CollabSendableSelection, } from '@atlaskit/editor-common/collab';
+export type InviteToEditComponentProps = {
+    children: ReactElement<InviteToEditButtonProps>;
+};
+export type InviteToEditButtonProps = {
+    onClick: (event: React.MouseEvent<HTMLElement>) => void;
+    selected: boolean;
+};
+export interface CollabInviteToEditProps {
+    inviteToEditHandler?: (event: React.MouseEvent<HTMLElement>) => void;
+    isInviteToEditButtonSelected?: boolean;
+    inviteToEditComponent?: React.ComponentType<InviteToEditComponentProps>;
+}
+export interface CollabAnalyticsProps {
+    /**
+     * @description Control wether Synchrony entity error events are tracked
+     */
+    EXPERIMENTAL_allowInternalErrorAnalytics?: boolean;
+}
+export type CollabEditOptions = {
+    provider?: Providers['collabEditProvider'];
+    userId?: string;
+    useNativePlugin?: boolean;
+} & CollabInviteToEditProps & CollabAnalyticsProps;
+export type PrivateCollabEditOptions = CollabEditOptions & {
+    sanitizePrivateContent?: boolean;
+    createAnalyticsEvent?: CreateUIAnalyticsEvent;
+    onSyncUpError?: SyncUpErrorFunction;
+};
+export type ProviderCallback = <ReturnType>(codeToExecute: (provider: CollabEditProvider) => ReturnType | undefined, onError?: (err: Error) => void) => Promise<ReturnType | undefined> | undefined;
+export type ProviderBuilder = (collabEditProviderPromise: Promise<CollabEditProvider>) => ProviderCallback;

package/dist/types-ts4.5/plugins/collab-edit/ui/avatars-with-plugin-state.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+import { WrappedComponentProps } from 'react-intl-next';
+import { EditorView } from 'prosemirror-view';
+import { EventDispatcher } from '../../../event-dispatcher';
+import { CollabInviteToEditProps } from '../types';
+import { FeatureFlags } from '@atlaskit/editor-common/types';
+export type AvatarsWithPluginStateProps = {
+    editorView?: EditorView;
+    eventDispatcher?: EventDispatcher;
+    featureFlags: FeatureFlags;
+} & CollabInviteToEditProps;
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<{
+    editorView?: EditorView<any> | undefined;
+    eventDispatcher?: EventDispatcher<any> | undefined;
+    featureFlags: FeatureFlags;
+} & CollabInviteToEditProps & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<{
+        editorView?: EditorView<any> | undefined;
+        eventDispatcher?: EventDispatcher<any> | undefined;
+        featureFlags: FeatureFlags;
+    } & CollabInviteToEditProps & WrappedComponentProps<"intl">>;
+};
+export default _default;

package/dist/types-ts4.5/plugins/collab-edit/ui/avatars.d.ts

@@ -0,0 +1,12 @@
+/** @jsx jsx */
+import React from 'react';
+import { EditorView } from 'prosemirror-view';
+import { ReadOnlyParticipants } from '../participants';
+import { FeatureFlags } from '@atlaskit/editor-common/types';
+export interface AvatarsProps {
+    sessionId?: string;
+    participants: ReadOnlyParticipants;
+    editorView?: EditorView;
+    featureFlags: FeatureFlags;
+}
+export declare const Avatars: React.FC<AvatarsProps>;

package/dist/types-ts4.5/plugins/collab-edit/ui/colored-avatar-item.d.ts

@@ -0,0 +1,7 @@
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+export interface ColoredAvatarItemProps {
+    sessionId: string;
+    name: string;
+}
+export declare const ColoredAvatarItem: (props: ColoredAvatarItemProps) => jsx.JSX.Element;

package/dist/types-ts4.5/plugins/collab-edit/ui/index.d.ts

@@ -0,0 +1,2 @@
+import AvatarsWithPluginState from './avatars-with-plugin-state';
+export default AvatarsWithPluginState;

package/dist/types-ts4.5/plugins/collab-edit/ui/invite-to-edit.d.ts

@@ -0,0 +1,10 @@
+/** @jsx jsx */
+import React from 'react';
+import { InviteToEditComponentProps } from '../types';
+export interface InviteToEditButtonProps {
+    onClick?: React.MouseEventHandler;
+    selected?: boolean;
+    Component?: React.ComponentType<InviteToEditComponentProps>;
+    title: string;
+}
+export declare const InviteToEditButton: React.FC<InviteToEditButtonProps>;

package/dist/types-ts4.5/plugins/collab-edit/ui/styles.d.ts

@@ -0,0 +1,3 @@
+export declare const inviteTeamWrapper: import("@emotion/react").SerializedStyles;
+export declare const avatarContainer: import("@emotion/react").SerializedStyles;
+export declare const badge: (color: string) => import("@emotion/react").SerializedStyles;

package/dist/types-ts4.5/plugins/collab-edit/ui/to-avatar.d.ts

@@ -0,0 +1,4 @@
+import { AvatarProps } from '@atlaskit/avatar-group';
+import { CollabParticipant } from '../types';
+declare const _default: import("memoize-one").MemoizedFn<(participant: CollabParticipant) => AvatarProps>;
+export default _default;

package/dist/types-ts4.5/plugins/collab-edit/utils.d.ts

@@ -0,0 +1,19 @@
+import { EditorState } from 'prosemirror-state';
+import { EditorView, Decoration, DecorationSet } from 'prosemirror-view';
+import { CollabEditOptions, CollabParticipant } from './types';
+export interface Color {
+    solid: string;
+    selection: string;
+}
+export declare const colors: Color[];
+export declare const getAvatarColor: (str: string) => {
+    index: number;
+    color: Color;
+};
+export declare const findPointers: (id: string, decorations: DecorationSet) => Decoration[];
+export declare const createTelepointers: (from: number, to: number, sessionId: string, isSelection: boolean, initial: string) => Decoration<{
+    [key: string]: any;
+}>[];
+export declare const replaceDocument: (doc: any, state: EditorState, version?: number, options?: CollabEditOptions, reserveCursor?: boolean) => import("prosemirror-state").Transaction<any>;
+export declare const scrollToCollabCursor: (editorView: EditorView, participants: CollabParticipant[], sessionId: string | undefined, index: number) => void;
+export declare const getPositionOfTelepointer: (sessionId: string, decorationSet: DecorationSet) => undefined | number;

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

@@ -0,0 +1,11 @@
+import React from 'react';
+import { PluginKey } from 'prosemirror-state';
+import { NextEditorPlugin } from '@atlaskit/editor-common/types';
+import { ContextPanelHandler } from './types';
+export declare const pluginKey: PluginKey<ContextPanelPluginState, any>;
+type ContextPanelPluginState = {
+    handlers: ContextPanelHandler[];
+    contents: React.ReactNode[];
+};
+declare const contextPanelPlugin: NextEditorPlugin<'contextPanel'>;
+export default contextPanelPlugin;

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

@@ -0,0 +1,2 @@
+import { Transaction } from 'prosemirror-state';
+export declare const applyChange: (tr: Transaction) => Transaction;

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

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

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

@@ -0,0 +1,8 @@
+import { Command, CommandDispatch } from '../../types';
+import { MarkType, NodeType } from 'prosemirror-model';
+import { EditorState } from 'prosemirror-state';
+export declare function createToolbarCopyCommandForMark(markType: MarkType): Command;
+export declare function getProvideMarkVisualFeedbackForCopyButtonCommand(markType: MarkType): (state: EditorState, dispatch: CommandDispatch | undefined) => boolean;
+export declare function removeMarkVisualFeedbackForCopyButtonCommand(state: EditorState, dispatch: CommandDispatch | undefined): boolean;
+export declare const createToolbarCopyCommandForNode: (nodeType: NodeType | Array<NodeType>) => Command;
+export declare const resetCopiedState: (nodeType: NodeType | Array<NodeType>, onMouseLeave?: Command) => Command;

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

@@ -0,0 +1,3 @@
+import { NextEditorPlugin } from '@atlaskit/editor-common/types';
+declare const copyButtonPlugin: NextEditorPlugin<'copyButton'>;
+export default copyButtonPlugin;

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

@@ -0,0 +1,12 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { MarkType } from 'prosemirror-model';
+type CopyButtonPluginState = {
+    copied: boolean;
+    markSelection?: {
+        start: number;
+        end: number;
+        markType: MarkType;
+    };
+};
+export declare function copyButtonPlugin(): SafePlugin<CopyButtonPluginState, any>;
+export default copyButtonPlugin;

package/dist/types-ts4.5/plugins/copy-button/pm-plugins/plugin-key.d.ts

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

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

@@ -0,0 +1,12 @@
+import { EditorState } from 'prosemirror-state';
+import { Command } from '../../../src/types';
+import { FloatingToolbarButton, FloatingToolbarItem, MarkOptions, NodeOptions } from '../floating-toolbar/types';
+export declare function getCopyButtonConfig(options: MarkOptions | NodeOptions): FloatingToolbarButton<Command>;
+export declare const showCopyButton: (state?: EditorState) => import("prosemirror-state").Plugin<any, any> | undefined;
+/**
+ * Process floatingToolbar items for copyButton
+ *
+ * If copy button plugin not enabled, remove copy button item from toolbar items
+ * else process copy button to standard floatingtoobarbutton
+ */
+export declare function processCopyButtonItems(state: EditorState): (items: Array<FloatingToolbarItem<Command>>) => Array<FloatingToolbarItem<Command>>;

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

@@ -0,0 +1,8 @@
+import { NodeType } from 'prosemirror-model';
+import { Schema, Node as PMNode } from 'prosemirror-model';
+import { Transaction } from 'prosemirror-state';
+export declare function getSelectedNodeOrNodeParentByNodeType({ nodeType, selection, }: {
+    nodeType: NodeType | Array<NodeType>;
+    selection: Transaction['selection'];
+}): import("prosemirror-utils").ContentNodeWithPos | undefined;
+export declare const toDOM: (node: PMNode, schema: Schema) => Node;

package/dist/types-ts4.5/plugins/custom-autoformat/doc.d.ts

@@ -0,0 +1,6 @@
+import { EditorView } from 'prosemirror-view';
+import { CustomAutoformatState } from './types';
+import { InputRuleHander } from './input-rules';
+import { AutoformatHandler } from '@atlaskit/editor-common/provider-factory';
+export declare const buildHandler: (_regex: string, handler: AutoformatHandler) => InputRuleHander;
+export declare const completeReplacements: (view: EditorView, state: CustomAutoformatState) => void;

package/dist/types-ts4.5/plugins/custom-autoformat/index.d.ts

@@ -0,0 +1,6 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { NextEditorPlugin, PMPluginFactoryParams } from '../../types';
+import { CustomAutoformatState } from './types';
+export declare const createPMPlugin: ({ providerFactory }: PMPluginFactoryParams) => SafePlugin<CustomAutoformatState, any>;
+declare const customAutoformatPlugin: NextEditorPlugin<'customAutoformat'>;
+export default customAutoformatPlugin;

package/dist/types-ts4.5/plugins/custom-autoformat/input-rules.d.ts

@@ -0,0 +1,9 @@
+import { EditorView } from 'prosemirror-view';
+import { AutoformatReplacement } from '@atlaskit/editor-common/provider-factory';
+export type InputRuleHander = (view: EditorView, match: string[], start: number, end: number) => Promise<AutoformatReplacement>;
+export type InputRule = {
+    matchTyping: RegExp;
+    matchEnter: RegExp;
+    handler: InputRuleHander;
+};
+export declare const triggerInputRule: (view: EditorView, rules: Array<InputRule>, from: number, to: number, text: string) => boolean;

package/dist/types-ts4.5/plugins/custom-autoformat/reducers.d.ts

@@ -0,0 +1,4 @@
+import { CustomAutoformatState, CustomAutoformatAction } from './types';
+type Reducer<ActionType> = (state: CustomAutoformatState, action: ActionType) => CustomAutoformatState;
+declare const reduce: Reducer<CustomAutoformatAction>;
+export default reduce;

package/dist/types-ts4.5/plugins/custom-autoformat/types.d.ts

@@ -0,0 +1,31 @@
+import { Node as ProsemirrorNode } from 'prosemirror-model';
+export type { AutoformatHandler, AutoformatReplacement, AutoformattingProvider, AutoformatRuleset as Ruleset, } from '@atlaskit/editor-common/provider-factory';
+export type AutoformatCandidate = {
+    start: number;
+    end: number;
+    match: string[];
+};
+export type AutoformatMatch = {
+    matchString: string;
+    replacement?: ProsemirrorNode;
+};
+export type CustomAutoformatState = {
+    resolving: Array<AutoformatCandidate>;
+    matches: Array<AutoformatMatch>;
+};
+export type CustomAutoformatMatched = {
+    action: 'matched';
+    start: number;
+    end: number;
+    match: string[];
+};
+export type CustomAutoformatResolved = {
+    action: 'resolved';
+    matchString: string;
+    replacement?: ProsemirrorNode;
+};
+export type CustomAutoformatFinish = {
+    action: 'finish';
+    matchString: string;
+};
+export type CustomAutoformatAction = CustomAutoformatMatched | CustomAutoformatResolved | CustomAutoformatFinish;

package/dist/types-ts4.5/plugins/custom-autoformat/utils.d.ts

@@ -0,0 +1,5 @@
+import { PluginKey, EditorState, Transaction } from 'prosemirror-state';
+import { CustomAutoformatState, CustomAutoformatAction } from './types';
+export declare const pluginKey: PluginKey<any, any>;
+export declare const getPluginState: (editorState: EditorState) => CustomAutoformatState | undefined;
+export declare const autoformatAction: (tr: Transaction, action: CustomAutoformatAction) => Transaction;

package/dist/types-ts4.5/plugins/data-consumer/index.d.ts

@@ -0,0 +1,3 @@
+import { NextEditorPlugin } from '@atlaskit/editor-common/types';
+declare const dataConsumerMarkPlugin: NextEditorPlugin<'dataConsumerPlugin'>;
+export default dataConsumerMarkPlugin;

package/dist/types-ts4.5/plugins/date/actions.d.ts

@@ -0,0 +1,17 @@
+import { EditorState, Transaction } from 'prosemirror-state';
+import { Command, CommandDispatch } from '../../types';
+import { DateType } from './types';
+import { TOOLBAR_MENU_TYPE } from '../insert-block/ui/ToolbarInsertBlock/types';
+import { INPUT_METHOD } from '../analytics';
+export declare const createDate: (isQuickInsertAction?: boolean) => (insert: (node: Node | Object | string, opts?: any) => Transaction, state: EditorState) => Transaction;
+/** Delete the date and close the datepicker */
+export declare const deleteDate: () => Command;
+/** Focus input */
+export declare const focusDateInput: () => (state: EditorState, dispatch: CommandDispatch | undefined) => boolean;
+export declare const insertDate: (date?: DateType, inputMethod?: TOOLBAR_MENU_TYPE, commitMethod?: INPUT_METHOD.PICKER | INPUT_METHOD.KEYBOARD, enterPressed?: boolean) => Command;
+export declare const setDatePickerAt: (showDatePickerAt: number | null) => (state: EditorState, dispatch: (tr: Transaction) => void) => boolean;
+export declare const closeDatePicker: () => Command;
+export declare const closeDatePickerWithAnalytics: ({ date, }: {
+    date?: DateType | undefined;
+}) => Command;
+export declare const openDatePicker: () => Command;