@atlaskit/editor-core 188.7.0 → 188.7.3

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

@@ -0,0 +1,12 @@
+export type DatePluginState = {
+    isQuickInsertAction?: boolean;
+    isNew: boolean;
+    showDatePickerAt: number | null;
+    isDateEmpty: boolean;
+    focusDateInput: boolean;
+};
+export type DatePluginMeta = {
+    isNew?: boolean;
+    showDatePickerAt?: number | null;
+    isDateEmpty?: boolean;
+};

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

@@ -0,0 +1,5 @@
+import type { ReadonlyTransaction } from '@atlaskit/editor-prosemirror/state';
+import type { DatePluginState, DatePluginMeta } from './types';
+export declare function reducer(pluginState: DatePluginState, meta: DatePluginMeta): DatePluginState;
+export declare function mapping(tr: ReadonlyTransaction, pluginState: DatePluginState): DatePluginState;
+export declare function onSelectionChanged(tr: ReadonlyTransaction, pluginState: DatePluginState): DatePluginState;

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

@@ -0,0 +1,31 @@
+import type { WeekDay } from '@atlaskit/calendar/types';
+import type { NextEditorPlugin } from '@atlaskit/editor-common/types';
+import type { EditorDisabledPlugin } from '@atlaskit/editor-plugin-editor-disabled';
+import type { analyticsPlugin } from '@atlaskit/editor-plugin-analytics';
+import type { insertDate, deleteDate } from './actions';
+export type DateType = {
+    year: number;
+    month: number;
+    day?: number;
+};
+export type DateSegment = 'day' | 'month' | 'year';
+export interface DatePluginConfig {
+    weekStartDay?: WeekDay;
+}
+export type DatePluginSharedState = {
+    showDatePickerAt?: number | null;
+    isNew: boolean;
+    focusDateInput: boolean;
+};
+export type DatePlugin = NextEditorPlugin<'date', {
+    pluginConfiguration: DatePluginConfig | undefined;
+    dependencies: [
+        typeof analyticsPlugin,
+        EditorDisabledPlugin
+    ];
+    sharedState: DatePluginSharedState;
+    actions: {
+        insertDate: typeof insertDate;
+        deleteDate: typeof deleteDate;
+    };
+}>;

package/dist/types-ts4.5/plugins/date/ui/DatePicker/date-picker-input.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import type { WrappedComponentProps } from 'react-intl-next';
+import type { DispatchAnalyticsEvent } from '@atlaskit/editor-common/analytics';
+import type { DateType } from '../../types';
+export interface InputProps {
+    /** Locale code string (eg. "en-AU") */
+    locale: string;
+    date: DateType;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    onNewDate: (date: DateType) => void;
+    onSubmitDate: (date: DateType | null) => void;
+    onEmptySubmit: () => void;
+    /** Automatically focus the text field */
+    autoFocus?: boolean;
+    /** Automatically select all text in the field. Requires autoFocus to be true. */
+    autoSelectAll?: boolean;
+}
+export interface InputState {
+    inputText: string;
+}
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<InputProps & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<InputProps & WrappedComponentProps<"intl">>;
+};
+export default _default;

package/dist/types-ts4.5/plugins/date/ui/DatePicker/index.d.ts

@@ -0,0 +1,36 @@
+/** @jsx jsx */
+import React from 'react';
+import type { WeekDay } from '@atlaskit/calendar/types';
+import type { DateType } from '../../types';
+import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import type { DispatchAnalyticsEvent } from '@atlaskit/editor-common/analytics';
+import type { WrappedComponentProps } from 'react-intl-next';
+export interface Props {
+    element: HTMLElement | null;
+    closeDatePicker: () => void;
+    /** Whether the date is newly created, selcting and focusing the input */
+    isNew: boolean;
+    /** Whether to automatically focus the input */
+    autoFocus?: boolean;
+    onSelect: (date: DateType | null, commitMethod: INPUT_METHOD.PICKER | INPUT_METHOD.KEYBOARD) => void;
+    onDelete: () => void;
+    mountTo?: HTMLElement;
+    boundariesElement?: HTMLElement;
+    scrollableElement?: HTMLElement;
+    closeDatePickerWithAnalytics: ({ date }: {
+        date?: DateType;
+    }) => void;
+    onTextChanged: (date: DateType) => void;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    weekStartDay?: WeekDay;
+}
+export interface State {
+    date: DateType;
+    selected: Array<string>;
+    setInputSelectionPos?: number;
+    latestValidDate: DateType;
+}
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<Props & WrappedComponentProps<"intl">>;
+};
+export default _default;

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

