@atlaskit/renderer 120.5.1 → 120.5.2

package/dist/types/react/nodes/media/index.d.ts

@@ -13,23 +13,23 @@ import type { LinkDefinition, BorderMarkDefinition, AnnotationMarkDefinition } f
 import type { MediaFeatureFlags } from '@atlaskit/media-common';
 import type { AnalyticsEventPayload } from '../../../analytics/events';
 export type MediaProps = MediaCardProps & {
-    providers?: ProviderFactory;
     allowAltTextOnImages?: boolean;
+    allowAnnotationsDraftMode?: boolean;
     children?: React.ReactNode;
-    isInsideOfBlockNode?: boolean;
-    marks: Array<LinkDefinition | BorderMarkDefinition | AnnotationMarkDefinition>;
+    enableDownloadButton?: boolean;
+    eventHandlers?: EventHandlers;
+    featureFlags?: MediaFeatureFlags;
+    fireAnalyticsEvent?: (event: AnalyticsEventPayload) => void;
+    height?: number;
+    isAnnotationMark?: () => boolean;
     isBorderMark: () => boolean;
+    isDrafting: boolean;
+    isInsideOfBlockNode?: boolean;
     isLinkMark: () => boolean;
-    isAnnotationMark?: () => boolean;
-    fireAnalyticsEvent?: (event: AnalyticsEventPayload) => void;
-    featureFlags?: MediaFeatureFlags;
-    eventHandlers?: EventHandlers;
-    enableDownloadButton?: boolean;
-    allowAnnotationsDraftMode?: boolean;
+    marks: Array<LinkDefinition | BorderMarkDefinition | AnnotationMarkDefinition>;
     mediaSingleElement?: HTMLElement | null;
+    providers?: ProviderFactory;
     width?: number;
-    height?: number;
-    isDrafting: boolean;
 };
 declare const MediaWithDraftAnnotation: (props: PropsWithChildren<MediaProps>) => jsx.JSX.Element;
 export default MediaWithDraftAnnotation;

package/dist/types/react/nodes/mediaGroup.d.ts

