@atlaskit/renderer 120.5.0 → 120.5.2

package/dist/types/ui/renderer-props.d.ts

@@ -19,58 +19,6 @@ interface RawObjectFeatureFlags {
     ['renderer-render-tracking']: string;
 }
 export interface RendererProps {
-    document: DocNode;
-    dataProviders?: ProviderFactory;
-    eventHandlers?: EventHandlers;
-    extensionHandlers?: ExtensionHandlers;
-    enableSsrInlineScripts?: boolean;
-    noOpSSRInlineScript?: boolean;
-    onComplete?: (stat: RenderOutputStat) => void;
-    onError?: (error: any) => void;
-    portal?: HTMLElement;
-    rendererContext?: RendererContext;
-    schema?: Schema;
-    appearance?: RendererAppearance;
-    adfStage?: ADFStage;
-    disableHeadingIDs?: boolean;
-    disableActions?: boolean;
-    allowHeadingAnchorLinks?: HeadingAnchorLinksProps;
-    allowPlaceholderText?: boolean;
-    maxHeight?: number;
-    fadeOutHeight?: number;
-    truncated?: boolean;
-    createAnalyticsEvent?: CreateUIAnalyticsEvent;
-    allowColumnSorting?: boolean;
-    shouldOpenMediaViewer?: boolean;
-    allowAltTextOnImages?: boolean;
-    stickyHeaders?: StickyHeaderProps;
-    media?: MediaOptions;
-    emojiResourceConfig?: EmojiResourceConfig;
-    smartLinks?: SmartLinksOptions;
-    extensionViewportSizes?: ExtensionViewportSize[];
-    getExtensionHeight?: GetPMNodeHeight;
-    allowAnnotations?: boolean;
-    annotationProvider?: AnnotationProviders | null;
-    innerRef?: React.RefObject<HTMLDivElement>;
-    /** @deprecated {@link https://hello.atlassian.net/browse/ENGHEALTH-3649 Internal documentation for deprecation (no external access)} This prop will be removed and set as default enabled, as the same flag on the Editor is also now default enabled. */
-    useSpecBasedValidator?: boolean;
-    allowCopyToClipboard?: boolean;
-    allowWrapCodeBlock?: boolean;
-    allowCustomPanels?: boolean;
-    analyticsEventSeverityTracking?: {
-        enabled: boolean;
-        severityNormalThreshold: number;
-        severityDegradedThreshold: number;
-    };
-    allowUgcScrubber?: boolean;
-    allowSelectAllTrap?: boolean;
-    unsupportedContentLevelsTracking?: UnsupportedContentLevelsTracking;
-    nodeComponents?: NodeComponentsProps;
-    isInsideOfInlineExtension?: boolean;
-    isTopLevelRenderer?: boolean;
-    includeNodesCountInStats?: boolean;
-    allowRendererContainerStyles?: boolean;
-    shouldRemoveEmptySpaceAroundContent?: boolean;
     /**
      * When enabled a trailing telepointer will be added to the rendered document
      * following content updates.
@@ -81,18 +29,46 @@ export interface RendererProps {
      * is updated as a result of a content update.
      */
     addTelepointer?: boolean;
-    textHighlighter?: TextHighlighter;
+    adfStage?: ADFStage;
+    allowAltTextOnImages?: boolean;
+    allowAnnotations?: boolean;
+    allowColumnSorting?: boolean;
+    allowCopyToClipboard?: boolean;
+    allowCustomPanels?: boolean;
+    allowHeadingAnchorLinks?: HeadingAnchorLinksProps;
+    allowPlaceholderText?: boolean;
+    allowRendererContainerStyles?: boolean;
+    allowSelectAllTrap?: boolean;
+    allowUgcScrubber?: boolean;
+    allowWrapCodeBlock?: boolean;
+    analyticsEventSeverityTracking?: {
+        enabled: boolean;
+        severityDegradedThreshold: number;
+        severityNormalThreshold: number;
+    };
+    annotationProvider?: AnnotationProviders | null;
+    appearance?: RendererAppearance;
+    createAnalyticsEvent?: CreateUIAnalyticsEvent;
     /**
-     * When true, elements may render without their default semantic roles
-     * (e.g., using role="presentation"), indicating that they are used solely for layout or styling purposes.
-     * Elements currently affected: Tables.
+     * Creates a new `Serializer` to transform the ADF `document` into `JSX.Element`.
+     * Allows Confluence to implement {@link https://hello.atlassian.net/wiki/spaces/~lmarinov/pages/5177285037/COMPLEXIT+Progressive+rendering+of+ADF progressive rendering}.
      */
-    UNSTABLE_isPresentational?: boolean;
+    createSerializer?(init: ReactSerializerInit): Serializer<JSX.Element> | null;
+    dataProviders?: ProviderFactory;
+    disableActions?: boolean;
+    disableHeadingIDs?: boolean;
     /**
      * When true, disables the overflow shadow (visual indication) on the edges
      * of tables.
      */
     disableTableOverflowShadow?: boolean;
+    document: DocNode;
+    emojiResourceConfig?: EmojiResourceConfig;
+    enableSsrInlineScripts?: boolean;
+    eventHandlers?: EventHandlers;
+    extensionHandlers?: ExtensionHandlers;
+    extensionViewportSizes?: ExtensionViewportSize[];
+    fadeOutHeight?: number;
     /**
      * @default undefined
      * @description
@@ -124,14 +100,38 @@ export interface RendererProps {
     featureFlags?: {
         [featureFlag: string]: boolean;
     } | Partial<RawObjectFeatureFlags>;
-    /** @deprecated {@link https://hello.atlassian.net/browse/ENGHEALTH-26490 Internal documentation for deprecation (no external access)}  This prop has been marked stable and therefore replaced by the `textHighlighter` prop. Please use `textHighlighter` prop instead. */
-    UNSTABLE_textHighlighter?: TextHighlighter;
+    getExtensionHeight?: GetPMNodeHeight;
+    includeNodesCountInStats?: boolean;
+    innerRef?: React.RefObject<HTMLDivElement>;
+    isInsideOfInlineExtension?: boolean;
+    isTopLevelRenderer?: boolean;
+    maxHeight?: number;
+    media?: MediaOptions;
+    nodeComponents?: NodeComponentsProps;
+    noOpSSRInlineScript?: boolean;
+    onComplete?: (stat: RenderOutputStat) => void;
+    onError?: (error: any) => void;
+    portal?: HTMLElement;
+    rendererContext?: RendererContext;
+    schema?: Schema;
+    shouldOpenMediaViewer?: boolean;
+    shouldRemoveEmptySpaceAroundContent?: boolean;
+    smartLinks?: SmartLinksOptions;
+    stickyHeaders?: StickyHeaderProps;
+    textHighlighter?: TextHighlighter;
+    truncated?: boolean;
     UNSTABLE_allowTableAlignment?: boolean;
     UNSTABLE_allowTableResizing?: boolean;
     /**
-     * Creates a new `Serializer` to transform the ADF `document` into `JSX.Element`.
-     * Allows Confluence to implement {@link https://hello.atlassian.net/wiki/spaces/~lmarinov/pages/5177285037/COMPLEXIT+Progressive+rendering+of+ADF progressive rendering}.
+     * When true, elements may render without their default semantic roles
+     * (e.g., using role="presentation"), indicating that they are used solely for layout or styling purposes.
+     * Elements currently affected: Tables.
      */
-    createSerializer?(init: ReactSerializerInit): Serializer<JSX.Element> | null;
+    UNSTABLE_isPresentational?: boolean;
+    /** @deprecated {@link https://hello.atlassian.net/browse/ENGHEALTH-26490 Internal documentation for deprecation (no external access)}  This prop has been marked stable and therefore replaced by the `textHighlighter` prop. Please use `textHighlighter` prop instead. */
+    UNSTABLE_textHighlighter?: TextHighlighter;
+    unsupportedContentLevelsTracking?: UnsupportedContentLevelsTracking;
+    /** @deprecated {@link https://hello.atlassian.net/browse/ENGHEALTH-3649 Internal documentation for deprecation (no external access)} This prop will be removed and set as default enabled, as the same flag on the Editor is also now default enabled. */
+    useSpecBasedValidator?: boolean;
 }
 export {};