@@ -0,0 +1,27 @@
+import { DateType } from '../types';
+/**
+ * Attempt to parse a string representing a date in a particular locale to a date object
+ * @param dateString The string representing the date in the given locale, eg '02/12/2000'
+ * @param l10n The localisation provider created by createLocalizationProvider
+ * @returns Editor DateType when can parse, null when can't parse or invalid
+ */
+export declare function parseDateType(dateString: string, locale: string): DateType | null;
+/**
+ * Convert an EditorDateType to a date string string formatted for a particular locale
+ * @param date The date object
+ * @param locale The locale code string (eg. "en-AU")
+ * @returns Date string, eg "25/5/20"
+ */
+export declare function formatDateType(date: DateType, locale: string): string;
+/**
+ * Convert an Editor DateType to a JavaScript Date object
+ * @param date Editor DateType
+ * @returns JavaScript Date object
+ */
+export declare function dateTypeToDate(date: DateType): Date;
+/**
+ * Convert a JavaScript Date to an editor DateType
+ * @param date JavaScript Date object
+ * @returns Editor DateType
+ */
+export declare function dateToDateType(date: Date): DateType;

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

@@ -0,0 +1,33 @@
+import type { DateType } from '../types';
+import type { DateSegment } from '../types';
+/**
+ * Inconclusively check if a date string is valid - a value of false means it is definitely
+ * invalid, a value of true means it might be valid.
+ * @param date Date string to be parsed
+ */
+export declare function isDatePossiblyValid(date: string): boolean;
+/**
+ * Find the segment of a date a position refers to. Eg: pos 2 in 29/03/2020 is in
+ * the day segment.
+ * @param position Cursor position, with 0 referring to the left of the first char
+ * @param date The localised date string
+ * @param locale The language to interpret the date string in
+ */
+export declare function findDateSegmentByPosition(position: number, date: string, locale: string): DateSegment | undefined;
+/**
+ * Generate a placeholder date string for a given locale
+ * eg: locale 'hu-HU' -> 'yyyy. mm. dd.'
+ * @param locale A locale string supported by Intl.DateTimeFormat
+ * @returns A placeholder string. d=1 or 2 digit day, dd=zero padded
+ * day, same for month but letter m, yyyy=year
+ */
+export declare function getLocaleDatePlaceholder(locale: string): string | undefined;
+/**
+ * Adjust date segment up or down. Eg. If day is the active segment and adjustment is -1,
+ * reduce the day by one.
+ * @param date Valid datetype
+ * @param activeSegment which part of the date is selected/being adjusted
+ * @param adjustment how many units the segment is being adjusted (can be pos or neg, usually 1 or -1)
+ */
+export declare function adjustDate(date: DateType, activeSegment: DateSegment, adjustment: number): DateType;
+export declare function isToday(date: DateType | undefined): boolean;

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

@@ -0,0 +1,12 @@
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+import type { Node as PMNode, NodeType } from '@atlaskit/editor-prosemirror/model';
+import type { Command } from '../../types';
+export declare const setExpandRef: (ref?: HTMLDivElement | null) => Command;
+export declare const deleteExpandAtPos: (expandNodePos: number, expandNode: PMNode) => Command;
+export declare const deleteExpand: () => Command;
+export declare const updateExpandTitle: (title: string, pos: number, nodeType: NodeType) => Command;
+export declare const toggleExpandExpanded: (pos: number, nodeType: NodeType) => Command;
+export declare const createExpandNode: (state: EditorState) => PMNode | null;
+export declare const insertExpand: Command;
+export declare const focusTitle: (pos: number) => Command;
+export declare const setSelectionInsideExpand: (expandPos: number) => Command;

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

