@atlaskit/renderer 120.5.1 → 120.5.2

package/dist/types/types/i18n.d.ts

@@ -1,5 +1,5 @@
 export interface MessageDescriptor {
-    id: string;
-    description: string;
     defaultMessage: string;
+    description: string;
+    id: string;
 }

package/dist/types/types/mediaOptions.d.ts

@@ -1,14 +1,14 @@
 import type { MediaClientConfig } from '@atlaskit/media-core';
 import type { MediaFeatureFlags, SSR } from '@atlaskit/media-common';
 export type MediaSSR = {
-    mode: SSR;
     config: MediaClientConfig;
+    mode: SSR;
 };
 export interface MediaOptions {
+    allowCaptions?: boolean;
     allowLinking?: boolean;
     enableDownloadButton?: boolean;
+    enableSyncMediaCard?: boolean;
     featureFlags?: MediaFeatureFlags;
     ssr?: MediaSSR;
-    allowCaptions?: boolean;
-    enableSyncMediaCard?: boolean;
 }

package/dist/types/types/smartLinksOptions.d.ts

@@ -1,20 +1,6 @@
 import type React from 'react';
 import type { CardProps } from '@atlaskit/smart-card';
 export interface SmartLinksOptions {
-    /**
-     * A flag to enable inline Smart Link to render without lazy loading.
-     * Default is false.
-     *
-     * Component: inline
-     */
-    ssr?: boolean;
-    /**
-     * A flag to disable hover preview on inline Smart Link.
-     * Default is false.
-     *
-     * Component: inline
-     */
-    hideHoverPreview?: boolean;
     /**
      * Configure visibility of actions available.
      * By default, smart links show all actions available on the views.
@@ -24,6 +10,13 @@ export interface SmartLinksOptions {
      * Component: inline (hover preview), block (card)
      */
     actionOptions?: CardProps['actionOptions'];
+    /**
+     * Competitor Prompt Component for Competitor link
+     */
+    CompetitorPrompt?: React.ComponentType<{
+        linkType?: string;
+        sourceUrl: string;
+    }>;
     /**
      * A prop that determines the style of a frame:
      * whether to show it, hide it or only show it when a user hovers over embed.
@@ -33,10 +26,17 @@ export interface SmartLinksOptions {
      */
     frameStyle?: CardProps['frameStyle'];
     /**
-     * Competitor Prompt Component for Competitor link
+     * A flag to disable hover preview on inline Smart Link.
+     * Default is false.
+     *
+     * Component: inline
      */
-    CompetitorPrompt?: React.ComponentType<{
-        sourceUrl: string;
-        linkType?: string;
-    }>;
+    hideHoverPreview?: boolean;
+    /**
+     * A flag to enable inline Smart Link to render without lazy loading.
+     * Default is false.
+     *
+     * Component: inline
+     */
+    ssr?: boolean;
 }

package/dist/types/ui/Expand.d.ts