package/dist/types-ts4.5/actions/index.d.ts

@@ -6,8 +6,8 @@ import type { Step } from '@atlaskit/editor-prosemirror/transform';
 import { RemoveMarkStep, RemoveNodeMarkStep } from '@atlaskit/editor-prosemirror/transform';
 import type { AnalyticsEventPayload } from '../analytics/events';
 type ActionResult = {
-    step: Step;
     doc: JSONDocNode;
+    step: Step;
 } | false;
 type Position = {
     from: number;
@@ -24,9 +24,9 @@ interface RendererActionsOptions {
 }
 export type ApplyAnnotation = (pos: Position, annotation: Annotation) => AnnotationActionResult;
 interface AnnotationsRendererActionsOptions {
-    isValidAnnotationPosition: (pos: Position) => boolean;
     applyAnnotation: ApplyAnnotation;
     getAnnotationMarks: () => Mark[];
+    isValidAnnotationPosition: (pos: Position) => boolean;
 }
 interface PositionRendererActionsOptions {
     getPositionFromRange: (range: Range) => Position | false;

package/dist/types-ts4.5/actions/matches-utils.d.ts

@@ -1,8 +1,8 @@
 import type { Node, Schema } from '@atlaskit/editor-prosemirror/model';
 export declare function getIndexMatch(doc: Node, schema: Schema, selectedText: string, startIndex: number): {
-    numMatches: number;
+    blockNodePos?: number;
     matchIndex: number;
+    numMatches: number;
     textContent: string;
-    blockNodePos?: number;
 };
 export declare function countMatches(searchString: string, query: string): number;

package/dist/types-ts4.5/analytics/events.d.ts

@@ -15,40 +15,40 @@ type RendererStartAEP = AEP<ACTION.STARTED, ACTION_SUBJECT.RENDERER, undefined,
     platform: PLATFORM.WEB;
 }, EVENT_TYPE.UI>;
 type RendererRenderedAEP = AEP<ACTION.RENDERED, ACTION_SUBJECT.RENDERER, undefined, {
-    platform: PLATFORM.WEB;
-    duration: number;
     distortedDuration: boolean;
-    ttfb?: number;
+    duration: number;
     nodes: Record<string, number>;
+    platform: PLATFORM.WEB;
     severity?: SEVERITY;
+    ttfb?: number;
 }, EVENT_TYPE.OPERATIONAL>;
 export type ComponentCrashErrorAEP = OperationalAEP<ACTION.CRASHED, ACTION_SUBJECT.RENDERER, ACTION_SUBJECT_ID, {
-    platform: PLATFORM.WEB;
-    errorMessage?: string;
-    errorStack?: string;
     componentStack?: string;
+    errorMessage?: string;
     errorRethrown?: boolean;
+    errorStack?: string;
+    platform: PLATFORM.WEB;
 }>;
 export type ComponentCaughtDomErrorAEP = OperationalAEP<ACTION.CAUGHT_DOM_ERROR, ACTION_SUBJECT.RENDERER, ACTION_SUBJECT_ID, {
     errorMessage: string;
     platform: PLATFORM.WEB;
 }>;
 type InvalidProsemirrorDocumentErrorAEP = AEP<ACTION.INVALID_PROSEMIRROR_DOCUMENT, ACTION_SUBJECT.RENDERER, ACTION_SUBJECT_ID, {
-    platform: PLATFORM.WEB;
     errorStack?: string;
+    platform: PLATFORM.WEB;
 }, EVENT_TYPE.OPERATIONAL>;
 type RendererUnsupportedContentLevelsTrackingSucceeded = AEP<ACTION.UNSUPPORTED_CONTENT_LEVELS_TRACKING_SUCCEEDED, ACTION_SUBJECT.RENDERER, undefined, {
     appearance?: string;
     platform: PLATFORM.WEB;
-    unsupportedContentLevelSeverity: UNSUPPORTED_CONTENT_LEVEL_SEVERITY;
+    supportedNodesCount: number;
     unsupportedContentLevelPercentage: number;
+    unsupportedContentLevelSeverity: UNSUPPORTED_CONTENT_LEVEL_SEVERITY;
     unsupportedNodesCount: number;
-    supportedNodesCount: number;
     unsupportedNodeTypeCount: Record<string, number>;
 }, EVENT_TYPE.OPERATIONAL>;
 type RendererUnsupportedContentLevelsTrackingErrored = AEP<ACTION.UNSUPPORTED_CONTENT_LEVELS_TRACKING_ERRORED, ACTION_SUBJECT.RENDERER, undefined, {
-    platform: PLATFORM.WEB;
     error: string;
+    platform: PLATFORM.WEB;
 }, EVENT_TYPE.OPERATIONAL>;
 type RendererSelectAllCaughtAEP = AEP<ACTION.SELECT_ALL_CAUGHT, ACTION_SUBJECT.RENDERER, undefined, {
     platform: PLATFORM.WEB;
@@ -59,8 +59,8 @@ type RendererSelectAllEscapedAEP = AEP<ACTION.SELECT_ALL_ESCAPED, ACTION_SUBJECT
 type UIAEP<Action, ActionSubject, ActionSubjectID, Attributes> = AEP<Action, ActionSubject, ActionSubjectID, Attributes, EVENT_TYPE.UI>;
 type ButtonAEP<ActionSubjectID, Attributes> = UIAEP<ACTION.CLICKED, ACTION_SUBJECT.BUTTON, ActionSubjectID, Attributes>;
 type AnchorLinkAEP = UIAEP<ACTION.VIEWED, ACTION_SUBJECT.ANCHOR_LINK, undefined, {
-    platform: PLATFORM.WEB;
     mode: MODE.RENDERER;
+    platform: PLATFORM.WEB;
 }>;
 type CodeBlockCopyAEP = ButtonAEP<ACTION_SUBJECT_ID.CODEBLOCK_COPY, undefined>;
 type CodeBlockWrapAEP = ButtonAEP<ACTION_SUBJECT_ID.CODEBLOCK_WRAP, {
@@ -68,27 +68,27 @@ type CodeBlockWrapAEP = ButtonAEP<ACTION_SUBJECT_ID.CODEBLOCK_WRAP, {
 }>;
 type HeadingAnchorLinkButtonAEP = ButtonAEP<ACTION_SUBJECT_ID.HEADING_ANCHOR_LINK, undefined>;
 type TableSortColumnNotAllowedAEP = AEP<ACTION.SORT_COLUMN_NOT_ALLOWED, ACTION_SUBJECT.TABLE, undefined, {
-    platform: PLATFORM.WEB;
     mode: MODE.RENDERER;
+    platform: PLATFORM.WEB;
 }, EVENT_TYPE.TRACK>;
 type TableSortColumnAEP = AEP<ACTION.SORT_COLUMN, ACTION_SUBJECT.TABLE, undefined, {
-    platform: PLATFORM.WEB;
+    columnIndex: number;
     mode: MODE.RENDERER;
+    platform: PLATFORM.WEB;
     sortOrder: SortOrder;
-    columnIndex: number;
 }, EVENT_TYPE.TRACK>;
 type VisitLinkAEP = AEP<ACTION.VISITED, ACTION_SUBJECT.LINK, undefined, {
-    platform: PLATFORM.WEB;
     mode: MODE.RENDERER;
+    platform: PLATFORM.WEB;
 }, EVENT_TYPE.TRACK>;
 type VisitMediaLinkAEP = AEP<ACTION.VISITED, ACTION_SUBJECT.MEDIA, ACTION_SUBJECT_ID.LINK, {
-    platform: PLATFORM.WEB;
     mode: MODE.RENDERER;
+    platform: PLATFORM.WEB;
 }, EVENT_TYPE.TRACK>;
 type ExpandAEP = AEP<ACTION.TOGGLE_EXPAND, ACTION_SUBJECT.EXPAND | ACTION_SUBJECT.NESTED_EXPAND, undefined, {
-    platform: PLATFORM.WEB;
-    mode: MODE.RENDERER;
     expanded: boolean;
+    mode: MODE.RENDERER;
+    platform: PLATFORM.WEB;
 }, EVENT_TYPE.TRACK>;
 type AnnotationActionType = ACTION.INSERTED | ACTION.CLOSED | ACTION.EDITED | ACTION.DELETED | ACTION.OPENED | ACTION.RESOLVED | ACTION.VIEWED | ACTION.CREATE_NOT_ALLOWED;
 type AnnotationAEPAttributes = AnnotationDraftAEPAttributes | AnnotationResolvedAEPAttributes;

package/dist/types-ts4.5/analytics/unsupported-content.d.ts

@@ -2,9 +2,9 @@ import type { UnsupportedContentLevelsTracking } from '@atlaskit/editor-common/u
 import type { AnalyticsEventPayload } from './events';
 type DispatchAnalyticsEvent = (event: AnalyticsEventPayload) => void;
 type DocumentData = {
-    rendererId: string;
-    doc: any;
     appearance?: string;
+    doc: any;
+    rendererId: string;
 };
 export declare const trackUnsupportedContentLevels: (item: DocumentData, trackingOptions: UnsupportedContentLevelsTracking, dispatchAnalyticsEvent: DispatchAnalyticsEvent) => void;
 export {};

package/dist/types-ts4.5/react/index.d.ts

@@ -12,47 +12,47 @@ import type { MediaOptions } from '../types/mediaOptions';
 import type { SmartLinksOptions } from '../types/smartLinksOptions';
 import type { EmojiResourceConfig } from '@atlaskit/emoji/resource';
 export interface ReactSerializerInit {
+    allowAltTextOnImages?: boolean;
+    allowAnnotations?: boolean;
+    allowColumnSorting?: boolean;
+    allowCopyToClipboard?: boolean;
+    allowCustomPanels?: boolean;
+    allowHeadingAnchorLinks?: HeadingAnchorLinksProps;
+    allowMediaLinking?: boolean;
+    allowPlaceholderText?: boolean;
+    allowSelectAllTrap?: boolean;
+    allowTableAlignment?: boolean;
+    allowTableResizing?: boolean;
+    allowWindowedCodeBlock?: boolean;
+    allowWrapCodeBlock?: boolean;
+    appearance?: RendererAppearance;
+    disableActions?: boolean;
+    disableHeadingIDs?: boolean;
+    disableTableOverflowShadow?: boolean;
+    emojiResourceConfig?: EmojiResourceConfig;
+    eventHandlers?: EventHandlers;
+    extensionHandlers?: ExtensionHandlers;
+    extensionViewportSizes?: ExtensionViewportSize[];
+    fireAnalyticsEvent?: (event: AnalyticsEventPayload) => void;
+    getExtensionHeight?: GetPMNodeHeight;
+    isInsideOfInlineExtension?: boolean;
+    isPresentational?: boolean;
+    media?: MediaOptions;
+    nodeComponents?: NodeComponentsProps;
+    objectContext?: RendererContext;
+    portal?: HTMLElement;
+    providers?: ProviderFactory;
+    shouldOpenMediaViewer?: boolean;
+    smartLinks?: SmartLinksOptions;
     /**
      * Used for to set positions on nodes for annotations.
      *
      * When not provided defaults to 1.
      */
     startPos?: number;
-    providers?: ProviderFactory;
-    eventHandlers?: EventHandlers;
-    extensionHandlers?: ExtensionHandlers;
-    portal?: HTMLElement;
-    objectContext?: RendererContext;
-    appearance?: RendererAppearance;
-    disableHeadingIDs?: boolean;
-    disableActions?: boolean;
-    allowHeadingAnchorLinks?: HeadingAnchorLinksProps;
-    allowColumnSorting?: boolean;
-    fireAnalyticsEvent?: (event: AnalyticsEventPayload) => void;
-    shouldOpenMediaViewer?: boolean;
-    allowAltTextOnImages?: boolean;
     stickyHeaders?: StickyHeaderConfig;
-    allowMediaLinking?: boolean;
     surroundTextNodesWithTextWrapper?: boolean;
-    media?: MediaOptions;
-    emojiResourceConfig?: EmojiResourceConfig;
-    smartLinks?: SmartLinksOptions;
-    extensionViewportSizes?: ExtensionViewportSize[];
-    getExtensionHeight?: GetPMNodeHeight;
-    allowCopyToClipboard?: boolean;
-    allowWrapCodeBlock?: boolean;
-    allowPlaceholderText?: boolean;
-    allowCustomPanels?: boolean;
-    allowAnnotations?: boolean;
-    allowSelectAllTrap?: boolean;
-    nodeComponents?: NodeComponentsProps;
-    allowWindowedCodeBlock?: boolean;
-    isInsideOfInlineExtension?: boolean;
     textHighlighter?: TextHighlighter;
-    allowTableAlignment?: boolean;
-    allowTableResizing?: boolean;
-    isPresentational?: boolean;
-    disableTableOverflowShadow?: boolean;
 }
 interface ParentInfo {
     parentIsIncompleteTask: boolean;

package/dist/types-ts4.5/react/marks/link.d.ts

@@ -2,8 +2,8 @@ import { jsx } from '@emotion/react';
 import type { LinkAttributes } from '@atlaskit/adf-schema';
 import type { MarkProps } from '../types';
 interface LinkProps extends LinkAttributes {
-    target?: string;
     isMediaLink?: boolean;
+    target?: string;
 }
 export default function Link(props: MarkProps<LinkProps>): jsx.JSX.Element;
 export {};

package/dist/types-ts4.5/react/nodes/blockCard.d.ts

@@ -8,13 +8,13 @@ import type { RendererAppearance } from '../../ui/Renderer/types';
 import type { SmartLinksOptions } from '../../types/smartLinksOptions';
 import type { DatasourceAttributeProperties } from '@atlaskit/adf-schema/schema';
 export default function BlockCard(props: {
-    url?: string;
     data?: object;
-    eventHandlers?: EventHandlers;
     datasource?: DatasourceAttributeProperties;
+    eventHandlers?: EventHandlers;
+    isNodeNested?: boolean;
+    layout?: string;
     portal?: HTMLElement;
     rendererAppearance?: RendererAppearance;
     smartLinks?: SmartLinksOptions;
-    layout?: string;
-    isNodeNested?: boolean;
+    url?: string;
 }): jsx.JSX.Element;

package/dist/types-ts4.5/react/nodes/bodiedExtension.d.ts

@@ -6,21 +6,21 @@ import type { ExtensionLayout } from '@atlaskit/adf-schema';
 import type { ExtensionHandlers } from '@atlaskit/editor-common/extensions';
 import type { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
 interface Props {
-    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;
+    extensionViewportSizes?: ExtensionViewportSize[];
     layout?: ExtensionLayout;
     localId?: string;
     marks?: PMMark[];
+    originalContent?: any;
+    parameters?: any;
+    path?: PMNode[];
+    providers: ProviderFactory;
+    rendererContext: RendererContext;
+    serializer: Serializer<any>;
     startPos: number;
-    extensionViewportSizes?: ExtensionViewportSize[];
 }
 declare const BodiedExtension: (props: React.PropsWithChildren<Props>) => React.JSX.Element;
 export default BodiedExtension;

package/dist/types-ts4.5/react/nodes/codeBlock/codeBlock.d.ts

@@ -1,12 +1,12 @@
 import type { WrappedComponentProps } from 'react-intl-next';
 import type { SupportedLanguages } from '@atlaskit/code';
 export interface Props {
-    text: string;
-    language: SupportedLanguages;
     allowCopyToClipboard?: boolean;
     allowWrapCodeBlock?: boolean;
-    codeBidiWarningTooltipEnabled: boolean;
     className?: string;
+    codeBidiWarningTooltipEnabled: boolean;
+    language: SupportedLanguages;
+    text: string;
 }
 declare const _default: import("react").FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps>> & {
     WrappedComponent: import("react").ComponentType<Props & WrappedComponentProps>;

package/dist/types-ts4.5/react/nodes/date.d.ts

@@ -2,8 +2,8 @@ import React from 'react';
 import { type WrappedComponentProps } from 'react-intl-next';
 import { type MarkDataAttributes } from '../../ui/annotations/element/useInlineAnnotationProps';
 export interface Props extends MarkDataAttributes {
-    timestamp: string;
     parentIsIncompleteTask?: boolean;
+    timestamp: string;
 }
 export declare const DateComponent: React.FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps>> & {
     WrappedComponent: React.ComponentType<Props & WrappedComponentProps>;

package/dist/types-ts4.5/react/nodes/embedCard.d.ts

@@ -8,18 +8,18 @@ import type { EventHandlers } from '@atlaskit/editor-common/ui';
 import type { RichMediaLayout } from '@atlaskit/adf-schema';
 import type { RendererAppearance } from '../../ui/Renderer/types';
 type EmbedCardInternalProps = {
-    url?: string;
     data?: object;
     eventHandlers?: EventHandlers;
-    portal?: HTMLElement;
+    isInsideOfBlockNode?: boolean;
+    isInsideOfInlineExtension?: boolean;
+    layout: RichMediaLayout;
     originalHeight?: number;
     originalWidth?: number;
-    width?: number;
-    layout: RichMediaLayout;
+    portal?: HTMLElement;
     rendererAppearance?: RendererAppearance;
-    isInsideOfBlockNode?: boolean;
     smartLinks?: SmartLinksOptions;
-    isInsideOfInlineExtension?: boolean;
+    url?: string;
+    width?: number;
 };
 export declare const EmbedOrBlockCardInternal: ({ url, data, eventHandlers, portal, originalHeight, originalWidth, width: embedWidth, layout, rendererAppearance, isInsideOfBlockNode, smartLinks, isInsideOfInlineExtension, }: EmbedCardInternalProps) => jsx.JSX.Element;
 declare const EmbedCardWithCondition: import("react").FC<EmbedCardInternalProps>;

package/dist/types-ts4.5/react/nodes/emoji.d.ts

@@ -10,10 +10,10 @@ import { type MarkDataAttributes } from '../../ui/annotations/element/useInlineA
 import { type EmojiAttributes } from '@atlaskit/adf-schema';
 export interface EmojiProps extends EmojiId, EmojiAttributes, MarkDataAttributes {
     allowTextFallback?: boolean;
-    providers?: ProviderFactory;
     fitToHeight?: number;
-    showTooltip?: boolean;
+    providers?: ProviderFactory;
     resourceConfig?: EmojiResourceConfig;
+    showTooltip?: boolean;
 }
 declare function EmojiItem(props: EmojiProps): jsx.JSX.Element;
 declare namespace EmojiItem {

package/dist/types-ts4.5/react/nodes/extension.d.ts

@@ -7,18 +7,18 @@ import { type ProviderFactory } from '@atlaskit/editor-common/provider-factory';
 import type { OverflowShadowProps } from '@atlaskit/editor-common/ui';
 interface Props {
     extensionHandlers?: ExtensionHandlers;
-    providers: ProviderFactory;
-    rendererContext: RendererContext;
-    extensionType: string;
     extensionKey: string;
-    path?: PMNode[];
-    text?: string;
-    parameters?: any;
+    extensionType: string;
+    extensionViewportSizes?: ExtensionViewportSize[];
     layout?: ExtensionLayout;
     localId?: string;
     marks?: PMMark[];
-    extensionViewportSizes?: ExtensionViewportSize[];
     nodeHeight?: string;
+    parameters?: any;
+    path?: PMNode[];
+    providers: ProviderFactory;
+    rendererContext: RendererContext;
+    text?: string;
 }
 type AllOrNone<T> = T | {
     [K in keyof T]?: never;

package/dist/types-ts4.5/react/nodes/extensionFrame.d.ts

@@ -10,18 +10,18 @@ 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;
+    originalContent?: any;
+    parameters?: any;
+    path?: PMNode[];
+    providers: ProviderFactory;
+    rendererContext: RendererContext;
+    serializer: Serializer<any>;
 }>;
 declare const ExtensionFrame: (props: Props) => jsx.JSX.Element;
 export default ExtensionFrame;

package/dist/types-ts4.5/react/nodes/fallback.d.ts

@@ -3,11 +3,11 @@ type CardErrorBoundaryProps = {
     unsupportedComponent: React.ComponentType<React.PropsWithChildren<unknown>>;
 };
 export declare class CardErrorBoundary extends React.PureComponent<{
-    url?: string;
-    onClick?: (e: React.MouseEvent<HTMLElement>, url?: string) => void;
-    isDatasource?: boolean;
     children?: React.ReactNode;
     datasourceId?: string;
+    isDatasource?: boolean;
+    onClick?: (e: React.MouseEvent<HTMLElement>, url?: string) => void;
+    url?: string;
 } & CardErrorBoundaryProps> {
     state: {
         isError: boolean;

package/dist/types-ts4.5/react/nodes/heading-anchor.d.ts

@@ -2,11 +2,11 @@ import React from 'react';
 import type { WrappedComponentProps } from 'react-intl-next';
 export declare const HeadingAnchorWrapperClassName = "heading-anchor-wrapper";
 type Props = {
-    onCopyText: () => Promise<void>;
     enableNestedHeaderLinks?: boolean;
-    level: number;
-    hideFromScreenReader?: boolean;
     headingId?: string;
+    hideFromScreenReader?: boolean;
+    level: number;
+    onCopyText: () => Promise<void>;
 };
 type HeadingAnchorProps = Props & React.PropsWithChildren<unknown> & WrappedComponentProps;
 declare const _default: React.FC<import("react-intl-next").WithIntlProps<HeadingAnchorProps>> & {

package/dist/types-ts4.5/react/nodes/heading.d.ts

@@ -4,11 +4,11 @@ import { type NodeProps } from '../types';
 import { type HeadingAnchorLinksProps } from '../../ui/Renderer/types';
 export type HeadingLevels = 1 | 2 | 3 | 4 | 5 | 6;
 declare function Heading(props: NodeProps<{
-    level: HeadingLevels;
-    headingId?: string;
-    showAnchorLink?: boolean;
     allowHeadingAnchorLinks?: HeadingAnchorLinksProps;
-    marks?: PMNode['marks'];
+    headingId?: string;
     invisible?: boolean;
+    level: HeadingLevels;
+    marks?: PMNode['marks'];
+    showAnchorLink?: boolean;
 }>): React.JSX.Element;
 export default Heading;