@@ -0,0 +1,24 @@
+import type { NextEditorPlugin, EditorProps } from '../../types';
+import type { LongPressSelectionPluginOptions } from '@atlaskit/editor-common/types';
+import type { FeatureFlagsPlugin } from '@atlaskit/editor-plugin-feature-flags';
+import type { decorationsPlugin } from '@atlaskit/editor-plugin-decorations';
+import type { SelectionPlugin } from '@atlaskit/editor-plugin-selection';
+interface ExpandPluginOptions extends LongPressSelectionPluginOptions {
+    allowInsertion?: boolean;
+    appearance?: EditorProps['appearance'];
+}
+declare const expandPlugin: NextEditorPlugin<'expand', {
+    pluginConfiguration: ExpandPluginOptions | undefined;
+    dependencies: [
+        FeatureFlagsPlugin,
+        typeof decorationsPlugin,
+        SelectionPlugin
+    ];
+}>;
+interface ExpandEditorProps {
+    allowExpand?: EditorProps['allowExpand'];
+}
+export default expandPlugin;
+export type { ExpandPluginState } from './types';
+export declare function isExpandInsertionEnabled({ allowExpand }: ExpandEditorProps): boolean;
+export { pluginKey } from './pm-plugins/plugin-factory';

package/dist/types-ts4.5/plugins/expand/nodeviews/index.d.ts