@@ -3,12 +3,12 @@ import type { WrappedComponentProps } from 'react-intl-next';
 import type { AnalyticsEventPayload } from '../analytics/events';
 import type { RendererAppearance } from './Renderer/types';
 export interface ExpandProps {
-    title: string;
-    nodeType: 'expand' | 'nestedExpand';
     children: React.ReactNode;
     fireAnalyticsEvent?: (event: AnalyticsEventPayload) => void;
     nestedHeaderIds?: Array<string>;
+    nodeType: 'expand' | 'nestedExpand';
     rendererAppearance?: RendererAppearance;
+    title: string;
 }
 declare const _default: React.FC<import("react-intl-next").WithIntlProps<ExpandProps & WrappedComponentProps>> & {
     WrappedComponent: React.ComponentType<ExpandProps & WrappedComponentProps>;

package/dist/types/ui/ExtensionRenderer.d.ts

@@ -10,22 +10,22 @@ import type { ExtensionHandlers, MultiBodiedExtensionActions } from '@atlaskit/e
 import type { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
 import type { Mark as PMMark } from '@atlaskit/editor-prosemirror/model';
 interface Props {
-    type: 'extension' | 'inlineExtension' | 'bodiedExtension' | 'multiBodiedExtension';
-    extensionHandlers?: ExtensionHandlers;
-    providers?: ProviderFactory;
-    rendererContext: RendererContext;
-    extensionType: string;
-    extensionKey: string;
     actions?: MultiBodiedExtensionActions;
-    text?: string;
-    parameters?: any;
+    children: ({ result }: {
+        result?: JSX.Element | null;
+    }) => JSX.Element;
     content?: any;
+    extensionHandlers?: ExtensionHandlers;
+    extensionKey: string;
+    extensionType: string;
     layout?: ExtensionLayout;
     localId?: string;
     marks?: PMMark[];
-    children: ({ result }: {
-        result?: JSX.Element | null;
-    }) => JSX.Element;
+    parameters?: any;
+    providers?: ProviderFactory;
+    rendererContext: RendererContext;
+    text?: string;
+    type: 'extension' | 'inlineExtension' | 'bodiedExtension' | 'multiBodiedExtension';
 }
 export default function ExtensionRenderer(props: Props): JSX.Element;
 export declare const InlineNodeRendererWrapper: ({ children, ssrPlaceholder, ssrPlaceholderReplace, }: React.PropsWithChildren<{

package/dist/types/ui/MediaCard.d.ts

@@ -14,33 +14,33 @@ export type MediaProvider = {
     viewMediaClientConfig: MediaClientConfig;
 };
 export interface MediaCardProps {
-    id?: string;
+    alt?: string;
+    appearance?: CardAppearance;
+    cardDimensions?: CardDimensions;
+    collection?: string;
     contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
+    dataAttributes?: Record<string, any>;
+    disableOverlay?: boolean;
+    enableSyncMediaCard?: boolean;
     eventHandlers?: {
         media?: {
             onClick?: CardOnClickCallback;
         };
     };
-    shouldOpenMediaViewer?: boolean;
-    type: MediaType;
-    collection?: string;
-    url?: string;
-    cardDimensions?: CardDimensions;
+    featureFlags?: MediaFeatureFlags;
+    id?: string;
+    imageStatus?: ImageStatus;
+    occurrenceKey?: string;
     originalDimensions?: NumericalCardDimensions;
-    resizeMode?: ImageResizeMode;
-    appearance?: CardAppearance;
     rendererAppearance?: RendererAppearance;
-    occurrenceKey?: string;
-    imageStatus?: ImageStatus;
-    disableOverlay?: boolean;
-    useInlinePlayer?: boolean;
     rendererContext?: RendererContext;
-    alt?: string;
-    featureFlags?: MediaFeatureFlags;
+    resizeMode?: ImageResizeMode;
     shouldEnableDownloadButton?: boolean;
+    shouldOpenMediaViewer?: boolean;
     ssr?: MediaSSR;
-    dataAttributes?: Record<string, any>;
-    enableSyncMediaCard?: boolean;
+    type: MediaType;
+    url?: string;
+    useInlinePlayer?: boolean;
 }
 interface State {
     contextIdentifierProvider?: ContextIdentifierProvider;
@@ -68,12 +68,12 @@ export declare class MediaCardView extends Component<MediaCardProps & {
     render(): React.JSX.Element | null;
 }
 export type ClipboardAttrs = {
-    id: string;
     alt?: string;
     collection?: string;
     contextIdentifierProvider?: ContextIdentifierProvider;
-    originalDimensions?: NumericalCardDimensions;
     fileState?: FileState;
+    id: string;
+    originalDimensions?: NumericalCardDimensions;
 };
 export declare const getClipboardAttrs: ({ id, alt, collection, contextIdentifierProvider, originalDimensions, fileState, }: ClipboardAttrs) => {
     [key: string]: string | number | undefined;

package/dist/types/ui/Renderer/ErrorBoundary.d.ts

@@ -2,17 +2,17 @@ import React from 'react';
 import type { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
 import type { ComponentCrashErrorAEP } from '../../analytics/events';
 interface ErrorBoundaryProps {
-    component: ComponentCrashErrorAEP['actionSubject'];
+    additionalInfo?: string;
     children: React.ReactNode;
+    component: ComponentCrashErrorAEP['actionSubject'];
     componentId?: ComponentCrashErrorAEP['actionSubjectId'];
-    fallbackComponent?: React.ReactNode;
     createAnalyticsEvent?: CreateUIAnalyticsEvent;
+    fallbackComponent?: React.ReactNode;
     rethrowError?: boolean;
-    additionalInfo?: string;
 }
 interface ErrorBoundaryState {
-    errorCaptured: boolean;
     domError: boolean;
+    errorCaptured: boolean;
 }
 export declare class ErrorBoundary extends React.Component<ErrorBoundaryProps, ErrorBoundaryState> {
     state: {

package/dist/types/ui/Renderer/ValidationContext.d.ts

@@ -1,6 +1,6 @@
 type ValidationContextType = {
-    skipValidation?: boolean;
     allowNestedTables?: boolean;
+    skipValidation?: boolean;
 } | null;
 /**
  * The ValidationContext is used to pass down the `skipValidation` flag from the NBMRenderer

package/dist/types/ui/Renderer/index.d.ts

@@ -10,8 +10,8 @@ import type { RendererAppearance } from './types';
 export declare const NORMAL_SEVERITY_THRESHOLD = 2000;
 export declare const DEGRADED_SEVERITY_THRESHOLD = 3000;
 export declare const RendererFunctionalComponent: (props: RendererProps & {
-    startPos?: number;
     skipValidation?: boolean;
+    startPos?: number;
     validationOverrides?: {
         allowNestedTables?: boolean;
     };
@@ -24,25 +24,25 @@ export declare const RendererFunctionalComponent: (props: RendererProps & {
 export declare function Renderer(props: RendererProps): jsx.JSX.Element;
 export declare const RendererWithAnalytics: React.MemoExoticComponent<(props: RendererProps) => jsx.JSX.Element>;
 export type RendererWrapperProps = {
+    addTelepointer?: boolean;
     allowAnnotations?: boolean;
-    appearance: RendererAppearance;
-    innerRef?: React.RefObject<HTMLDivElement>;
     allowColumnSorting?: boolean;
     allowCopyToClipboard?: boolean;
-    allowWrapCodeBlock?: boolean;
-    allowPlaceholderText?: boolean;
     allowCustomPanels?: boolean;
-    addTelepointer?: boolean;
     allowNestedHeaderLinks: boolean;
-    useBlockRenderForCodeBlock: boolean;
-    onClick?: (event: React.MouseEvent) => void;
-    onMouseDown?: (event: React.MouseEvent) => void;
-    ssr?: MediaSSR;
-    isInsideOfInlineExtension?: boolean;
+    allowPlaceholderText?: boolean;
+    allowRendererContainerStyles?: boolean;
     allowTableResizing?: boolean;
+    allowWrapCodeBlock?: boolean;
+    appearance: RendererAppearance;
+    innerRef?: React.RefObject<HTMLDivElement>;
+    isInsideOfInlineExtension?: boolean;
     isTopLevelRenderer?: boolean;
+    onClick?: (event: React.MouseEvent) => void;
+    onMouseDown?: (event: React.MouseEvent) => void;
     shouldRemoveEmptySpaceAroundContent?: boolean;
-    allowRendererContainerStyles?: boolean;
+    ssr?: MediaSSR;
+    useBlockRenderForCodeBlock: boolean;
 } & {
     children?: React.ReactNode;
 };

package/dist/types/ui/Renderer/truncated-wrapper.d.ts

@@ -5,10 +5,10 @@
 import { jsx } from '@emotion/react';
 import { Component } from 'react';
 interface TruncatedWrapperProps {
-    height?: number;
-    fadeHeight?: number;
     backgroundColor?: string;
     children?: React.ReactNode;
+    fadeHeight?: number;
+    height?: number;
 }
 export declare class TruncatedWrapper extends Component<TruncatedWrapperProps, unknown> {
     constructor(props: TruncatedWrapperProps);

package/dist/types/ui/annotations/contexts/AnnotationManagerContext.d.ts

@@ -8,14 +8,14 @@ interface AnnotationState {
 }
 type AnnotationsStateRecord = Record<AnnotationId, AnnotationState>;
 interface AnnotationManagerStateContext {
-    isDrafting: boolean;
-    draftId: string | undefined;
-    draftMarkRef: HTMLElement | undefined;
-    draftActionResult: ActionResult | undefined;
     annotations: AnnotationsStateRecord;
+    currentHoveredAnnotationId: AnnotationId | undefined;
     currentSelectedAnnotationId: AnnotationId | undefined;
     currentSelectedMarkRef: HTMLElement | undefined;
-    currentHoveredAnnotationId: AnnotationId | undefined;
+    draftActionResult: ActionResult | undefined;
+    draftId: string | undefined;
+    draftMarkRef: HTMLElement | undefined;
+    isDrafting: boolean;
 }
 interface AnnotationManagerDispatchContext {
     annotationManager: AnnotationManager | undefined;
@@ -26,44 +26,44 @@ declare const AnnotationManagerDispatchContext: React.Context<AnnotationManagerD
 type AnnotationManagerAction = {
     type: 'reset';
 } | {
-    type: 'loadAnnotation';
     data: {
         id: AnnotationId;
         markState?: AnnotationMarkStates;
     }[];
+    type: 'loadAnnotation';
 } | {
-    type: 'updateAnnotation';
     data: {
-        id: AnnotationId;
-        selected?: boolean;
         hovered?: boolean;
+        id: AnnotationId;
         markState?: AnnotationMarkStates;
+        selected?: boolean;
     };
+    type: 'updateAnnotation';
 } | {
     type: 'resetSelectedAnnotation';
 } | {
     type: 'resetHoveredAnnotation';
 } | {
-    type: 'setDrafting';
     data: {
-        isDrafting: boolean;
-        draftId: string | undefined;
         draftActionResult: ActionResult | undefined;
+        draftId: string | undefined;
+        isDrafting: boolean;
     };
+    type: 'setDrafting';
 } | {
-    type: 'setDraftMarkRef';
     data: {
         draftMarkRef: HTMLElement | undefined;
     };
+    type: 'setDraftMarkRef';
 } | {
-    type: 'setSelectedMarkRef';
     data: {
         markRef: HTMLElement | undefined;
     };
+    type: 'setSelectedMarkRef';
 };
 export declare const AnnotationManagerProvider: ({ children, annotationManager, updateSubscriber, }: {
-    children?: ReactNode;
     annotationManager?: AnnotationManager;
+    children?: ReactNode;
     updateSubscriber?: AnnotationUpdateEmitter;
 }) => React.JSX.Element;
 export declare const useAnnotationManagerState: () => AnnotationManagerStateContext;

package/dist/types/ui/annotations/contexts/AnnotationRangeContext.d.ts

@@ -3,46 +3,46 @@ import React from 'react';
 import type { Position } from '../types';
 export type RangeType = 'selection' | 'hover' | null;
 interface AnnotationRangeStateContext {
+    hoverDraftDocumentPosition: Position | null;
+    hoverDraftRange: Range | null;
     /**
      * This range represents the selection that the user has made before they intend to save an annotation
      */
     range: Range | null;
     /**
-     * This represents the type of range that is currently set on the range property, ie, whether the range is a hover or selection.
+     * When a selection or hover is promoted to a draft, we need to store the document position of the selection or hover.
+     * This is only set once on promotion, the position should not change while the draft is open.
      */
-    type: RangeType;
+    selectionDraftDocumentPosition: Position | null;
     /**
      * This range represents the "pre-committed" placeholder range that the user will eventually save as an annotation
      * If the user does not set allowDraftMode, this will be ignored as it only is set when we call applyAnnotationDraftAt()
      */
     selectionDraftRange: Range | null;
-    hoverDraftRange: Range | null;
     /**
-     * When a selection or hover is promoted to a draft, we need to store the document position of the selection or hover.
-     * This is only set once on promotion, the position should not change while the draft is open.
+     * This represents the type of range that is currently set on the range property, ie, whether the range is a hover or selection.
      */
-    selectionDraftDocumentPosition: Position | null;
-    hoverDraftDocumentPosition: Position | null;
+    type: RangeType;
 }
 interface AnnotationRangeDispatchContext {
-    clearSelectionRange: () => void;
+    clearHoverDraft: () => void;
     clearHoverRange: () => void;
-    setSelectionRange: (range: Range) => void;
-    setHoverTarget?: (target: HTMLElement) => void;
-    promoteSelectionToDraft: (position: Position | null) => void;
-    promoteHoverToDraft: (position: Position | null) => void;
     clearSelectionDraft: () => void;
-    clearHoverDraft: () => void;
+    clearSelectionRange: () => void;
+    promoteHoverToDraft: (position: Position | null) => void;
+    promoteSelectionToDraft: (position: Position | null) => void;
+    setHoverTarget?: (target: HTMLElement) => void;
+    setSelectionRange: (range: Range) => void;
 }
 export declare const AnnotationRangeStateContext: React.Context<AnnotationRangeStateContext>;
 export declare const AnnotationRangeDispatchContext: React.Context<AnnotationRangeDispatchContext>;
 export declare const AnnotationRangeProviderInner: ({ children, allowCommentsOnMedia, }: {
-    children?: ReactNode;
     allowCommentsOnMedia?: boolean;
+    children?: ReactNode;
 }) => React.JSX.Element;
 export declare const AnnotationRangeProvider: ({ children, allowCommentsOnMedia, isNestedRender, }: {
-    children?: ReactNode;
     allowCommentsOnMedia?: boolean;
+    children?: ReactNode;
     isNestedRender?: boolean;
 }) => React.JSX.Element;
 export declare const useAnnotationRangeState: () => AnnotationRangeStateContext;

package/dist/types/ui/annotations/draft/component.d.ts

@@ -12,19 +12,19 @@ export declare const AnnotationDraft: ({ draftPosition, children, }: React.Props
     draftPosition: Position;
 }>) => jsx.JSX.Element;
 type ApplyAnnotationsProps = {
-    texts: string[];
-    shouldApplyAnnotationAt: InsertDraftPosition.INSIDE | InsertDraftPosition.START | InsertDraftPosition.END;
     draftPosition: Position;
-    textHighlighter?: TextHighlighter;
     marks?: readonly Mark[];
+    shouldApplyAnnotationAt: InsertDraftPosition.INSIDE | InsertDraftPosition.START | InsertDraftPosition.END;
+    textHighlighter?: TextHighlighter;
+    texts: string[];
 };
 export declare const getAnnotationIndex: (annotationPosition: InsertDraftPosition, fragmentCount: number) => number;
 export declare const applyAnnotationOnText: ({ texts, shouldApplyAnnotationAt, draftPosition, textHighlighter, marks, }: ApplyAnnotationsProps) => JSX.Element[];
 type Props = React.PropsWithChildren<{
-    startPos: number;
     endPos: number;
-    textHighlighter?: TextHighlighter;
     marks?: readonly Mark[];
+    startPos: number;
+    textHighlighter?: TextHighlighter;
 }>;
 export declare const TextWithAnnotationDraft: ({ startPos, endPos, children, textHighlighter, marks, }: Props) => jsx.JSX.Element;
 export {};

package/dist/types/ui/annotations/draft/text.d.ts

@@ -2,8 +2,8 @@ import React from 'react';
 import { type TextPosition, type Position } from '../types';
 export declare const findTextString: (reactNode: React.ReactNode) => string | null;
 type Offset = {
-    startOffset: number;
     endOffset: number;
+    startOffset: number;
 };
 export declare const splitText: (text: string, { startOffset, endOffset }: Offset) => string[] | null;
 export declare const calcTextSplitOffset: (position: Position, textPosition: TextPosition, text: string) => {

package/dist/types/ui/annotations/element/index.d.ts

@@ -1,10 +1,10 @@
 import React from 'react';
 import { type AnnotationId, type AnnotationDataAttributes, type AnnotationTypes } from '@atlaskit/adf-schema';
 type MarkElementProps = React.PropsWithChildren<{
-    id: AnnotationId;
     annotationParentIds: AnnotationId[];
-    dataAttributes: AnnotationDataAttributes;
     annotationType: AnnotationTypes;
+    dataAttributes: AnnotationDataAttributes;
+    id: AnnotationId;
     useBlockLevel?: boolean;
 }>;
 declare const MarkElement: ({ annotationParentIds, children, dataAttributes, id, useBlockLevel, }: MarkElementProps) => React.JSX.Element;

package/dist/types/ui/annotations/element/mark.d.ts

@@ -7,13 +7,13 @@ import type { OnAnnotationClickPayload } from '@atlaskit/editor-common/types';
 import type { AnnotationId, AnnotationDataAttributes } from '@atlaskit/adf-schema';
 import { AnnotationMarkStates } from '@atlaskit/adf-schema';
 type MarkComponentProps = {
-    id: AnnotationId;
     annotationParentIds: AnnotationId[];
     dataAttributes: AnnotationDataAttributes;
-    state: AnnotationMarkStates | null;
     hasFocus: boolean;
+    id: AnnotationId;
     isHovered: boolean;
     onClick: (props: OnAnnotationClickPayload) => void;
+    state: AnnotationMarkStates | null;
     useBlockLevel?: boolean;
 };
 export declare const MarkComponent: ({ annotationParentIds, children, dataAttributes, id, state, hasFocus, isHovered, onClick, useBlockLevel, }: React.PropsWithChildren<MarkComponentProps>) => React.ReactElement<{

package/dist/types/ui/annotations/hooks/use-events.d.ts

@@ -3,10 +3,10 @@ import type { AnnotationMarkStates, AnnotationId } from '@atlaskit/adf-schema';
 import { AnnotationTypes } from '@atlaskit/adf-schema';
 import type { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
 type ListenEventProps = {
-    id: AnnotationId;
-    updateSubscriber: AnnotationUpdateEmitter | null;
     createAnalyticsEvent?: CreateUIAnalyticsEvent;
+    id: AnnotationId;
     isNestedRender?: boolean;
+    updateSubscriber: AnnotationUpdateEmitter | null;
 };
 type UseAnnotationUpdateSatteByEventProps = {
     type: AnnotationTypes;

package/dist/types/ui/annotations/hover/mounter.d.ts

@@ -4,16 +4,16 @@ import type { ApplyAnnotation } from '../../../actions/index';
 import type { Position } from '../types';
 import type { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
 type Props = {
-    range: Range;
-    isWithinRange: boolean;
+    applyAnnotation: ApplyAnnotation;
     component: React.ComponentType<InlineCommentHoverComponentProps>;
-    wrapperDOM: React.RefObject<HTMLDivElement>;
+    createAnalyticsEvent?: CreateUIAnalyticsEvent;
     documentPosition: Position | false;
+    generateIndexMatch?: (pos: Position) => false | AnnotationByMatches;
     isAnnotationAllowed: boolean;
+    isWithinRange: boolean;
     onClose: () => void;
-    applyAnnotation: ApplyAnnotation;
-    createAnalyticsEvent?: CreateUIAnalyticsEvent;
-    generateIndexMatch?: (pos: Position) => false | AnnotationByMatches;
+    range: Range;
+    wrapperDOM: React.RefObject<HTMLDivElement>;
 };
 export declare const Mounter: React.MemoExoticComponent<(props: Props) => React.JSX.Element>;
 export {};

package/dist/types/ui/annotations/hover/range-validator.d.ts

@@ -3,8 +3,8 @@ import type { InlineCommentHoverComponentProps } from '@atlaskit/editor-common/t
 import type { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
 type Props = {
     component: React.ComponentType<InlineCommentHoverComponentProps>;
-    rendererRef: React.RefObject<HTMLDivElement>;
     createAnalyticsEvent?: CreateUIAnalyticsEvent;
+    rendererRef: React.RefObject<HTMLDivElement>;
 };
 export declare const RangeValidator: {
     (props: Props): React.JSX.Element | null;

package/dist/types/ui/annotations/selection/mounter.d.ts

@@ -4,16 +4,16 @@ import type { ApplyAnnotation } from '../../../actions/index';
 import type { Position } from '../types';
 import type { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
 type Props = {
-    range: Range | null;
-    draftRange: Range | null;
+    applyAnnotation: ApplyAnnotation;
     component: React.ComponentType<React.PropsWithChildren<InlineCommentSelectionComponentProps>>;
-    wrapperDOM: React.RefObject<HTMLDivElement>;
+    createAnalyticsEvent?: CreateUIAnalyticsEvent;
     documentPosition: Position | false;
+    draftRange: Range | null;
+    generateIndexMatch?: (pos: Position) => false | AnnotationByMatches;
     isAnnotationAllowed: boolean;
     onClose: () => void;
-    applyAnnotation: ApplyAnnotation;
-    createAnalyticsEvent?: CreateUIAnalyticsEvent;
-    generateIndexMatch?: (pos: Position) => false | AnnotationByMatches;
+    range: Range | null;
+    wrapperDOM: React.RefObject<HTMLDivElement>;
 };
 export declare const SelectionInlineCommentMounter: React.MemoExoticComponent<(props: React.PropsWithChildren<Props>) => React.JSX.Element>;
 export {};

package/dist/types/ui/annotations/selection/range-validator.d.ts

@@ -2,9 +2,9 @@ import React from 'react';
 import type { InlineCommentSelectionComponentProps } from '@atlaskit/editor-common/types';
 import type { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
 type Props = {
-    selectionComponent: React.ComponentType<React.PropsWithChildren<InlineCommentSelectionComponentProps>>;
-    rendererRef: React.RefObject<HTMLDivElement>;
     createAnalyticsEvent?: CreateUIAnalyticsEvent;
+    rendererRef: React.RefObject<HTMLDivElement>;
+    selectionComponent: React.ComponentType<React.PropsWithChildren<InlineCommentSelectionComponentProps>>;
 };
 export declare const SelectionRangeValidator: {
     (props: Props): React.JSX.Element | null;

package/dist/types/ui/annotations/types.d.ts

@@ -11,9 +11,12 @@ export type Position = {
     to: number;
 };
 export type AnnotationsWrapperProps = React.PropsWithChildren<{
+    /**
+     * This is set internally -- and should not be set by consumers.
+     */
+    _startPos?: number;
     adfDocument: JSONDocNode;
     annotationProvider: AnnotationProviders | null | undefined;
-    rendererRef: React.RefObject<HTMLDivElement>;
     /**
      * This is set (by consumers) for nested renderers when they are
      * rendering bodied extension content.
@@ -22,12 +25,9 @@ export type AnnotationsWrapperProps = React.PropsWithChildren<{
     onLoadComplete?: ({ numberOfUnresolvedInlineComments, }: {
         numberOfUnresolvedInlineComments: number;
     }) => void;
-    /**
-     * This is set internally -- and should not be set by consumers.
-     */
-    _startPos?: number;
+    rendererRef: React.RefObject<HTMLDivElement>;
 }>;
 export type TextPosition = {
-    start: number;
     end: number;
+    start: number;
 };

package/dist/types/ui/annotations/wrapper.d.ts

@@ -1,9 +1,9 @@
 import React from 'react';
 import type { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
 type Props = {
-    rendererRef: React.RefObject<HTMLDivElement>;
     createAnalyticsEvent?: CreateUIAnalyticsEvent;
     isNestedRender?: boolean;
+    rendererRef: React.RefObject<HTMLDivElement>;
 };
 export declare const AnnotationsContextWrapper: (props: React.PropsWithChildren<Props>) => JSX.Element;
 export {};