@atlaskit/editor-common 107.28.2 → 107.29.0

package/dist/types/collab/index.d.ts

@@ -8,16 +8,16 @@ import { token } from '@atlaskit/tokens';
 import type { Providers } from '../provider-factory';
 import type { GetResolvedEditorStateReason } from '../types';
 export type NewCollabSyncUpErrorAttributes = {
+    clientId?: number | string;
     lengthOfUnconfirmedSteps?: number;
-    tries: number;
     maxRetries: number;
-    clientId?: number | string;
+    tries: number;
     version: number;
 };
 export type ResolvedEditorState<T = any> = {
     content: JSONDocNode | T;
-    title: string | null;
     stepVersion: number;
+    title: string | null;
 };
 export declare enum PROVIDER_ERROR_CODE {
     NO_PERMISSION_ERROR = "NO_PERMISSION_ERROR",
@@ -42,8 +42,8 @@ export declare enum PROVIDER_ERROR_CODE {
 type InsufficientEditingPermission = {
     code: PROVIDER_ERROR_CODE.NO_PERMISSION_ERROR;
     message: string;
-    recoverable: boolean;
     reason?: string;
+    recoverable: boolean;
     /**
      * @deprecated switch to using either the error code or the recoverable flag
      */
@@ -174,8 +174,8 @@ type NetworkIssue = {
 type InvalidProviderConfiguration = {
     code: PROVIDER_ERROR_CODE.INVALID_PROVIDER_CONFIGURATION;
     message: string;
-    recoverable: boolean;
     reason: string;
+    recoverable: boolean;
     /**
      * @deprecated switch to using either the error code or the recoverable flag
      */
@@ -189,8 +189,8 @@ type InvalidProviderConfiguration = {
 type InternalServiceError = {
     code: PROVIDER_ERROR_CODE.INTERNAL_SERVICE_ERROR;
     message: string;
-    recoverable: boolean;
     reason: string;
+    recoverable: boolean;
     /**
      * @deprecated switch to using either the error code or the recoverable flag
      */
@@ -216,21 +216,21 @@ export type CollabMetadataPayload = Metadata;
 export interface CollabEventInitData {
     doc?: any;
     json?: any;
-    version?: number;
-    sid?: string;
     reserveCursor?: boolean;
+    sid?: string;
+    version?: number;
 }
 export interface CollabInitPayload extends CollabEventInitData {
+    caller?: string;
     doc: any;
-    version: number;
     metadata?: Metadata;
     reserveCursor?: boolean;
     targetClientId?: string;
-    caller?: string;
+    version: number;
 }
 export interface CollabEventConnectionData {
-    sid: string;
     initial: boolean;
+    sid: string;
 }
 export type CollabConnectedPayload = CollabEventConnectionData;
 export declare enum DisconnectReason {
@@ -254,139 +254,139 @@ export interface CollabEventRemoteData {
     userIds?: (number | string)[];
 }
 type MarkJson = {
-    type: string;
     attrs: {
         [key: string]: any;
     };
+    type: string;
 };
 export type NodeJson = {
-    type: string;
     attrs: {
         [key: string]: any;
     };
     content: NodeJson[];
     marks: MarkJson[];
     text?: string;
+    type: string;
 };
 type SliceJson = {
     content: NodeJson[];
-    openStart: number;
     openEnd: number;
+    openStart: number;
 };
 export interface StepMetadata {
     metadata?: {
-        source?: string;
-        stepId?: string;
         prevStepId?: string;
         rebased?: boolean;
-        traceId?: string;
         reqId?: string;
         schemaVersion?: string;
+        source?: string;
+        stepId?: string;
+        traceId?: string;
         unconfirmedStepAfterRecovery?: boolean;
     };
 }
 export interface BaseStepPM extends StepMetadata {
     clientId: number | string;
-    userId: string;
-    stepType: string;
-    to?: number;
     from?: number;
     slice?: SliceJson;
+    stepType: string;
+    to?: number;
+    userId: string;
 }
 export interface ReplaceStepPM extends BaseStepPM {
     from: number;
-    to: number;
     slice: SliceJson;
     structure?: boolean;
+    to: number;
 }
 export interface ReplaceAroundStepPM extends BaseStepPM {
     from: number;
-    to: number;
     gapFrom: number;
     gapTo: number;
-    slice: SliceJson;
     insert: number;
+    slice: SliceJson;
     structure?: boolean;
+    to: number;
 }
 export type InlineCommentStepPM = InlineCommentAddMarkStepPM | InlineCommentAddNodeMarkStepPM;
 interface InlineCommentAddMarkStepPM extends BaseStepPM {
-    stepType: 'addMark';
     from: number;
-    to: number;
     mark?: {
-        type?: 'annotation';
         attrs?: {
-            id?: string;
             annotationType?: 'inlineComment';
+            id?: string;
         };
+        type?: 'annotation';
     };
+    stepType: 'addMark';
+    to: number;
 }
 export interface InlineCommentAddNodeMarkStepPM extends BaseStepPM {
-    stepType: 'addNodeMark';
-    pos: number;
     mark?: {
-        type?: 'annotation';
         attrs?: {
-            id?: string;
             annotationType?: 'inlineComment';
+            id?: string;
         };
+        type?: 'annotation';
     };
+    pos: number;
+    stepType: 'addNodeMark';
 }
 export interface SetAttrsStepPM extends BaseStepPM {
-    stepType: 'setAttrs';
-    pos: number;
     attrs: Record<string, unknown>;
+    pos: number;
+    stepType: 'setAttrs';
 }
 export type BatchAttrsStepPM = BaseStepPM & BatchAttrsStep;
 export type OverrideDocumentStepPM = BaseStepPM & OverrideDocumentStep;
 export type StepJson = OverrideDocumentStepPM | ReplaceAroundStepPM | ReplaceStepPM | InlineCommentStepPM | SetAttrsStepPM;
 export interface CollabDataPayload extends CollabEventRemoteData {
-    version: number;
     json: StepJson[];
     userIds: (number | string)[];
+    version: number;
 }
 export interface CollabSendableSelection {
-    type: 'textSelection' | 'nodeSelection';
     anchor?: number | string;
     head?: number | string;
+    type: 'textSelection' | 'nodeSelection';
 }
 export type PresenceActivity = 'viewer' | 'editor';
 export type CollabActivityAIProviderChangedPayload = {
-    type: 'ai-provider:change';
     action: 'add' | 'remove';
     providerId?: string;
+    type: 'ai-provider:change';
 };
 export type CollabPresenceActivityChangePayload = {
-    type: 'participant:activity';
     activity?: PresenceActivity;
+    type: 'participant:activity';
 };
 export interface CollabEventTelepointerData {
-    type: 'telepointer';
     selection: CollabSendableSelection;
     sessionId: string;
+    type: 'telepointer';
 }
 export type CollabTelepointerPayload = CollabEventTelepointerData;
 type ProviderParticipantPermitLevel = {
-    isPermittedToView?: boolean;
     isPermittedToComment?: boolean;
     isPermittedToEdit?: boolean;
+    isPermittedToView?: boolean;
 };
 export interface CollabParticipant {
-    lastActive: number;
-    sessionId: string;
     avatar: string;
-    name: string;
     cursorPos?: number;
-    permit?: ProviderParticipantPermitLevel;
     isGuest?: boolean;
-    presenceId?: string;
-    presenceActivity?: PresenceActivity;
     isHydrated?: boolean;
+    lastActive: number;
+    name: string;
+    permit?: ProviderParticipantPermitLevel;
+    presenceActivity?: PresenceActivity;
+    presenceId?: string;
+    sessionId: string;
 }
 export type ProviderParticipant = CollabParticipant & {
-    userId: string;
     clientId: number | string;
     email: string;
+    userId: string;
 };
 export interface CollabEventPresenceData {
     joined?: ProviderParticipant[];
@@ -407,64 +407,64 @@ export type CollabCommitStatusEventPayload = {
     version: number;
 };
 export type UserPermitType = {
-    isPermittedToView: boolean;
     isPermittedToComment: boolean;
     isPermittedToEdit: boolean;
+    isPermittedToView: boolean;
 };
 export type CollabPermissionEventPayload = UserPermitType;
 export type ConflictChange = {
     from: number;
-    to: number;
     local: Slice;
     remote: Slice;
+    to: number;
 };
 export type ConflictChanges = {
-    inserted: ConflictChange[];
     deleted: ConflictChange[];
+    inserted: ConflictChange[];
 };
 export interface CollabEventConflictPayload extends ConflictChanges {
     offlineDoc: PMNode;
 }
 export interface CollabEvents {
-    'metadata:changed': Metadata;
-    init: CollabInitPayload;
+    'commit-status': CollabCommitStatusEventPayload;
     connected: CollabConnectedPayload;
-    disconnected: CollabDisconnectedPayload;
+    connecting: CollabConnectingPayload;
     data: CollabDataPayload;
-    telepointer: CollabTelepointerPayload;
-    presence: CollabPresencePayload;
-    'local-steps': CollabLocalStepsPayload;
-    error: ProviderError;
+    'data:conflict': CollabEventConflictPayload;
+    disconnected: CollabDisconnectedPayload;
     entity: any;
-    connecting: CollabConnectingPayload;
-    permission: CollabPermissionEventPayload;
-    'commit-status': CollabCommitStatusEventPayload;
+    error: ProviderError;
+    init: CollabInitPayload;
+    'local-steps': CollabLocalStepsPayload;
+    'metadata:changed': Metadata;
     'namespace-lock:check': CollabNamespaceLockCheckPayload;
-    'data:conflict': CollabEventConflictPayload;
+    permission: CollabPermissionEventPayload;
+    presence: CollabPresencePayload;
     'presence:changed': CollabPresenceActivityChangePayload;
+    telepointer: CollabTelepointerPayload;
 }
 export type SyncUpErrorFunction = (attributes: NewCollabSyncUpErrorAttributes) => void;
 export interface CollabEditProvider<Events extends CollabEvents = CollabEvents> {
+    getFinalAcknowledgedState(reason: GetResolvedEditorStateReason): Promise<ResolvedEditorState>;
+    getIsNamespaceLocked(): boolean;
     initialize(getState: () => any, createStep: (json: object) => Step): this;
+    off(evt: keyof Events, handler: (...args: any) => void): this;
+    on(evt: keyof Events, handler: (...args: any) => void): this;
+    send(tr: Transaction, oldState: EditorState, newState: EditorState): void;
+    sendMessage<K extends keyof Events>(data: {
+        type: K;
+    } & Events[K]): void;
     setup(props: {
-        getState?: () => EditorState;
         editorApi?: any;
+        getState?: () => EditorState;
         onSyncUpError?: SyncUpErrorFunction;
     }): this;
-    send(tr: Transaction, oldState: EditorState, newState: EditorState): void;
-    on(evt: keyof Events, handler: (...args: any) => void): this;
-    off(evt: keyof Events, handler: (...args: any) => void): this;
     unsubscribeAll(evt: keyof Events): this;
-    sendMessage<K extends keyof Events>(data: {
-        type: K;
-    } & Events[K]): void;
-    getFinalAcknowledgedState(reason: GetResolvedEditorStateReason): Promise<ResolvedEditorState>;
-    getIsNamespaceLocked(): boolean;
 }
 export type CollabEditOptions = {
     provider?: Providers['collabEditProvider'];
-    userId?: string;
     useNativePlugin?: boolean;
+    userId?: string;
 } & CollabInviteToEditProps & CollabAnalyticsProps;
 export type InviteToEditButtonProps = {
     onClick: (event: React.MouseEvent<HTMLElement>) => void;
@@ -474,9 +474,9 @@ export type InviteToEditComponentProps = {
     children: ReactElement<InviteToEditButtonProps>;
 };
 export interface CollabInviteToEditProps {
+    inviteToEditComponent?: React.ComponentType<React.PropsWithChildren<InviteToEditComponentProps>>;
     inviteToEditHandler?: (event: React.MouseEvent<HTMLElement>) => void;
     isInviteToEditButtonSelected?: boolean;
-    inviteToEditComponent?: React.ComponentType<React.PropsWithChildren<InviteToEditComponentProps>>;
 }
 export interface CollabAnalyticsProps {
     /**

package/dist/types/doc-utils/editor-use-only.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
 export declare function createEditorUseOnlyNotice(componentName: string, alternatePackages?: {
-    name: string;
     link: string;
+    name: string;
 }[]): React.JSX.Element;

package/dist/types/element-browser/ElementBrowser.d.ts

@@ -4,15 +4,17 @@ import type { QuickInsertItem } from '../provider-factory';
 import type { EmptyStateHandler } from '../types';
 import type { Category, Modes } from './types';
 export interface Props {
+    cache?: CellMeasurerCache;
     categories?: Category[];
-    mode: keyof typeof Modes;
+    defaultCategory?: string;
+    emptyStateHandler?: EmptyStateHandler;
     getItems: (query?: string, category?: string) => QuickInsertItem[];
-    onSelectItem?: (item: QuickInsertItem) => void;
+    mode: keyof typeof Modes;
     onInsertItem: (item: QuickInsertItem) => void;
-    showSearch: boolean;
+    onSelectItem?: (item: QuickInsertItem) => void;
+    onViewMore?: () => void;
     showCategories: boolean;
-    defaultCategory?: string;
-    emptyStateHandler?: EmptyStateHandler;
+    showSearch: boolean;
     /**
      * @private
      * @deprecated
@@ -20,14 +22,12 @@ export interface Props {
      * Please clean up viewMoreItem when cleaning up platform_editor_refactor_view_more
      */
     viewMoreItem?: QuickInsertItem;
-    onViewMore?: () => void;
-    cache?: CellMeasurerCache;
 }
 export interface State {
-    items: QuickInsertItem[];
     categories: Category[];
-    selectedCategory?: string;
+    items: QuickInsertItem[];
     searchTerm?: string;
+    selectedCategory?: string;
 }
 export default class ElementBrowser extends PureComponent<Props, State> {
     static defaultProps: {

package/dist/types/element-browser/ViewMore.d.ts

@@ -1,6 +1,6 @@
 import { jsx } from '@emotion/react';
 import type { QuickInsertItem } from '../provider-factory';
 export declare const ViewMore: ({ item, focus }: {
-    item: QuickInsertItem;
     focus: boolean;
+    item: QuickInsertItem;
 }) => jsx.JSX.Element;

package/dist/types/element-browser/components/CategoryList.d.ts

@@ -7,9 +7,9 @@ import type { WithAnalyticsEventsProps } from '@atlaskit/analytics-next';
 import type { Category } from '../types';
 interface Props {
     categories?: Category[];
+    focusedCategoryIndex?: number;
     onSelectCategory: (category: Category) => void;
     selectedCategory?: string;
-    focusedCategoryIndex?: number;
     setFocusedCategoryIndex: (index: number) => void;
     setFocusedItemIndex: (index: number) => void;
     setFocusOnSearch?: () => void;

package/dist/types/element-browser/components/ElementList/ElementList.d.ts

@@ -14,29 +14,29 @@ export declare const ICON_HEIGHT = 40;
 export declare const ICON_WIDTH = 40;
 export declare const itemIcon: import("@emotion/react").SerializedStyles;
 export interface Props {
+    cache?: CellMeasurerCache;
+    columnCount: number;
+    emptyStateHandler?: EmptyStateHandler;
+    focusOnEmptyStateButton?: boolean;
     items: QuickInsertItem[];
     mode: keyof typeof Modes;
     onInsertItem: (item: QuickInsertItem) => void;
-    columnCount: number;
-    setColumnCount: (columnCount: number) => void;
-    setFocusedItemIndex: (index: number) => void;
-    setFocusedCategoryIndex?: (index: number) => void;
-    emptyStateHandler?: EmptyStateHandler;
+    searchTerm?: string;
     selectedCategory?: string;
     selectedCategoryIndex?: number;
-    searchTerm?: string;
-    cache?: CellMeasurerCache;
-    focusOnEmptyStateButton?: boolean;
+    setColumnCount: (columnCount: number) => void;
+    setFocusedCategoryIndex?: (index: number) => void;
+    setFocusedItemIndex: (index: number) => void;
 }
 type ElementItemType = {
+    focus: boolean;
+    index: number;
     inlineMode: boolean;
     item: QuickInsertItem;
     onInsertItem: (item: QuickInsertItem) => void;
+    role?: string;
     selected: boolean;
-    focus: boolean;
     setFocusedItemIndex: (index: number) => void;
-    index: number;
-    role?: string;
 };
 export declare function ElementItem({ inlineMode, selected, item, index, onInsertItem, focus, setFocusedItemIndex, role, }: ElementItemType): jsx.JSX.Element;
 declare const MemoizedElementListWithAnalytics: React.MemoExoticComponent<React.ForwardRefExoticComponent<Omit<Props & SelectedItemProps & WithAnalyticsEventsProps & import("@atlaskit/analytics-next").WithContextProps, "ref"> & React.RefAttributes<any>>>;

package/dist/types/element-browser/components/ElementList/EmptyState.d.ts

@@ -1,6 +1,6 @@
 type Props = {
-    onExternalLinkClick: () => void;
     focusOnEmptyStateButton?: boolean;
+    onExternalLinkClick: () => void;
 };
 export default function EmptyState({ onExternalLinkClick, focusOnEmptyStateButton, }: Props): JSX.Element;
 export {};

package/dist/types/element-browser/components/ElementSearch.d.ts

@@ -7,15 +7,15 @@ import type { WrappedComponentProps } from 'react-intl-next';
 import type { QuickInsertItem } from '../../provider-factory';
 import { Modes } from '../types';
 interface Props {
-    onSearch: (value: string) => void;
-    mode: keyof typeof Modes;
+    ariaControlsId?: string;
     focus: boolean;
+    items: QuickInsertItem[];
+    mode: keyof typeof Modes;
     onClick: (e: React.MouseEvent) => void;
     onKeyDown: (e: React.KeyboardEvent) => void;
+    onSearch: (value: string) => void;
     searchTerm?: string;
-    items: QuickInsertItem[];
     selectedItemIndex?: number;
-    ariaControlsId?: string;
 }
 declare const MemoizedElementSearchWithAnalytics: React.MemoExoticComponent<React.ForwardRefExoticComponent<Omit<Props & WrappedComponentProps, "intl"> & {
     forwardedRef?: React.Ref<any>;

package/dist/types/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/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/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/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/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;