@@ -0,0 +1,55 @@
+import type { IntlShape } from 'react-intl-next';
+import type { EditorView, NodeView, Decoration } from '@atlaskit/editor-prosemirror/view';
+import type { Node as PmNode } from '@atlaskit/editor-prosemirror/model';
+import type { getPosHandlerNode, getPosHandler } from '../../../nodeviews/';
+import type { FeatureFlags, ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type expandPlugin from '../index';
+import type { SetSelectionRelativeToNode } from '@atlaskit/editor-common/selection';
+export declare class ExpandNodeView implements NodeView {
+    private selectNearNode;
+    node: PmNode;
+    view: EditorView;
+    dom: HTMLElement;
+    contentDOM?: HTMLElement;
+    icon?: HTMLElement | null;
+    input?: HTMLInputElement | null;
+    titleContainer?: HTMLElement | null;
+    content?: HTMLElement | null;
+    getPos: getPosHandlerNode;
+    intl: IntlShape;
+    allowInteractiveExpand: boolean;
+    isMobile: boolean;
+    featureFlags: FeatureFlags;
+    api: ExtractInjectionAPI<typeof expandPlugin> | undefined;
+    constructor(node: PmNode, view: EditorView, getPos: getPosHandlerNode, getIntl: () => IntlShape, isMobile: boolean, featureFlags: FeatureFlags, selectNearNode: SetSelectionRelativeToNode | undefined, api: ExtractInjectionAPI<typeof expandPlugin> | undefined);
+    private initHandlers;
+    private focusTitle;
+    private handleIconKeyDown;
+    private renderIcon;
+    private isAllowInteractiveExpandEnabled;
+    private handleClick;
+    private handleInput;
+    private handleFocus;
+    private handleTitleKeydown;
+    private deleteExpand;
+    private toggleExpand;
+    private moveToOutsideOfTitle;
+    private isCollapsed;
+    private setRightGapCursor;
+    private setLeftGapCursor;
+    private handleArrowRightFromTitle;
+    private handleArrowLeftFromTitle;
+    stopEvent(event: Event): boolean;
+    ignoreMutation(mutationRecord: MutationRecord | {
+        type: 'selection';
+        target: Element;
+    }): boolean;
+    update(node: PmNode, _decorations: readonly Decoration[]): boolean;
+    destroy(): void;
+}
+export default function ({ getIntl, isMobile, featureFlags, api, }: {
+    getIntl: () => IntlShape;
+    isMobile: boolean;
+    featureFlags: FeatureFlags;
+    api: ExtractInjectionAPI<typeof expandPlugin> | undefined;
+}): (node: PmNode, view: EditorView, getPos: getPosHandler) => NodeView;

package/dist/types-ts4.5/plugins/expand/pm-plugins/keymap.d.ts

@@ -0,0 +1,4 @@
+import type { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type expandPlugin from '../index';
+export declare function expandKeymap(api: ExtractInjectionAPI<typeof expandPlugin> | undefined): SafePlugin;

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

@@ -0,0 +1,8 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { Dispatch } from '../../../event-dispatcher';
+import type { EditorProps } from '../../../types';
+import type { IntlShape } from 'react-intl-next';
+import type { FeatureFlags, ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type expandPlugin from '../index';
+export declare function containsClass(element: Element | null, className: string): boolean;
+export declare const createPlugin: (dispatch: Dispatch, getIntl: () => IntlShape, appearance: EditorProps['appearance'], useLongPressSelection: boolean | undefined, featureFlags: FeatureFlags, api: ExtractInjectionAPI<typeof expandPlugin> | undefined) => SafePlugin<import("../types").ExpandPluginState>;

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

@@ -0,0 +1,3 @@
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+export declare const pluginKey: PluginKey<any>;
+export declare const createPluginState: (dispatch: import("@atlaskit/editor-common/event-dispatcher").Dispatch<any>, initialState: import("..").ExpandPluginState | ((state: import("prosemirror-state").EditorState) => import("..").ExpandPluginState)) => import("prosemirror-state").SafeStateField<import("..").ExpandPluginState>, createCommand: <A = import("../types").ExpandPluginAction>(action: A | ((state: Readonly<import("prosemirror-state").EditorState>) => false | A), transform?: ((tr: import("prosemirror-state").Transaction, state: import("prosemirror-state").EditorState) => import("prosemirror-state").Transaction) | undefined) => import("@atlaskit/editor-common/types").Command, getPluginState: (state: import("prosemirror-state").EditorState) => import("..").ExpandPluginState;

package/dist/types-ts4.5/plugins/expand/reducer.d.ts

@@ -0,0 +1,3 @@
+import { ExpandPluginState, ExpandPluginAction } from './types';
+declare const _default: (pluginState: ExpandPluginState, action: ExpandPluginAction) => ExpandPluginState;
+export default _default;

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

@@ -0,0 +1,3 @@
+import type { FloatingToolbarHandler } from '@atlaskit/editor-common/types';
+import type { HoverDecorationHandler } from '@atlaskit/editor-plugin-decorations';
+export declare const getToolbarConfig: (hoverDecoration: HoverDecorationHandler | undefined) => FloatingToolbarHandler;

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

@@ -0,0 +1,9 @@
+export interface ExpandPluginState {
+    expandRef?: HTMLDivElement | null;
+}
+export type ExpandPluginAction = {
+    type: 'SET_EXPAND_REF';
+    data: {
+        ref?: HTMLDivElement | null;
+    };
+};

package/dist/types-ts4.5/plugins/expand/ui/ExpandIconButton.d.ts

@@ -0,0 +1,43 @@
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+import { IntlShape } from 'react-intl-next';
+interface ExpandIconButtonProps {
+    allowInteractiveExpand: boolean;
+    expanded: boolean;
+    intl?: IntlShape;
+}
+interface ExpandIconButtonWithLabelProps extends ExpandIconButtonProps {
+    label: string;
+}
+export declare const withTooltip: (WrapperComponent: React.ElementType) => {
+    new (props: ExpandIconButtonWithLabelProps): {
+        render(): jsx.JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ExpandIconButtonWithLabelProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<ExpandIconButtonWithLabelProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<ExpandIconButtonWithLabelProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<ExpandIconButtonWithLabelProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<ExpandIconButtonWithLabelProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<ExpandIconButtonWithLabelProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<ExpandIconButtonWithLabelProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<ExpandIconButtonWithLabelProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<ExpandIconButtonWithLabelProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    contextType?: React.Context<any> | undefined;
+};
+export declare const CustomButton: (props: ExpandIconButtonWithLabelProps) => jsx.JSX.Element;
+export declare const ExpandIconButton: (props: ExpandIconButtonProps) => jsx.JSX.Element;
+export {};

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

@@ -0,0 +1,11 @@
+export declare const expandClassNames: {
+    prefix: string;
+    expanded: string;
+    titleContainer: string;
+    inputContainer: string;
+    iconContainer: string;
+    icon: string;
+    titleInput: string;
+    content: string;
+    type: (type: string) => string;
+};

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

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

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

@@ -0,0 +1 @@
+export { findExpand, transformSliceToRemoveOpenExpand, transformSliceNestedExpandToExpand, } from '@atlaskit/editor-common/transforms';

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

@@ -0,0 +1,17 @@
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { Schema, Node as PmNode, Fragment, Mark } from '@atlaskit/editor-prosemirror/model';
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+import type { UpdateExtension, ExtensionAPI } from '@atlaskit/editor-common/extensions';
+import type { MacroProvider } from '@atlaskit/editor-common/provider-factory';
+export { transformSliceToRemoveOpenBodiedExtension } from '@atlaskit/editor-common/transforms';
+import type { Command, CommandDispatch } from '../../types';
+import type EditorActions from '../../actions';
+import type { ApplyChangeHandler } from '@atlaskit/editor-plugin-context-panel';
+export declare const buildExtensionNode: <S extends Schema<any, any>>(type: 'inlineExtension' | 'extension' | 'bodiedExtension', schema: S, attrs: object, content?: Fragment, marks?: readonly Mark[]) => PmNode;
+export declare const performNodeUpdate: (type: 'inlineExtension' | 'extension' | 'bodiedExtension', newAttrs: object, content: Fragment, marks: readonly Mark[], shouldScrollIntoView: boolean) => Command;
+export declare const updateExtensionParams: (updateExtension: UpdateExtension<object>, node: {
+    node: PmNode;
+    pos: number;
+}, actions: ExtensionAPI) => (state: EditorState, dispatch?: CommandDispatch, view?: EditorView) => Promise<boolean>;
+export declare const editSelectedExtension: (editorActions: EditorActions) => boolean;
+export declare const editExtension: (macroProvider: MacroProvider | null | undefined, applyChangeToContextPanel: ApplyChangeHandler | undefined, updateExtension?: Promise<UpdateExtension<object> | void>) => Command;

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

@@ -0,0 +1,12 @@
+import type { ExtensionLayout } from '@atlaskit/adf-schema';
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { ExtensionState } from './types';
+import type { Parameters, TransformBefore, TransformAfter } from '@atlaskit/editor-common/src/extensions';
+import type { ApplyChangeHandler } from '@atlaskit/editor-plugin-context-panel';
+export declare function updateState(state: Partial<ExtensionState>): import("@atlaskit/editor-common/types").Command;
+export declare function setEditingContextToContextPanel<T extends Parameters = Parameters>(processParametersBefore: TransformBefore<T>, processParametersAfter: TransformAfter<T>, applyChangeToContextPanel: ApplyChangeHandler | undefined): import("@atlaskit/editor-common/types").Command;
+export declare const clearEditingContext: (applyChangeToContextPanel: ApplyChangeHandler | undefined) => import("@atlaskit/editor-common/types").Command;
+export declare const forceAutoSave: (applyChangeToContextPanel: ApplyChangeHandler | undefined) => (resolve: () => void, reject?: ((reason?: any) => void) | undefined) => import("@atlaskit/editor-common/types").Command;
+export declare const updateExtensionLayout: (layout: ExtensionLayout) => import("@atlaskit/editor-common/types").Command;
+export declare const removeExtension: () => import("@atlaskit/editor-common/types").Command;
+export declare const removeDescendantNodes: (sourceNode?: PMNode) => import("@atlaskit/editor-common/types").Command;

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

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+import type { FeatureFlags } from '@atlaskit/editor-common/types';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { ContentNodeWithPos } from '@atlaskit/editor-prosemirror/utils';
+import type { ApplyChangeHandler } from '@atlaskit/editor-plugin-context-panel';
+export declare const getContextPanel: (allowAutoSave?: boolean, featureFlags?: FeatureFlags, applyChange?: ApplyChangeHandler) => (state: EditorState) => JSX.Element | undefined;
+export declare function onChangeAction(editorView: EditorView, updatedParameters: object | undefined, oldParameters: object | undefined, nodeWithPos: ContentNodeWithPos, onSaving?: () => void): Promise<void>;

package/dist/types-ts4.5/plugins/extension/extension-api.d.ts

@@ -0,0 +1,10 @@
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { MacroProvider } from '../macro';
+import type { CreateExtensionAPI } from '@atlaskit/editor-plugin-extension';
+interface EditInLegacyMacroBrowserArgs {
+    view: EditorView;
+    macroProvider?: MacroProvider;
+}
+export declare const getEditInLegacyMacroBrowser: ({ view, macroProvider, }: EditInLegacyMacroBrowserArgs) => () => void;
+export declare const createExtensionAPI: CreateExtensionAPI;
+export {};

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

@@ -0,0 +1,3 @@
+import type { ExtensionPlugin } from '@atlaskit/editor-plugin-extension';
+declare const extensionPlugin: ExtensionPlugin;
+export default extensionPlugin;

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

@@ -0,0 +1,32 @@
+/// <reference types="react" />
+import type { EditorView, NodeView } from '@atlaskit/editor-prosemirror/view';
+import type { Node as PmNode } from '@atlaskit/editor-prosemirror/model';
+import type { ExtensionHandlers } from '@atlaskit/editor-common/extensions';
+import type { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import type { PluginInjectionAPIWithDependency } from '@atlaskit/editor-common/types';
+import type { EditorAppearance } from '../../../types/editor-appearance';
+import type { ForwardRef, getPosHandler } from '../../../nodeviews';
+import ReactNodeView from '@atlaskit/editor-common/react-node-view';
+import type { PortalProviderAPI } from '@atlaskit/editor-common/portal-provider';
+import type { EventDispatcher } from '../../../event-dispatcher';
+import type { WidthPlugin } from '@atlaskit/editor-plugin-width';
+interface ExtensionNodeViewOptions {
+    appearance?: EditorAppearance;
+}
+export declare class ExtensionNode extends ReactNodeView {
+    ignoreMutation(mutation: MutationRecord | {
+        type: 'selection';
+        target: Element;
+    }): boolean;
+    getContentDOM(): {
+        dom: HTMLDivElement;
+    } | undefined;
+    render(props: {
+        providerFactory: ProviderFactory;
+        extensionHandlers: ExtensionHandlers;
+        extensionNodeViewOptions?: ExtensionNodeViewOptions;
+        pluginInjectionApi: PluginInjectionAPIWithDependency<WidthPlugin> | undefined;
+    }, forwardRef: ForwardRef): JSX.Element;
+}
+export default function ExtensionNodeView(portalProviderAPI: PortalProviderAPI, eventDispatcher: EventDispatcher, providerFactory: ProviderFactory, extensionHandlers: ExtensionHandlers, extensionNodeViewOptions: ExtensionNodeViewOptions, pluginInjectionApi: PluginInjectionAPIWithDependency<WidthPlugin> | undefined): (node: PmNode, view: EditorView, getPos: getPosHandler) => NodeView;
+export {};

package/dist/types-ts4.5/plugins/extension/plugin-factory.d.ts

@@ -0,0 +1,4 @@
+import { ExtensionState } from './types';
+export declare const createPluginState: (dispatch: import("@atlaskit/editor-common/event-dispatcher").Dispatch<any>, initialState: ExtensionState<import("@atlaskit/editor-common/extensions").Parameters> | ((state: import("prosemirror-state").EditorState) => ExtensionState<import("@atlaskit/editor-common/extensions").Parameters>)) => import("prosemirror-state").SafeStateField<ExtensionState<import("@atlaskit/editor-common/extensions").Parameters>>;
+export declare const createCommand: <A = import("./types").ExtensionAction<import("@atlaskit/editor-common/extensions").Parameters>>(action: A | ((state: Readonly<import("prosemirror-state").EditorState>) => false | A), transform?: ((tr: import("prosemirror-state").Transaction, state: import("prosemirror-state").EditorState) => import("prosemirror-state").Transaction) | undefined) => import("@atlaskit/editor-common/types").Command;
+export declare const getPluginState: (state: import("prosemirror-state").EditorState) => ExtensionState<import("@atlaskit/editor-common/extensions").Parameters>;

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

@@ -0,0 +1,3 @@
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+import type { ExtensionState } from './types';
+export declare const pluginKey: PluginKey<ExtensionState<import("@atlaskit/editor-common/extensions").Parameters>>;

package/dist/types-ts4.5/plugins/extension/pm-plugins/keymap.d.ts

@@ -0,0 +1,3 @@
+import type { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { ApplyChangeHandler } from '@atlaskit/editor-plugin-context-panel';
+export default function keymapPlugin(applyChange: ApplyChangeHandler | undefined): SafePlugin;

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

@@ -0,0 +1,27 @@
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { ExtensionHandlers, ExtensionProvider } from '@atlaskit/editor-common/extensions';
+import type { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import type { ContextIdentifierProvider } from '@atlaskit/editor-common/provider-factory';
+import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { ApplyChangeHandler } from '@atlaskit/editor-plugin-context-panel';
+import type { EditorAppearance } from '../../../types/editor-appearance';
+import type { Dispatch, EventDispatcher } from '@atlaskit/editor-common/event-dispatcher';
+import type { PortalProviderAPI } from '@atlaskit/editor-common/portal-provider';
+import { getPluginState, createCommand } from '../plugin-factory';
+import { pluginKey } from '../plugin-key';
+import type extensionPlugin from '../index';
+export declare const createExtensionProviderHandler: (view: EditorView) => (name: string, provider?: Promise<ExtensionProvider>) => Promise<void>;
+export declare const createContextIdentifierProviderHandler: (view: EditorView) => (name: string, provider?: Promise<ContextIdentifierProvider>) => Promise<void>;
+export declare const handleUpdate: ({ view, prevState, domAtPos, extensionHandlers, applyChange, }: {
+    view: EditorView;
+    prevState: EditorState;
+    domAtPos: EditorView['domAtPos'];
+    extensionHandlers: ExtensionHandlers;
+    applyChange: ApplyChangeHandler | undefined;
+}) => true | undefined;
+declare const createPlugin: (dispatch: Dispatch, providerFactory: ProviderFactory, extensionHandlers: ExtensionHandlers, portalProviderAPI: PortalProviderAPI, eventDispatcher: EventDispatcher, pluginInjectionApi: ExtractInjectionAPI<typeof extensionPlugin> | undefined, useLongPressSelection?: boolean, options?: {
+    appearance?: EditorAppearance;
+}) => SafePlugin<import("../types").ExtensionState<import("@atlaskit/editor-common/extensions").Parameters>>;
+export { pluginKey, createPlugin, createCommand, getPluginState };

package/dist/types-ts4.5/plugins/extension/pm-plugins/unique-id.d.ts

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

package/dist/types-ts4.5/plugins/extension/pm-plugins/utils.d.ts

@@ -0,0 +1,3 @@
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { ExtensionProvider } from '@atlaskit/editor-common/extensions';
+export declare const updateEditButton: (view: EditorView, extensionProvider: ExtensionProvider) => Promise<import("@atlaskit/editor-common/extensions").UpdateExtension<any> | undefined>;

package/dist/types-ts4.5/plugins/extension/reducer.d.ts

@@ -0,0 +1,2 @@
+import { ExtensionState, ExtensionAction } from './types';
+export default function (pluginState: ExtensionState, action: ExtensionAction): ExtensionState;

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

@@ -0,0 +1,42 @@
+import type { FloatingToolbarHandler } from '@atlaskit/editor-common/types';
+import type { HoverDecorationHandler } from '@atlaskit/editor-plugin-decorations';
+import type { ApplyChangeHandler } from '@atlaskit/editor-plugin-context-panel';
+export declare const messages: {
+    edit: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    deleteElementTitle: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    unnamedSource: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    confirmDeleteLinkedModalOKButton: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    confirmDeleteLinkedModalMessage: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    confirmModalCheckboxLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};
+interface GetToolbarConfigProps {
+    breakoutEnabled: boolean | undefined;
+    hoverDecoration: HoverDecorationHandler | undefined;
+    applyChangeToContextPanel: ApplyChangeHandler | undefined;
+}
+export declare const getToolbarConfig: ({ breakoutEnabled, hoverDecoration, applyChangeToContextPanel, }: GetToolbarConfigProps) => FloatingToolbarHandler;
+export {};

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

@@ -0,0 +1,22 @@
+import type { ContextIdentifierProvider } from '@atlaskit/editor-common/provider-factory';
+import { UpdateExtension, ExtensionProvider, Parameters, TransformBefore, TransformAfter } from '@atlaskit/editor-common/extensions';
+import type { ApplyChangeHandler } from '@atlaskit/editor-plugin-context-panel';
+export type ExtensionState<T extends Parameters = Parameters> = {
+    localId?: string;
+    autoSaveResolve?: () => void;
+    autoSaveReject?: (reason?: any) => void;
+    showEditButton: boolean;
+    showContextPanel: boolean;
+    updateExtension?: Promise<UpdateExtension<T> | void>;
+    element?: HTMLElement;
+    extensionProvider?: ExtensionProvider<T>;
+    contextIdentifierProvider?: ContextIdentifierProvider;
+    processParametersBefore?: TransformBefore<T>;
+    processParametersAfter?: TransformAfter<T>;
+    positions?: Record<number, number>;
+    applyChangeToContextPanel: ApplyChangeHandler | undefined;
+};
+export type ExtensionAction<T extends Parameters = Parameters> = {
+    type: 'UPDATE_STATE';
+    data: Partial<ExtensionState<T>>;
+};