@atlaskit/editor-common 107.28.2 → 107.30.0

package/dist/types-ts4.5/element-browser/components/StatelessElementBrowser.d.ts

@@ -9,18 +9,20 @@ import type { QuickInsertItem } from '../../provider-factory';
 import type { EmptyStateHandler } from '../../types';
 import type { Category, Modes } from '../types';
 export type StatelessElementBrowserProps = {
+    cache?: CellMeasurerCache;
     categories?: Category[];
+    emptyStateHandler?: EmptyStateHandler;
     items: QuickInsertItem[];
+    mode: keyof typeof Modes;
+    onInsertItem: (item: QuickInsertItem) => void;
     onSearch: (searchTerm: string) => void;
     onSelectCategory: (category: Category) => void;
     onSelectItem?: (item: QuickInsertItem) => void;
-    onInsertItem: (item: QuickInsertItem) => void;
+    onViewMore?: () => void;
+    searchTerm?: string;
     selectedCategory?: string;
-    showSearch: boolean;
     showCategories: boolean;
-    mode: keyof typeof Modes;
-    searchTerm?: string;
-    emptyStateHandler?: EmptyStateHandler;
+    showSearch: boolean;
     /**
      * @private
      * @deprecated
@@ -28,22 +30,22 @@ export type StatelessElementBrowserProps = {
      * Please clean up viewMoreItem when cleaning up platform_editor_refactor_view_more
      */
     viewMoreItem?: QuickInsertItem;
-    onViewMore?: () => void;
-    cache?: CellMeasurerCache;
 } & WithAnalyticsEventsProps;
 declare const MemoizedElementBrowser: React.MemoExoticComponent<React.ForwardRefExoticComponent<Omit<Omit<{
+    cache?: CellMeasurerCache;
     categories?: Category[];
+    emptyStateHandler?: EmptyStateHandler;
     items: QuickInsertItem[];
+    mode: keyof typeof Modes;
+    onInsertItem: (item: QuickInsertItem) => void;
     onSearch: (searchTerm: string) => void;
     onSelectCategory: (category: Category) => void;
     onSelectItem?: (item: QuickInsertItem) => void;
-    onInsertItem: (item: QuickInsertItem) => void;
+    onViewMore?: () => void;
+    searchTerm?: string;
     selectedCategory?: string;
-    showSearch: boolean;
     showCategories: boolean;
-    mode: keyof typeof Modes;
-    searchTerm?: string;
-    emptyStateHandler?: EmptyStateHandler;
+    showSearch: boolean;
     /**
      * @private
      * @deprecated
@@ -51,7 +53,5 @@ declare const MemoizedElementBrowser: React.MemoExoticComponent<React.ForwardRef
      * Please clean up viewMoreItem when cleaning up platform_editor_refactor_view_more
      */
     viewMoreItem?: QuickInsertItem;
-    onViewMore?: () => void;
-    cache?: CellMeasurerCache;
 }, keyof WithAnalyticsEventsProps> & React.RefAttributes<any> & import("@atlaskit/analytics-next").WithContextProps, "ref"> & React.RefAttributes<any>>>;
 export default MemoizedElementBrowser;

package/dist/types-ts4.5/element-browser/hooks/use-select-and-focus-on-arrow-navigation.d.ts