@@ -7,9 +7,9 @@ import type { MediaProps } from './media';
 import type { MediaFeatureFlags } from '@atlaskit/media-common';
 export interface MediaGroupProps {
     children?: React.ReactNode;
+    enableDownloadButton?: boolean;
     eventHandlers?: EventHandlers;
     featureFlags?: MediaFeatureFlags;
-    enableDownloadButton?: boolean;
 }
 interface MediaGroupState {
     animate: boolean;

package/dist/types/react/nodes/mediaInline.d.ts

@@ -8,13 +8,13 @@ import type { RendererAppearance } from '../../ui/Renderer/types';
 import type { Mark } from '@atlaskit/editor-prosemirror/model';
 import type { MediaSSR } from '../../types/mediaOptions';
 type MediaInlineProps = {
-    id: string;
-    providers: ProviderFactory;
     collection?: string;
     eventHandlers?: EventHandlers;
-    rendererAppearance?: RendererAppearance;
     featureFlags?: MediaFeatureFlags;
+    id: string;
     marks?: Array<Mark>;
+    providers: ProviderFactory;
+    rendererAppearance?: RendererAppearance;
     ssr?: MediaSSR;
 };
 declare const _default: React.FC<import("react-intl-next").WithIntlProps<MediaInlineProps & WrappedComponentProps & MediaInlineAttrs>> & {

package/dist/types/react/nodes/mediaSingle/index.d.ts

@@ -7,19 +7,19 @@ import type { EventHandlers, MediaSingleWidthType } from '@atlaskit/editor-commo
 import type { AnalyticsEventPayload } from '../../../analytics/events';
 import type { RendererAppearance } from '../../../ui/Renderer/types';
 export interface Props {
+    allowCaptions?: boolean;
     children: React.ReactNode;
-    layout: MediaSingleLayout;
+    dataAttributes?: Record<string, any>;
+    editorAppearance?: EditorAppearance;
     eventHandlers?: EventHandlers;
-    width?: number;
-    widthType?: MediaSingleWidthType;
-    isInsideOfBlockNode?: boolean;
-    rendererAppearance: RendererAppearance;
-    fireAnalyticsEvent?: (event: AnalyticsEventPayload) => void;
     featureFlags?: MediaFeatureFlags;
-    allowCaptions?: boolean;
+    fireAnalyticsEvent?: (event: AnalyticsEventPayload) => void;
+    isInsideOfBlockNode?: boolean;
     isInsideOfInlineExtension?: boolean;
-    dataAttributes?: Record<string, any>;
-    editorAppearance?: EditorAppearance;
+    layout: MediaSingleLayout;
+    rendererAppearance: RendererAppearance;
+    width?: number;
+    widthType?: MediaSingleWidthType;
 }
 export declare const getMediaContainerWidth: (currentContainerWidth: number, layout: MediaSingleLayout) => number;
 declare const _default: React.FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps>> & {

package/dist/types/react/nodes/mention.d.ts

@@ -3,12 +3,12 @@ import type { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
 import type { EventHandlers } from '@atlaskit/editor-common/ui';
 import { type MarkDataAttributes } from '../../ui/annotations/element/useInlineAnnotationProps';
 export interface Props extends MarkDataAttributes {
+    accessLevel?: string;
+    eventHandlers?: EventHandlers;
     id: string;
+    localId?: string;
     providers?: ProviderFactory;
-    eventHandlers?: EventHandlers;
     text: string;
-    accessLevel?: string;
-    localId?: string;
 }
 declare const _default: React.NamedExoticComponent<Props>;
 export default _default;

package/dist/types/react/nodes/multiBodiedExtension/actions.d.ts

@@ -1,10 +1,10 @@
 import React from 'react';
 import type { MultiBodiedExtensionActions } from '@atlaskit/editor-common/extensions';
 type ActionsProps = {
-    updateActiveChild: (index: number) => void;
-    children: React.ReactNode;
     allowBodiedOverride: boolean;
+    children: React.ReactNode;
     childrenContainer: React.ReactNode;
+    updateActiveChild: (index: number) => void;
 };
 export declare const useMultiBodiedExtensionActions: ({ updateActiveChild, children, allowBodiedOverride, childrenContainer, }: ActionsProps) => MultiBodiedExtensionActions;
 export {};

package/dist/types/react/nodes/multiBodiedExtension/context.d.ts

@@ -1,11 +1,11 @@
 import React from 'react';
 type useMultiBodiedExtensionContextProps = {
-    extensionType: string;
     extensionKey: string;
+    extensionType: string;
 };
 type MultiBodiedExtensionLoadingContext = {
-    loading: boolean;
     extensionContext: MultiBodiedExtensionContext | null;
+    loading: boolean;
 };
 export type MultiBodiedExtensionContext = {
     NodeRenderer: React.ComponentType<any>;

package/dist/types/react/nodes/multiBodiedExtension.d.ts

@@ -12,19 +12,19 @@ import type { ExtensionLayout } from '@atlaskit/adf-schema';
 import type { ExtensionHandlers } from '@atlaskit/editor-common/extensions';
 import type { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
 type Props = React.PropsWithChildren<{
-    serializer: Serializer<any>;
+    content?: any;
     extensionHandlers?: ExtensionHandlers;
-    rendererContext: RendererContext;
-    providers: ProviderFactory;
-    extensionType: string;
     extensionKey: string;
-    path?: PMNode[];
-    originalContent?: any;
-    parameters?: any;
-    content?: any;
+    extensionType: string;
     layout?: ExtensionLayout;
     localId?: string;
     marks?: PMMark[];
+    originalContent?: any;
+    parameters?: any;
+    path?: PMNode[];
+    providers: ProviderFactory;
+    rendererContext: RendererContext;
+    serializer: Serializer<any>;
 }>;
 declare const MultiBodiedExtension: (props: Props) => jsx.JSX.Element;
 export default MultiBodiedExtension;

package/dist/types/react/nodes/multiBodiedExtensionOld.d.ts

@@ -11,19 +11,19 @@ import type { ExtensionLayout } from '@atlaskit/adf-schema';
 import type { ExtensionHandlers } from '@atlaskit/editor-common/extensions';
 import type { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
 type Props = React.PropsWithChildren<{
-    serializer: Serializer<any>;
+    content?: any;
     extensionHandlers?: ExtensionHandlers;
-    rendererContext: RendererContext;
-    providers: ProviderFactory;
-    extensionType: string;
     extensionKey: string;
-    path?: PMNode[];
-    originalContent?: any;
-    parameters?: any;
-    content?: any;
+    extensionType: string;
     layout?: ExtensionLayout;
     localId?: string;
     marks?: PMMark[];
+    originalContent?: any;
+    parameters?: any;
+    path?: PMNode[];
+    providers: ProviderFactory;
+    rendererContext: RendererContext;
+    serializer: Serializer<any>;
 }>;
 declare const MultiBodiedExtension: (props: Props) => jsx.JSX.Element;
 export default MultiBodiedExtension;

package/dist/types/react/nodes/orderedList.d.ts

@@ -1,9 +1,9 @@
 import React from 'react';
 import type { Node } from '@atlaskit/editor-prosemirror/model';
 export default function OrderedList(props: {
+    children: React.ReactNode;
+    content?: Node[];
     order?: number;
-    start?: number;
     path?: Node[];
-    content?: Node[];
-    children: React.ReactNode;
+    start?: number;
 }): React.JSX.Element;

package/dist/types/react/nodes/panel.d.ts

@@ -7,14 +7,14 @@ import { jsx } from '@emotion/react';
 import { PanelType } from '@atlaskit/adf-schema';
 import type { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
 export interface Props {
-    children?: React.ReactNode;
-    providers?: ProviderFactory;
-    panelType: PanelType;
     allowCustomPanels?: boolean;
+    children?: React.ReactNode;
+    panelColor?: string;
     panelIcon?: string;
     panelIconId?: string;
     panelIconText?: string;
-    panelColor?: string;
+    panelType: PanelType;
+    providers?: ProviderFactory;
 }
 declare const Panel: (props: Props) => jsx.JSX.Element;
 export default Panel;

package/dist/types/react/nodes/placeholder.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
 interface Props {
-    text: string;
     allowPlaceholderText?: boolean;
+    text: string;
 }
 export default function Placeholder(props: Props): React.JSX.Element;
 export {};

package/dist/types/react/nodes/status.d.ts

@@ -2,9 +2,9 @@ import React from 'react';
 import { type Color } from '@atlaskit/status/element';
 import { type MarkDataAttributes } from '../../ui/annotations/element/useInlineAnnotationProps';
 export interface Props extends MarkDataAttributes {
-    text: string;
     color: Color;
     localId?: string;
+    text: string;
 }
 declare const _default: React.NamedExoticComponent<Props>;
 export default _default;

package/dist/types/react/nodes/table/sticky.d.ts

@@ -11,22 +11,22 @@ import type { RendererAppearance } from '../../../ui/Renderer/types';
 export type StickyMode = 'none' | 'stick' | 'pin-bottom';
 export declare const tableStickyPadding = 8;
 type StickyTableProps = {
-    left?: number;
-    top?: number;
-    mode: StickyMode;
+    allowTableResizing?: boolean;
+    children: React.ReactNode[];
+    columnWidths?: number[];
+    fixTableSSRResizing?: boolean;
     innerRef: React.RefObject<HTMLDivElement>;
-    rowHeight: number;
-    wrapperWidth: number;
-    tableWidth: 'inherit' | number;
     isNumberColumnEnabled: boolean;
-    children: React.ReactNode[];
     layout: TableLayout;
-    columnWidths?: number[];
+    left?: number;
+    mode: StickyMode;
+    rendererAppearance: RendererAppearance;
     renderWidth: number;
+    rowHeight: number;
     tableNode?: PMNode;
-    rendererAppearance: RendererAppearance;
-    allowTableResizing?: boolean;
-    fixTableSSRResizing?: boolean;
+    tableWidth: 'inherit' | number;
+    top?: number;
+    wrapperWidth: number;
 } & OverflowShadowProps;
 export declare const StickyTable: ({ top, left, mode, shadowClassNames, innerRef, wrapperWidth, tableWidth, isNumberColumnEnabled, layout, children, columnWidths, renderWidth, rowHeight, tableNode, rendererAppearance, allowTableResizing, fixTableSSRResizing, }: StickyTableProps) => jsx.JSX.Element;
 /**

package/dist/types/react/nodes/table/table.d.ts

@@ -1,10 +1,10 @@
 import React from 'react';
 import type { SharedTableProps } from './types';
 type TableProps = SharedTableProps & {
-    innerRef?: React.RefObject<HTMLTableElement>;
     children: React.ReactNode[];
-    isPresentational?: boolean;
     fixTableSSRResizing?: boolean;
+    innerRef?: React.RefObject<HTMLTableElement>;
+    isPresentational?: boolean;
 };
 export declare const Table: React.MemoExoticComponent<({ innerRef, isNumberColumnEnabled, columnWidths, layout, renderWidth, children, tableNode, rendererAppearance, isInsideOfBlockNode, isInsideOfTable, isinsideMultiBodiedExtension, allowTableResizing, isPresentational, fixTableSSRResizing, }: TableProps) => React.JSX.Element>;
 export {};

package/dist/types/react/nodes/table/types.d.ts

@@ -2,14 +2,14 @@ import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
 import type { TableLayout } from '@atlaskit/adf-schema';
 import type { RendererAppearance } from '../../../ui/Renderer/types';
 export type SharedTableProps = {
+    allowTableResizing?: boolean;
     columnWidths?: Array<number>;
-    layout: TableLayout;
+    isinsideMultiBodiedExtension?: boolean;
+    isInsideOfBlockNode?: boolean;
+    isInsideOfTable?: boolean;
     isNumberColumnEnabled: boolean;
+    layout: TableLayout;
+    rendererAppearance: RendererAppearance;
     renderWidth: number;
     tableNode?: PMNode;
-    rendererAppearance: RendererAppearance;
-    isInsideOfBlockNode?: boolean;
-    isInsideOfTable?: boolean;
-    isinsideMultiBodiedExtension?: boolean;
-    allowTableResizing?: boolean;
 };

package/dist/types/react/nodes/table.d.ts

@@ -21,15 +21,15 @@ export declare const shouldHeaderStick: (scrollTop: number, tableTop: number, ta
 export declare const shouldHeaderPinBottom: (scrollTop: number, tableBottom: number, rowHeight: number) => boolean;
 export declare const addSortableColumn: (rows: React.ReactElement<any>[], tableOrderStatus: TableOrderStatus | undefined, onSorting: (columnIndex: number, sortOrder: SortOrder) => void) => React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
 export type TableProps = SharedTableProps & {
-    children: React.ReactElement<any> | Array<React.ReactElement<any>>;
-    tableNode?: PMNode;
-    rendererAppearance?: RendererAppearance;
     allowColumnSorting?: boolean;
-    stickyHeaders?: StickyHeaderConfig;
     allowTableAlignment?: boolean;
     allowTableResizing?: boolean;
-    isPresentational?: boolean;
+    children: React.ReactElement<any> | Array<React.ReactElement<any>>;
     disableTableOverflowShadow?: boolean;
+    isPresentational?: boolean;
+    rendererAppearance?: RendererAppearance;
+    stickyHeaders?: StickyHeaderConfig;
+    tableNode?: PMNode;
 };
 export declare const isHeaderRowEnabled: (rows: (React.ReactChild | React.ReactFragment | React.ReactPortal)[]) => any;
 export declare const tableCanBeSticky: (node: PMNode | undefined, children: (React.ReactChild | React.ReactFragment | React.ReactPortal)[]) => any;
@@ -38,9 +38,9 @@ export interface TableOrderStatus {
     order: SortOrder;
 }
 export interface TableState {
+    headerRowHeight: number;
     stickyMode: StickyMode;
     wrapperWidth: number;
-    headerRowHeight: number;
 }
 /**
  *

package/dist/types/react/nodes/tableCell.d.ts

@@ -3,20 +3,20 @@ import type { CellAttributes } from '@atlaskit/adf-schema';
 import { SortOrder } from '@atlaskit/editor-common/types';
 import type { AnalyticsEventPayload } from '../../analytics/events';
 type CellProps = CellAttributes & {
+    ariaSort?: string;
     children?: React.ReactNode;
-    onClick?: () => void;
     className?: string;
     colGroupWidth?: string;
     offsetTop?: number;
-    ariaSort?: string;
+    onClick?: () => void;
 };
 export type CellWithSortingProps = CellProps & {
-    isHeaderRow?: boolean;
     allowColumnSorting?: boolean;
-    onSorting?: (columnIndex?: number, currentSortOrdered?: SortOrder) => void;
     columnIndex?: number;
-    sortOrdered?: SortOrder;
     fireAnalyticsEvent?: (event: AnalyticsEventPayload) => void;
+    isHeaderRow?: boolean;
+    onSorting?: (columnIndex?: number, currentSortOrdered?: SortOrder) => void;
+    sortOrdered?: SortOrder;
 };
 export declare const withSortableColumn: (WrapperComponent: React.ElementType) => (props: CellWithSortingProps) => React.JSX.Element;
 export declare const TableHeader: (props: CellWithSortingProps) => React.JSX.Element;

package/dist/types/react/nodes/tableNew.d.ts

@@ -22,14 +22,14 @@ export declare const shouldHeaderStick: (scrollTop: number, tableTop: number, ta
 export declare const shouldHeaderPinBottom: (scrollTop: number, tableBottom: number, rowHeight: number) => boolean;
 export declare const addSortableColumn: (rows: React.ReactElement<any>[], tableOrderStatus: TableOrderStatus | undefined, onSorting: (columnIndex: number, sortOrder: SortOrder) => void) => React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
 export type TableProps = SharedTableProps & {
-    children: React.ReactElement<any> | Array<React.ReactElement<any>>;
-    tableNode?: PMNode;
-    rendererAppearance?: RendererAppearance;
     allowColumnSorting?: boolean;
-    stickyHeaders?: StickyHeaderConfig;
     allowTableAlignment?: boolean;
     allowTableResizing?: boolean;
+    children: React.ReactElement<any> | Array<React.ReactElement<any>>;
     isPresentational?: boolean;
+    rendererAppearance?: RendererAppearance;
+    stickyHeaders?: StickyHeaderConfig;
+    tableNode?: PMNode;
 };
 export declare const isHeaderRowEnabled: (rows: (React.ReactChild | React.ReactFragment | React.ReactPortal)[]) => any;
 export declare const tableCanBeSticky: (node: PMNode | undefined, children: (React.ReactChild | React.ReactFragment | React.ReactPortal)[]) => any;
@@ -38,9 +38,9 @@ export interface TableOrderStatus {
     order: SortOrder;
 }
 export interface TableState {
+    headerRowHeight: number;
     stickyMode: StickyMode;
     wrapperWidth: number;
-    headerRowHeight: number;
 }
 /**
  * TableContainer renders tables using only CSS-based rules

package/dist/types/react/nodes/tableRow.d.ts

@@ -1,16 +1,16 @@
 import React from 'react';
 import { SortOrder } from '@atlaskit/editor-common/types';
 type Props = {
-    isNumberColumnEnabled?: number;
-    index?: number;
+    allowColumnSorting?: boolean;
     children?: React.ReactNode;
+    index?: number;
+    innerRef?: React.Ref<HTMLTableRowElement>;
+    isNumberColumnEnabled?: number;
     onSorting?: (columnIndex?: number, currentSortOrdered?: SortOrder) => void;
-    allowColumnSorting?: boolean;
     tableOrderStatus?: {
         columnIndex: number;
         order: SortOrder;
     };
-    innerRef?: React.Ref<HTMLTableRowElement>;
 };
 type State = {
     colGroupWidths: string[];

package/dist/types/react/nodes/task-item-with-providers.d.ts

@@ -2,20 +2,20 @@ import React, { type ReactNode } from 'react';
 import type { ContextIdentifierProvider } from '@atlaskit/editor-common/provider-factory';
 import { type ContentRef, type TaskDecisionProvider } from '@atlaskit/task-decision';
 interface Props {
-    taskId: string;
-    objectAri: string;
-    isDone: boolean;
-    isRenderer?: boolean;
-    contentRef?: ContentRef;
-    onChange?: (taskId: string, isChecked: boolean) => void;
-    showPlaceholder?: boolean;
     children?: ReactNode;
-    taskDecisionProvider?: Promise<TaskDecisionProvider>;
+    contentRef?: ContentRef;
     contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
-    disabled?: boolean;
     dataAttributes?: {
         [key: string]: string | number;
     };
+    disabled?: boolean;
+    isDone: boolean;
+    isRenderer?: boolean;
+    objectAri: string;
+    onChange?: (taskId: string, isChecked: boolean) => void;
+    showPlaceholder?: boolean;
+    taskDecisionProvider?: Promise<TaskDecisionProvider>;
+    taskId: string;
 }
 export default function TaskItemWithProviders(props: Props): React.JSX.Element;
 export {};

package/dist/types/react/nodes/taskItem.d.ts

@@ -2,12 +2,12 @@ import React, { PureComponent, type ReactNode } from 'react';
 import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
 import { type RendererContext, type NodeProps } from '../types';
 export interface Props {
+    children?: ReactNode;
+    disabled?: boolean;
     localId: string;
+    providers?: ProviderFactory;
     rendererContext?: RendererContext;
     state?: string;
-    providers?: ProviderFactory;
-    children?: ReactNode;
-    disabled?: boolean;
 }
 export default class TaskItem extends PureComponent<NodeProps<Props>, Object> {
     private providerFactory;

package/dist/types/react/nodes/taskList.d.ts

@@ -1,7 +1,7 @@
 import React, { PureComponent, type ReactNode } from 'react';
 export interface Props {
-    localId?: string;
     children?: ReactNode;
+    localId?: string;
 }
 export default class TaskList extends PureComponent<Props, Object> {
     render(): React.JSX.Element | null;

package/dist/types/react/nodes/text-wrapper.d.ts

@@ -3,11 +3,11 @@ import React from 'react';
 import type { TextHighlighter } from '../types';
 import type { Mark } from '@atlaskit/editor-prosemirror/model';
 type Props = {
-    startPos: number;
-    endPos: number;
     children?: ReactNode | null;
-    textHighlighter?: TextHighlighter;
+    endPos: number;
     marks?: readonly Mark[];
+    startPos: number;
+    textHighlighter?: TextHighlighter;
 };
 declare const TextWrapper: (props: Props) => React.JSX.Element | null;
 export default TextWrapper;

package/dist/types/react/types.d.ts

@@ -8,66 +8,66 @@ import type { Serializer } from '../serializer';
 import type { RendererAppearance, HeadingAnchorLinksProps } from '../ui/Renderer/types';
 import type { AnnotationId, AnnotationTypes } from '@atlaskit/adf-schema';
 export interface RendererContext {
-    objectAri?: string;
-    containerAri?: string;
     adDoc?: any;
+    containerAri?: string;
+    objectAri?: string;
     schema?: Schema;
 }
 export interface NodeMeta {
-    text?: PMNode['text'];
-    providers?: ProviderFactory | undefined;
-    eventHandlers?: EventHandlers | undefined;
-    extensionHandlers?: ExtensionHandlers | undefined;
-    portal?: HTMLElement | undefined;
-    rendererContext?: RendererContext;
-    serializer: Serializer<JSX.Element>;
+    [key: string]: any;
+    allowCopyToClipboard?: boolean;
+    allowCustomPanels?: boolean;
+    allowHeadingAnchorLinks?: HeadingAnchorLinksProps;
+    allowPlaceholderText?: boolean;
+    allowWrapCodeBlock?: boolean;
     content?: {
         [key: string]: any;
     } | null;
-    allowHeadingAnchorLinks?: HeadingAnchorLinksProps;
-    allowCopyToClipboard?: boolean;
-    allowWrapCodeBlock?: boolean;
-    allowPlaceholderText?: boolean;
-    allowCustomPanels?: boolean;
-    rendererAppearance?: RendererAppearance;
-    fireAnalyticsEvent?: (event: AnalyticsEventPayload) => void;
-    nodeType: NodeType['name'];
-    marks: PMNode['marks'];
     dataAttributes: {
         'data-renderer-start-pos': number;
     };
-    [key: string]: any;
+    eventHandlers?: EventHandlers | undefined;
+    extensionHandlers?: ExtensionHandlers | undefined;
+    fireAnalyticsEvent?: (event: AnalyticsEventPayload) => void;
+    marks: PMNode['marks'];
+    nodeType: NodeType['name'];
+    portal?: HTMLElement | undefined;
+    providers?: ProviderFactory | undefined;
+    rendererAppearance?: RendererAppearance;
+    rendererContext?: RendererContext;
+    serializer: Serializer<JSX.Element>;
+    text?: PMNode['text'];
 }
 export interface MarkMeta {
+    [key: string]: any;
     dataAttributes: {
-        'data-renderer-mark': true;
         'data-block-mark'?: true;
+        'data-renderer-mark': true;
     };
     eventHandlers?: EventHandlers;
     fireAnalyticsEvent?: (event: AnalyticsEventPayload) => void;
-    markKey?: any;
     isInline?: boolean;
-    [key: string]: any;
+    markKey?: any;
 }
 export interface AnnotationMarkMeta extends MarkMeta {
-    id: AnnotationId;
-    annotationType: AnnotationTypes;
-    annotationParentIds: string[];
     allowAnnotations: boolean;
-    useBlockLevel?: boolean;
+    annotationParentIds: string[];
+    annotationType: AnnotationTypes;
+    id: AnnotationId;
     isMediaInline?: boolean;
+    useBlockLevel?: boolean;
 }
 export type NodeProps<NodeAttrs = Object> = NodeAttrs & PropsWithChildren<NodeMeta>;
 export type MarkProps<MarkAttrs = Object> = MarkAttrs & PropsWithChildren<MarkMeta>;
 export type TextHighlighter = {
-    pattern: RegExp;
     component: React.ComponentType<{
         children: React.ReactNode;
-        match: string;
-        marks: Set<string>;
         groups: Array<string> | undefined;
+        marks: Set<string>;
+        match: string;
         startPos: number;
     }>;
+    pattern: RegExp;
 };
 export interface ExtensionViewportSize {
     extensionId?: string;

package/dist/types/react/utils/segment-text.d.ts

@@ -1,10 +1,10 @@
 import type { TextHighlighter } from '../types';
 export type TextSegment = {
-    type: 'plain';
     text: string;
+    type: 'plain';
 } | {
-    type: 'match';
-    text: string;
     groups: Array<string> | undefined;
+    text: string;
+    type: 'match';
 };
 export declare function segmentText(text: string | undefined, highlighter: TextHighlighter | undefined): Array<TextSegment>;

package/dist/types/render-document.d.ts

@@ -5,15 +5,15 @@ import { type AnalyticsEventPayload } from './analytics/events';
 import { type Serializer } from './serializer';
 import { type RendererAppearance } from './ui/Renderer/types';
 export interface RenderOutput<T> {
+    pmDoc?: PMNode;
     result: T;
     stat: RenderOutputStat;
-    pmDoc?: PMNode;
 }
 export interface RenderOutputStat {
     buildTreeTime?: number;
+    nodesCount?: Record<string, number>;
     sanitizeTime: number;
     serializeTime?: number;
-    nodesCount?: Record<string, number>;
 }
 export interface ResultWithTime<T> {
     output: T;

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

@@ -3,9 +3,9 @@ import { AddMarkStep } from '@atlaskit/editor-prosemirror/transform';
 export declare function isRoot(element: HTMLElement | null): boolean;
 export declare function resolvePos(node: Node | null, offset: number, findEnd?: boolean): number | false;
 interface AnnotationStepOptions {
-    schema: Schema;
     annotationId: string;
     annotationType: 'inlineComment';
+    schema: Schema;
 }
 export declare function getPosFromRange(range: Range): {
     from: number;