@@ -39,14 +39,14 @@ import type React from 'react';
  *
  */
 type ReducerState = {
+    canFocusViewMore?: boolean;
+    focusedCategoryIndex?: number;
+    focusedItemIndex?: number;
+    focusOnEmptyStateButton?: boolean;
     focusOnSearch: boolean;
     focusOnViewMore: boolean;
-    focusOnEmptyStateButton?: boolean;
-    selectedItemIndex?: number;
-    focusedItemIndex?: number;
     listSize: number;
-    canFocusViewMore?: boolean;
-    focusedCategoryIndex?: number;
+    selectedItemIndex?: number;
 };
 export declare enum ACTIONS {
     FOCUS_SEARCH = "focusOnSearch",
@@ -54,22 +54,22 @@ export declare enum ACTIONS {
     MOVE = "move"
 }
 export type ReducerAction = {
-    type: ACTIONS;
     payload: Partial<ReducerState> & {
         positions?: number;
         step?: number;
     };
+    type: ACTIONS;
 };
 export type useSelectAndFocusReturnType = {
-    selectedItemIndex?: number;
-    onKeyDown: (e: React.KeyboardEvent<HTMLDivElement>) => void;
+    focusedCategoryIndex?: number;
+    focusedItemIndex?: number;
+    focusOnEmptyStateButton?: boolean;
     focusOnSearch: boolean;
     focusOnViewMore: boolean;
-    focusOnEmptyStateButton?: boolean;
-    focusedItemIndex?: number;
-    focusedCategoryIndex?: number;
-    setFocusedItemIndex: (index?: number) => void;
+    onKeyDown: (e: React.KeyboardEvent<HTMLDivElement>) => void;
+    selectedItemIndex?: number;
     setFocusedCategoryIndex: (index?: number) => void;
+    setFocusedItemIndex: (index?: number) => void;
     setFocusOnSearch: () => void;
 };
 declare function useSelectAndFocusOnArrowNavigation(listSize: number, step: number, canFocusViewMore: boolean, itemIsDisabled: (index: number) => boolean, isFocusSearch?: boolean): useSelectAndFocusReturnType;

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

@@ -1,12 +1,12 @@
 export type Category = {
-    title: string;
     name: string;
+    title: string;
 };
 export declare enum Modes {
     full = "full",
     inline = "inline"
 }
 export type SelectedItemProps = {
-    selectedItemIndex?: number;
     focusedItemIndex?: number;
+    selectedItemIndex?: number;
 };

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

@@ -7,26 +7,26 @@ import type { EditorAppearance } from '../../../types';
 import type { OverflowShadowProps } from '../../../ui';
 import type { ExtensionsPluginInjectionAPI, MacroInteractionDesignFeatureFlags } from '../../types';
 export interface Props {
-    node: PmNode;
-    getPos: ProsemirrorGetPosHandler;
-    view: EditorView;
+    children?: React.ReactNode;
+    editorAppearance?: EditorAppearance;
     extensionProvider?: ExtensionProvider;
+    getPos: ProsemirrorGetPosHandler;
     handleContentDOMRef: (node: HTMLElement | null) => void;
-    children?: React.ReactNode;
-    references?: ReferenceEntity[];
     hideFrame?: boolean;
-    editorAppearance?: EditorAppearance;
-    pluginInjectionApi: ExtensionsPluginInjectionAPI;
-    macroInteractionDesignFeatureFlags?: MacroInteractionDesignFeatureFlags;
-    isNodeSelected?: boolean;
+    isLivePageViewMode?: boolean;
     isNodeHovered?: boolean;
     isNodeNested?: boolean;
+    isNodeSelected?: boolean;
+    macroInteractionDesignFeatureFlags?: MacroInteractionDesignFeatureFlags;
+    node: PmNode;
+    pluginInjectionApi: ExtensionsPluginInjectionAPI;
+    references?: ReferenceEntity[];
     setIsNodeHovered?: (isHovered: boolean) => void;
+    setShowBodiedExtensionRendererView?: (showBodiedExtensionRendererView: boolean) => void;
+    showBodiedExtensionRendererView?: boolean;
     showLivePagesBodiedMacrosRendererView?: boolean;
     showUpdatedLivePages1PBodiedExtensionUI?: boolean;
-    showBodiedExtensionRendererView?: boolean;
-    setShowBodiedExtensionRendererView?: (showBodiedExtensionRendererView: boolean) => void;
-    isLivePageViewMode?: boolean;
+    view: EditorView;
 }
 declare const _default: {
     new (props: (Props & OverflowShadowProps) | Readonly<Props & OverflowShadowProps>): {

package/dist/types-ts4.5/extensibility/Extension/InlineExtension/index.d.ts

@@ -7,14 +7,14 @@ import { jsx } from '@emotion/react';
 import type { Node as PmNode } from '@atlaskit/editor-prosemirror/model';
 import type { ExtensionsPluginInjectionAPI, MacroInteractionDesignFeatureFlags } from '../../types';
 export interface Props {
-    node: PmNode;
-    pluginInjectionApi: ExtensionsPluginInjectionAPI;
     children?: React.ReactNode;
-    macroInteractionDesignFeatureFlags?: MacroInteractionDesignFeatureFlags;
-    isNodeSelected?: boolean;
+    isLivePageViewMode?: boolean;
     isNodeHovered?: boolean;
+    isNodeSelected?: boolean;
+    macroInteractionDesignFeatureFlags?: MacroInteractionDesignFeatureFlags;
+    node: PmNode;
+    pluginInjectionApi: ExtensionsPluginInjectionAPI;
     setIsNodeHovered?: (isHovered: boolean) => void;
-    isLivePageViewMode?: boolean;
 }
 declare const InlineExtension: (props: Props) => jsx.JSX.Element;
 export default InlineExtension;

package/dist/types-ts4.5/extensibility/Extension/LegacyContentHeader/index.d.ts

@@ -4,8 +4,8 @@
  */
 import { jsx } from '@emotion/react';
 export type LegacyContentHeaderProps = {
-    isNodeSelected?: boolean;
     isNodeHovered?: boolean;
+    isNodeSelected?: boolean;
     onMouseEnter?: () => void;
     onMouseLeave?: () => void;
 };

package/dist/types-ts4.5/extensibility/Extension/Lozenge/EditToggle.d.ts

@@ -5,11 +5,11 @@
 import type { CSSProperties } from 'react';
 import { jsx } from '@emotion/react';
 type EditToggleProps = {
-    isNodeHovered?: boolean;
     customContainerStyles?: CSSProperties;
+    isNodeHovered?: boolean;
     setIsNodeHovered?: (isNodeHovered: boolean) => void;
-    showBodiedExtensionRendererView?: boolean;
     setShowBodiedExtensionRendererView?: (showBodiedExtensionRendererView: boolean) => void;
+    showBodiedExtensionRendererView?: boolean;
 };
 export declare const EditToggle: ({ isNodeHovered, customContainerStyles, setIsNodeHovered, showBodiedExtensionRendererView, setShowBodiedExtensionRendererView, }: EditToggleProps) => jsx.JSX.Element;
 export {};

package/dist/types-ts4.5/extensibility/Extension/Lozenge/ExtensionLabel.d.ts

@@ -7,17 +7,17 @@ import { jsx } from '@emotion/react';
 import { type ExtensionsPluginInjectionAPI } from '../../types';
 export declare const getShouldShowBodiedMacroLabel: (isBodiedMacro: boolean | undefined, isNodeHovered: boolean | undefined, showLivePagesBodiedMacrosRendererView: boolean | undefined, showBodiedExtensionRendererView: boolean | undefined, showUpdatedLivePages1PBodiedExtensionUI: boolean | undefined) => boolean | undefined;
 type ExtensionLabelProps = {
-    text: string;
+    customContainerStyles?: CSSProperties;
     extensionName: string;
+    isBodiedMacro?: boolean;
     isNodeHovered?: boolean;
     isNodeNested?: boolean;
-    customContainerStyles?: CSSProperties;
+    pluginInjectionApi?: ExtensionsPluginInjectionAPI;
     setIsNodeHovered?: (isHovered: boolean) => void;
-    isBodiedMacro?: boolean;
-    showUpdatedLivePages1PBodiedExtensionUI?: boolean;
-    showLivePagesBodiedMacrosRendererView?: boolean;
     showBodiedExtensionRendererView?: boolean;
-    pluginInjectionApi?: ExtensionsPluginInjectionAPI;
+    showLivePagesBodiedMacrosRendererView?: boolean;
+    showUpdatedLivePages1PBodiedExtensionUI?: boolean;
+    text: string;
 };
 export declare const ExtensionLabel: ({ text, extensionName, isNodeHovered, customContainerStyles, isNodeNested, setIsNodeHovered, isBodiedMacro, showUpdatedLivePages1PBodiedExtensionUI, showLivePagesBodiedMacrosRendererView, showBodiedExtensionRendererView, pluginInjectionApi, }: ExtensionLabelProps) => jsx.JSX.Element;
 export {};

package/dist/types-ts4.5/extensibility/Extension/Lozenge/LozengeComponent.d.ts

@@ -4,23 +4,23 @@ import { type ExtensionsPluginInjectionAPI } from '../../types';
 import type { LozengeData } from './index';
 export declare const ICON_SIZE = 24;
 type LozengeComponentProps = {
-    lozengeData?: LozengeData;
-    extensionName: string;
-    title: string;
-    params: any;
-    renderImage: (lozengeData: LozengeData) => void;
-    isNodeSelected?: boolean;
-    showMacroInteractionDesignUpdates?: boolean;
     customContainerStyles?: CSSProperties;
+    extensionName: string;
+    isBodiedMacro?: boolean;
     isNodeHovered?: boolean;
     isNodeNested?: boolean;
+    isNodeSelected?: boolean;
+    lozengeData?: LozengeData;
+    params: any;
+    pluginInjectionApi?: ExtensionsPluginInjectionAPI;
+    renderImage: (lozengeData: LozengeData) => void;
     setIsNodeHovered?: (isHovered: boolean) => void;
-    isBodiedMacro?: boolean;
+    setShowBodiedExtensionRendererView?: (showBodiedExtensionRendererView: boolean) => void;
+    showBodiedExtensionRendererView?: boolean;
     showLivePagesBodiedMacrosRendererView?: boolean;
+    showMacroInteractionDesignUpdates?: boolean;
     showUpdatedLivePages1PBodiedExtensionUI?: boolean;
-    showBodiedExtensionRendererView?: boolean;
-    setShowBodiedExtensionRendererView?: (showBodiedExtensionRendererView: boolean) => void;
-    pluginInjectionApi?: ExtensionsPluginInjectionAPI;
+    title: string;
 };
 export declare const LozengeComponent: ({ lozengeData, extensionName, title, params, renderImage, showMacroInteractionDesignUpdates, customContainerStyles, isNodeHovered, isNodeNested, setIsNodeHovered, isBodiedMacro, showLivePagesBodiedMacrosRendererView, showUpdatedLivePages1PBodiedExtensionUI, showBodiedExtensionRendererView, setShowBodiedExtensionRendererView, pluginInjectionApi, }: LozengeComponentProps) => jsx.JSX.Element;
 export {};

package/dist/types-ts4.5/extensibility/Extension/Lozenge/index.d.ts

@@ -8,23 +8,23 @@ import { jsx } from '@emotion/react';
 import type { Node as PmNode } from '@atlaskit/editor-prosemirror/model';
 import { type ExtensionsPluginInjectionAPI } from '../../types';
 export interface Props {
-    node: PmNode;
-    showMacroInteractionDesignUpdates?: boolean;
-    isNodeSelected?: boolean;
+    customContainerStyles?: CSSProperties;
+    isBodiedMacro?: boolean;
     isNodeHovered?: boolean;
     isNodeNested?: boolean;
-    customContainerStyles?: CSSProperties;
+    isNodeSelected?: boolean;
+    node: PmNode;
+    pluginInjectionApi?: ExtensionsPluginInjectionAPI;
     setIsNodeHovered?: (isHovered: boolean) => void;
-    isBodiedMacro?: boolean;
+    setShowBodiedExtensionRendererView?: (showBodiedExtensionRendererView: boolean) => void;
+    showBodiedExtensionRendererView?: boolean;
     showLivePagesBodiedMacrosRendererView?: boolean;
+    showMacroInteractionDesignUpdates?: boolean;
     showUpdatedLivePages1PBodiedExtensionUI?: boolean;
-    showBodiedExtensionRendererView?: boolean;
-    setShowBodiedExtensionRendererView?: (showBodiedExtensionRendererView: boolean) => void;
-    pluginInjectionApi?: ExtensionsPluginInjectionAPI;
 }
 export interface LozengeData {
-    url: string;
     height?: number;
+    url: string;
     width?: number;
 }
 export default class ExtensionLozenge extends Component<Props, any> {

package/dist/types-ts4.5/extensibility/Extension.d.ts

@@ -9,20 +9,20 @@ import type { ProsemirrorGetPosHandler } from '../react-node-view';
 import type { EditorAppearance } from '../types';
 import type { ExtensionsPluginInjectionAPI, MacroInteractionDesignFeatureFlags } from './types';
 export interface Props {
+    editorAppearance?: EditorAppearance;
     editorView: EditorView;
-    node: PMNode;
+    eventDispatcher?: EventDispatcher;
+    extensionHandlers: ExtensionHandlers;
     getPos: ProsemirrorGetPosHandler;
-    providerFactory?: ProviderFactory;
     handleContentDOMRef: (node: HTMLElement | null) => void;
-    extensionHandlers: ExtensionHandlers;
-    references?: ReferenceEntity[];
-    editorAppearance?: EditorAppearance;
-    pluginInjectionApi: ExtensionsPluginInjectionAPI;
-    eventDispatcher?: EventDispatcher;
     macroInteractionDesignFeatureFlags?: MacroInteractionDesignFeatureFlags;
+    node: PMNode;
+    pluginInjectionApi: ExtensionsPluginInjectionAPI;
+    providerFactory?: ProviderFactory;
+    references?: ReferenceEntity[];
+    rendererExtensionHandlers?: ExtensionHandlers;
     showLivePagesBodiedMacrosRendererView?: (node: ADFEntity) => boolean;
     showUpdatedLivePages1PBodiedExtensionUI?: (node: ADFEntity) => boolean;
-    rendererExtensionHandlers?: ExtensionHandlers;
 }
 export declare class Extension extends Component<Props, any> {
     static displayName: string;

package/dist/types-ts4.5/extensibility/ExtensionComponent.d.ts

@@ -8,37 +8,37 @@ import type { ProsemirrorGetPosHandler } from '../react-node-view';
 import type { EditorAppearance } from '../types';
 import type { ExtensionsPluginInjectionAPI, MacroInteractionDesignFeatureFlags } from './types';
 export interface Props {
+    editorAppearance?: EditorAppearance;
     editorView: EditorView;
-    node: PMNode;
-    getPos: ProsemirrorGetPosHandler;
-    handleContentDOMRef: (node: HTMLElement | null) => void;
+    eventDispatcher?: EventDispatcher;
     extensionHandlers: ExtensionHandlers;
     extensionProvider?: Promise<ExtensionProvider>;
-    references?: ReferenceEntity[];
-    editorAppearance?: EditorAppearance;
-    pluginInjectionApi: ExtensionsPluginInjectionAPI;
-    eventDispatcher?: EventDispatcher;
+    getPos: ProsemirrorGetPosHandler;
+    handleContentDOMRef: (node: HTMLElement | null) => void;
+    isLivePageViewMode?: boolean;
     macroInteractionDesignFeatureFlags?: MacroInteractionDesignFeatureFlags;
+    node: PMNode;
+    pluginInjectionApi: ExtensionsPluginInjectionAPI;
+    references?: ReferenceEntity[];
+    rendererExtensionHandlers?: ExtensionHandlers;
     showLivePagesBodiedMacrosRendererView?: (node: ADFEntity) => boolean;
     showUpdatedLivePages1PBodiedExtensionUI?: (node: ADFEntity) => boolean;
-    rendererExtensionHandlers?: ExtensionHandlers;
-    isLivePageViewMode?: boolean;
 }
 export interface State {
-    extensionProvider?: ExtensionProvider;
-    extensionHandlersFromProvider?: ExtensionHandlers;
     _privateProps?: {
-        __hideFrame?: boolean;
         __allowBodiedOverride?: boolean;
+        __hideFrame?: boolean;
     };
     activeChildIndex?: number;
+    extensionHandlersFromProvider?: ExtensionHandlers;
+    extensionProvider?: ExtensionProvider;
     isNodeHovered?: boolean;
     showBodiedExtensionRendererView?: boolean;
 }
 export type PropsNew = Omit<Props, 'extensionProvider'> & {
     extensionProvider?: ExtensionProvider;
-    showBodiedExtensionRendererView?: boolean;
     setShowBodiedExtensionRendererView?: (showBodiedExtensionRendererView: boolean) => void;
+    showBodiedExtensionRendererView?: boolean;
 };
 export type StateNew = Omit<State, 'extensionProvider' | 'showBodiedExtensionRendererView'>;
 export declare const ExtensionComponent: (props: Props) => React.JSX.Element;

package/dist/types-ts4.5/extensibility/ExtensionNodeWrapper.d.ts

@@ -8,8 +8,8 @@ import { jsx } from '@emotion/react';
 import type { MacroInteractionDesignFeatureFlags } from './types';
 type Props = {
     children: React.ReactNode;
-    nodeType: string;
     macroInteractionDesignFeatureFlags?: MacroInteractionDesignFeatureFlags;
+    nodeType: string;
 };
 /**
  * If inlineExtension, add zero width space to the end of the nodes and wrap with span;

package/dist/types-ts4.5/extensibility/MultiBodiedExtension/action-api.d.ts

@@ -4,13 +4,13 @@ import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { EventDispatcher } from '../../event-dispatcher';
 import type { MultiBodiedExtensionActions } from '../../extensions';
 type ActionsProps = {
-    updateActiveChild: (index: number) => boolean;
-    node: PmNode;
-    editorView: EditorView;
-    getPos: () => number | undefined;
-    eventDispatcher?: EventDispatcher;
     allowBodiedOverride: boolean;
     childrenContainer: React.ReactNode;
+    editorView: EditorView;
+    eventDispatcher?: EventDispatcher;
+    getPos: () => number | undefined;
+    node: PmNode;
+    updateActiveChild: (index: number) => boolean;
 };
 export declare const useMultiBodiedExtensionActions: ({ updateActiveChild, editorView, getPos, node, eventDispatcher, allowBodiedOverride, childrenContainer, }: ActionsProps) => MultiBodiedExtensionActions;
 export {};

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

@@ -13,21 +13,21 @@ import type { OverflowShadowProps } from '../../ui';
 import type { ExtensionsPluginInjectionAPI, MacroInteractionDesignFeatureFlags } from '../types';
 export type TryExtensionHandlerType = (actions: MultiBodiedExtensionActions | undefined) => React.ReactElement | null;
 type Props = {
-    node: PmNode;
-    handleContentDOMRef: (node: HTMLElement | null) => void;
+    allowBodiedOverride?: boolean;
+    editorAppearance?: EditorAppearance;
     editorView: EditorView;
-    getPos: () => number | undefined;
-    tryExtensionHandler: TryExtensionHandlerType;
     eventDispatcher?: EventDispatcher;
-    pluginInjectionApi?: ExtensionsPluginInjectionAPI;
-    editorAppearance?: EditorAppearance;
-    macroInteractionDesignFeatureFlags?: MacroInteractionDesignFeatureFlags;
-    isNodeSelected?: boolean;
+    getPos: () => number | undefined;
+    handleContentDOMRef: (node: HTMLElement | null) => void;
+    isLivePageViewMode?: boolean;
     isNodeHovered?: boolean;
     isNodeNested?: boolean;
+    isNodeSelected?: boolean;
+    macroInteractionDesignFeatureFlags?: MacroInteractionDesignFeatureFlags;
+    node: PmNode;
+    pluginInjectionApi?: ExtensionsPluginInjectionAPI;
     setIsNodeHovered?: (isHovered: boolean) => void;
-    isLivePageViewMode?: boolean;
-    allowBodiedOverride?: boolean;
+    tryExtensionHandler: TryExtensionHandlerType;
 };
 declare const MultiBodiedExtension: (props: Props & OverflowShadowProps) => jsx.JSX.Element;
 export default MultiBodiedExtension;

package/dist/types-ts4.5/extensibility/extensionNodeView.d.ts

@@ -15,19 +15,19 @@ interface ExtensionNodeViewOptions {
     getExtensionHeight?: GetPMNodeHeight;
 }
 interface ReactExtensionNodeProps {
-    extensionNodeViewOptions?: ExtensionNodeViewOptions;
-    providerFactory: ProviderFactory;
     extensionHandlers: ExtensionHandlers;
-    pluginInjectionApi: ExtensionsPluginInjectionAPI;
+    extensionNodeViewOptions?: ExtensionNodeViewOptions;
     macroInteractionDesignFeatureFlags?: MacroInteractionDesignFeatureFlags;
+    pluginInjectionApi: ExtensionsPluginInjectionAPI;
+    providerFactory: ProviderFactory;
+    rendererExtensionHandlers?: ExtensionHandlers;
     showLivePagesBodiedMacrosRendererView?: (node: ADFEntity) => boolean;
     showUpdatedLivePages1PBodiedExtensionUI?: (node: ADFEntity) => boolean;
-    rendererExtensionHandlers?: ExtensionHandlers;
 }
 export declare class ExtensionNode<AdditionalParams = unknown> extends ReactNodeView<ReactExtensionNodeProps & AdditionalParams> {
     ignoreMutation(mutation: MutationRecord | {
-        type: 'selection';
         target: Node;
+        type: 'selection';
     }): boolean;
     createDomRef(): HTMLElement;
     /**
@@ -45,14 +45,14 @@ export declare class ExtensionNode<AdditionalParams = unknown> extends ReactNode
         dom: HTMLDivElement;
     } | undefined;
     render(props: {
-        providerFactory: ProviderFactory;
         extensionHandlers: ExtensionHandlers;
         extensionNodeViewOptions?: ExtensionNodeViewOptions;
-        pluginInjectionApi: ExtensionsPluginInjectionAPI;
         macroInteractionDesignFeatureFlags?: MacroInteractionDesignFeatureFlags;
+        pluginInjectionApi: ExtensionsPluginInjectionAPI;
+        providerFactory: ProviderFactory;
+        rendererExtensionHandlers?: ExtensionHandlers;
         showLivePagesBodiedMacrosRendererView?: (node: ADFEntity) => boolean;
         showUpdatedLivePages1PBodiedExtensionUI?: (node: ADFEntity) => boolean;
-        rendererExtensionHandlers?: ExtensionHandlers;
     }, forwardRef: ForwardRef): React.JSX.Element;
 }
 export default function ExtensionNodeView(portalProviderAPI: PortalProviderAPI, eventDispatcher: EventDispatcher, providerFactory: ProviderFactory, extensionHandlers: ExtensionHandlers, extensionNodeViewOptions: ExtensionNodeViewOptions, pluginInjectionApi: ExtensionsPluginInjectionAPI, macroInteractionDesignFeatureFlags?: MacroInteractionDesignFeatureFlags, showLivePagesBodiedMacrosRendererView?: (node: ADFEntity) => boolean, showUpdatedLivePages1PBodiedExtensionUI?: (node: ADFEntity) => boolean, rendererExtensionHandlers?: ExtensionHandlers): (node: PmNode, view: EditorView, getPos: getPosHandler) => NodeView;

package/dist/types-ts4.5/extensions/extension-handlers.d.ts

@@ -13,7 +13,7 @@ export declare function getExtensionModuleNodePrivateProps(extensionProvider: Ex
     [prop: string]: any;
 }>;
 export declare function getNodeRenderer<T extends Parameters>(extensionProvider: ExtensionProvider, extensionType: ExtensionType, extensionKey: ExtensionKey): React.ComponentType<{
+    actions?: MultiBodiedExtensionActions;
     node: ExtensionParams<T>;
     references?: ReferenceEntity[];
-    actions?: MultiBodiedExtensionActions;
 }> & Loadable.LoadableComponent;

package/dist/types-ts4.5/extensions/types/extension-handler.d.ts

@@ -2,14 +2,14 @@ import type { ADFEntity } from '@atlaskit/adf-utils/types';
 import type { NodeWithPos } from '@atlaskit/editor-prosemirror/utils';
 import type { Parameters } from './extension-parameters';
 export interface ExtensionParams<T extends Parameters> {
+    content?: object | string;
     extensionKey: string;
     extensionType: string;
-    type?: 'extension' | 'inlineExtension' | 'bodiedExtension' | 'multiBodiedExtension';
-    parameters?: T;
-    content?: object | string;
-    localId?: string;
     fragmentLocalId?: string;
     layout?: string;
+    localId?: string;
+    parameters?: T;
+    type?: 'extension' | 'inlineExtension' | 'bodiedExtension' | 'multiBodiedExtension';
 }
 export type ExtensionHandler<T extends Parameters = Parameters> = (ext: ExtensionParams<T>, doc: object, actions?: MultiBodiedExtensionActions) => JSX.Element | null;
 export type OnSaveCallback<T extends Parameters = Parameters> = (params: T) => void;
@@ -17,13 +17,11 @@ export type OnSaveCallbackAsync<T extends Parameters = Parameters> = (params: T)
 export type TransformBefore<T extends Parameters = Parameters> = (data: T) => any;
 export type TransformAfter<T extends Parameters = Parameters> = (data: any) => Promise<Partial<T>>;
 export type ExtensionAPI<T extends Parameters = Parameters> = {
-    editInContextPanel: (transformBefore: TransformBefore<T>, transformAfter: TransformAfter<T>) => void;
     _editInLegacyMacroBrowser: () => void;
-    getNodeWithPosByLocalId: (localId: string) => NodeWithPos;
     doc: {
         insertAfter: (localId: string, adf: ADFEntity, options?: {
-            allowSelectionToNewNode?: boolean;
             allowSelectionNearNewNode?: boolean;
+            allowSelectionToNewNode?: boolean;
         }) => void;
         scrollTo: (localId: string) => void;
         update: (localId: string, mutationCallback: (currentValue: Pick<ADFEntity, 'content' | 'attrs' | 'marks'>) => Pick<ADFEntity, 'content' | 'attrs' | 'marks'>, options?: {
@@ -31,6 +29,8 @@ export type ExtensionAPI<T extends Parameters = Parameters> = {
             scrollIntoView?: boolean;
         }) => void;
     };
+    editInContextPanel: (transformBefore: TransformBefore<T>, transformAfter: TransformAfter<T>) => void;
+    getNodeWithPosByLocalId: (localId: string) => NodeWithPos;
 };
 export type UpdateExtension<T extends Parameters = Parameters> = (extensionParameters: T, actions?: ExtensionAPI<T>) => Promise<T | void>;
 export interface Extension<T extends Parameters = Parameters> {
@@ -44,13 +44,13 @@ export type ReferenceEntity = {
     [prop: string]: ADFEntity | Object;
 };
 export type MultiBodiedExtensionActions = {
-    changeActive: (index: number) => boolean;
     addChild: () => boolean;
+    changeActive: (index: number) => boolean;
+    getChildren(): Array<ADFEntity>;
+    getChildrenContainer(): React.ReactNode;
     getChildrenCount: () => number;
     removeChild: (index: number) => boolean;
     updateParameters: (parameters: Parameters) => boolean;
-    getChildren(): Array<ADFEntity>;
-    getChildrenContainer(): React.ReactNode;
 };
 export type ParametersGetter<T extends Parameters = Parameters> = TransformBefore<T>;
 export type AsyncParametersGetter<T extends Parameters = Parameters> = TransformAfter<T>;

package/dist/types-ts4.5/extensions/types/extension-manifest-toolbar-item.d.ts

@@ -4,10 +4,13 @@ import type { ExtensionAPI } from './extension-handler';
 import type { ExtensionIconModule } from './extension-manifest-common';
 export type ToolbarButtonAction = (contextNode: ADFEntity, api: ExtensionAPI) => Promise<void>;
 export type ToolbarButton = ExtensionModuleToolbarButtonLabelOrIcon & {
-    key: string;
     action: ToolbarButtonAction;
-    label: string;
     ariaLabel?: string;
+    disabled?: boolean;
+    display?: 'icon' | 'label' | 'icon-and-label';
+    icon?: () => ExtensionIconModule;
+    key: string;
+    label: string;
     tooltip?: React.ReactNode | string;
     /**
      * Tooltip Style
@@ -15,9 +18,6 @@ export type ToolbarButton = ExtensionModuleToolbarButtonLabelOrIcon & {
      * How to use: https://atlassian.design/components/tooltip/examples#custom-component
      */
     tooltipStyle?: React.ForwardRefExoticComponent<any> | React.ComponentType<any>;
-    icon?: () => ExtensionIconModule;
-    display?: 'icon' | 'label' | 'icon-and-label';
-    disabled?: boolean;
 };
 export type ToolbarItem = ToolbarButton | FloatingToolbarItem<Command>;
 export type ToolbarContext = ExtensionNodeContext | StandardNodeContext;
@@ -27,28 +27,31 @@ export type ContextualToolbar = {
 };
 export type ExtensionModuleToolbarButtonLabelOrIcon = ExtensionModuleToolbarButtonWithIcon | ExtensionModuleToolbarButtonWithLabel;
 export type ExtensionModuleToolbarButtonWithIcon = {
-    icon: () => ExtensionIconModule;
     display?: 'icon' | 'icon-and-label';
+    icon: () => ExtensionIconModule;
 };
 export type ExtensionModuleToolbarButtonWithLabel = {
     display?: 'label';
 };
 export type ExtensionNodeContext = {
-    type: 'extension';
-    nodeType: 'extension' | 'inlineExtension' | 'bodiedExtension' | 'multiBodiedExtension';
     extensionKey: string | string[];
     extensionType?: string;
+    nodeType: 'extension' | 'inlineExtension' | 'bodiedExtension' | 'multiBodiedExtension';
     shouldExclude?: (node: ADFEntity) => boolean;
+    type: 'extension';
 };
 export type StandardNodeContext = {
-    type: 'node';
     nodeType: 'table';
+    type: 'node';
 };
 export type ExtensionToolbarItem = ExtensionToolbarButton | FloatingToolbarDropdown<Command>;
 export type ExtensionToolbarButton = {
+    action: ToolbarButtonAction;
+    ariaLabel?: string;
+    disabled?: boolean;
+    icon?: () => ExtensionIconModule;
     key: string;
     label?: string;
-    ariaLabel?: string;
     tooltip?: React.ReactNode | string;
     /**
      * Tooltip Style
@@ -56,7 +59,4 @@ export type ExtensionToolbarButton = {
      * How to use: https://atlassian.design/components/tooltip/examples#custom-component
      */
     tooltipStyle?: React.ForwardRefExoticComponent<any> | React.ComponentType<any>;
-    icon?: () => ExtensionIconModule;
-    action: ToolbarButtonAction;
-    disabled?: boolean;
 };