@atlaskit/editor-common 107.28.2 → 107.29.0

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

@@ -9,9 +9,9 @@ export type ExtensionType = string;
 export type ExtensionKey = string;
 export type ExtensionModuleKey = string;
 export type ExtensionComponentProps<T extends Parameters = Parameters> = {
-    node: ExtensionParams<T>;
-    actions?: MultiBodiedExtensionActions;
     [key: string]: any;
+    actions?: MultiBodiedExtensionActions;
+    node: ExtensionParams<T>;
 };
 export type ExtensionComponent<T extends Parameters> = ComponentType<React.PropsWithChildren<ExtensionComponentProps<T>>>;
 export type ExtensionComponentModule<T extends Parameters> = Promise<MaybeESModule<ExtensionComponent<T>>>;
@@ -19,30 +19,30 @@ export type Serializer<T extends Parameters = Parameters> = (data: T) => string;
 export type Deserializer<T extends Parameters = Parameters> = (value: string) => T;
 export type ExtensionModuleActionObject<T extends Parameters = Parameters> = {
     key: ExtensionModuleKey;
-    type: 'node';
     parameters?: T;
+    type: 'node';
 };
 export type MaybeADFEntity = MaybeESModule<ADFEntity | Array<ADFEntity> | void>;
 export type ExtensionModuleActionHandler = (extensionAPI: ExtensionAPI) => Promise<MaybeADFEntity>;
 export type ExtensionModuleAction<T extends Parameters = Parameters> = ExtensionModuleActionObject<T> | ExtensionModuleActionHandler;
 export type ExtensionModule<T extends Parameters = Parameters> = {
-    key: string;
-    title?: string;
+    action: ExtensionModuleAction<T>;
+    categories?: string[];
     description?: string;
-    icon?: () => ExtensionIconModule;
-    priority?: number;
     featured?: boolean;
+    icon?: () => ExtensionIconModule;
+    key: string;
     keywords?: string[];
-    categories?: string[];
-    action: ExtensionModuleAction<T>;
     parameters?: T;
+    priority?: number;
+    title?: string;
 };
 export type DynamicFieldDefinitions<T> = (parameters: T) => FieldDefinition[];
 export type ExtensionModuleNode<T extends Parameters = Parameters> = {
-    type: 'extension' | 'inlineExtension' | 'bodiedExtension' | 'multiBodiedExtension';
+    getFieldsDefinition?: (extensionParameters: T) => Promise<FieldDefinition[] | DynamicFieldDefinitions<T>>;
     render: () => ExtensionComponentModule<T>;
+    type: 'extension' | 'inlineExtension' | 'bodiedExtension' | 'multiBodiedExtension';
     update?: UpdateExtension<T>;
-    getFieldsDefinition?: (extensionParameters: T) => Promise<FieldDefinition[] | DynamicFieldDefinitions<T>>;
 };
 export type PreloadableExtensionModuleNode<T extends Parameters = Parameters> = ExtensionModuleNode<T> & {
     preloadRender: () => Promise<void>;
@@ -64,8 +64,8 @@ export type ExtensionModuleFieldTypeUser = {
     provider: UserFieldContextProvider;
 };
 export type ExtensionModuleFieldTypeFieldset<T extends Parameters = Parameters> = {
-    serializer?: Serializer<T>;
     deserializer?: Deserializer<T>;
+    serializer?: Serializer<T>;
 };
 export type ExtensionModuleFields<T extends Parameters = Parameters> = {
     custom?: {
@@ -79,11 +79,11 @@ export type ExtensionModuleFields<T extends Parameters = Parameters> = {
     };
 };
 export type ExtensionModules<T extends Parameters = Parameters> = {
-    quickInsert?: ExtensionModule<T>[];
-    nodes?: ExtensionModuleNodes<T>;
-    fields?: ExtensionModuleFields<T>;
     autoConvert?: ExtensionModuleAutoConvert;
     contextualToolbars?: ContextualToolbar[];
+    fields?: ExtensionModuleFields<T>;
+    nodes?: ExtensionModuleNodes<T>;
+    quickInsert?: ExtensionModule<T>[];
 };
 export type ExtensionQuickInsertModule = 'quickInsert';
 export type ExtensionModuleType<T extends Parameters = Parameters> = Exclude<keyof ExtensionModules<T>, 'nodes' | 'fields'>;
@@ -95,23 +95,23 @@ export type ExtensionDeprecationStatus = {
     message?: string | React.ReactNode;
 };
 export type ExtensionManifest<T extends Parameters = Parameters> = {
-    type: ExtensionType;
-    key: ExtensionKey;
-    title: string;
-    description?: string;
-    summary?: string;
-    deprecation?: ExtensionDeprecationStatus;
+    autoConvert?: {
+        matchers: Array<AutoConvertMatches>;
+    };
     categories?: string[];
-    keywords?: string[];
+    deprecation?: ExtensionDeprecationStatus;
+    description?: string;
     documentationUrl?: string;
     icons: {
-        '48': () => ExtensionIconModule;
         [dimensions: string]: () => ExtensionIconModule;
+        '48': () => ExtensionIconModule;
     };
+    key: ExtensionKey;
+    keywords?: string[];
     modules: ExtensionModules<T>;
-    autoConvert?: {
-        matchers: Array<AutoConvertMatches>;
-    };
+    summary?: string;
+    title: string;
+    type: ExtensionType;
 };
 export type Icon = () => ExtensionIconModule;
 export type Module<T extends Parameters> = MaybeESModule<T>;

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

@@ -1,10 +1,10 @@
 import { type ExtensionAutoConvertHandler, type ExtensionKey, type ExtensionManifest, type ExtensionType } from './extension-manifest';
 import { type Parameters } from './extension-parameters';
 export interface ExtensionProvider<T extends Parameters = any> {
+    getAutoConverter(): Promise<ExtensionAutoConvertHandler[]>;
+    getExtension(type: ExtensionType, key: ExtensionKey): Promise<ExtensionManifest<T> | undefined>;
     getExtensions(): Promise<ExtensionManifest<T>[]>;
-    preload?(): Promise<void>;
     getPreloadedExtension?(type: ExtensionType, key: ExtensionKey): ExtensionManifest<T> | undefined;
-    getExtension(type: ExtensionType, key: ExtensionKey): Promise<ExtensionManifest<T> | undefined>;
+    preload?(): Promise<void>;
     search(keyword: string): Promise<ExtensionManifest<T>[]>;
-    getAutoConverter(): Promise<ExtensionAutoConvertHandler[]>;
 }

package/dist/types-ts4.5/extensions/types/field-definitions.d.ts

@@ -1,6 +1,4 @@
 export type Option = {
-    label: string;
-    value: string;
     description?: string;
     /**
      * If a string is passed, we use a image tag to create an icon.
@@ -9,141 +7,143 @@ export type Option = {
      * We can't enforce the size if a React component is passed so it's on the consumer to make the appropriate choice.
      */
     icon?: string | React.ReactNode;
+    label: string;
+    value: string;
 };
 import type { Props as SmartUserPickerProps } from '@atlaskit/smart-user-picker';
 export type UserFieldContext = Pick<SmartUserPickerProps, 'siteId' | 'principalId' | 'fieldId' | 'productKey' | 'containerId' | 'objectId' | 'childObjectId' | 'productAttributes' | 'includeUsers'>;
 interface BaseFieldDefinition {
+    allowDuplicates?: boolean;
     description?: string;
+    isDisabled?: boolean;
+    isHidden?: boolean;
+    isRequired?: boolean;
     label: string;
     name: string;
-    isRequired?: boolean;
-    allowDuplicates?: boolean;
-    isHidden?: boolean;
-    isDisabled?: boolean;
 }
 interface BaseEnumField extends BaseFieldDefinition {
-    type: 'enum';
     items: Option[];
+    type: 'enum';
 }
 export interface EnumSingleSelectField extends BaseEnumField {
-    style: 'select';
-    isMultiple?: false;
     defaultValue?: string;
+    isMultiple?: false;
     placeholder?: string;
+    style: 'select';
 }
 export interface EnumRadioFieldBase extends BaseEnumField {
-    style: 'radio';
     isMultiple?: false;
+    style: 'radio';
 }
 export interface EnumRadioFieldDefaulted extends EnumRadioFieldBase {
-    isRequired?: false;
     defaultValue: string;
+    isRequired?: false;
 }
 export interface EnumRadioFieldRequired extends EnumRadioFieldBase {
-    isRequired: true;
     defaultValue?: string;
+    isRequired: true;
 }
 export type EnumRadioField = EnumRadioFieldDefaulted | EnumRadioFieldRequired;
 export interface EnumMultipleSelectField extends BaseEnumField {
-    style: 'select';
-    isMultiple: true;
     defaultValue?: string[];
+    isMultiple: true;
     placeholder?: string;
+    style: 'select';
 }
 export interface EnumCheckboxField extends BaseEnumField {
-    style: 'checkbox';
-    isMultiple: true;
     defaultValue?: string[];
+    isMultiple: true;
+    style: 'checkbox';
 }
 export type EnumSelectField = EnumSingleSelectField | EnumMultipleSelectField;
 export type EnumField = EnumSelectField | EnumRadioField | EnumCheckboxField;
 export interface StringOneLineField extends BaseFieldDefinition {
-    type: 'string';
-    style?: 'oneline';
     defaultValue?: string;
     placeholder?: string;
+    style?: 'oneline';
+    type: 'string';
 }
 export interface StringMultilineField extends BaseFieldDefinition {
-    type: 'string';
-    style: 'multiline';
     defaultValue?: string;
-    placeholder?: string;
     options?: {
         minimumRows: number;
     };
+    placeholder?: string;
+    style: 'multiline';
+    type: 'string';
 }
 export type StringField = StringOneLineField | StringMultilineField;
 export interface NumberField extends BaseFieldDefinition {
-    type: 'number';
     defaultValue?: number;
     placeholder?: string;
+    type: 'number';
 }
 export interface BooleanField extends BaseFieldDefinition {
-    type: 'boolean';
     defaultValue?: boolean | string;
     style?: 'checkbox' | 'toggle';
+    type: 'boolean';
 }
 export interface ColorField extends BaseFieldDefinition {
-    type: 'color';
     defaultValue?: string;
+    type: 'color';
 }
 export interface DateField extends BaseFieldDefinition {
-    type: 'date';
     defaultValue?: string;
     placeholder?: string;
+    type: 'date';
 }
 export interface DateRangeField extends BaseFieldDefinition {
-    type: 'date-range';
     defaultValue?: DateRangeResult;
     items: Option[];
+    type: 'date-range';
 }
 export interface DateRangeResult {
-    type: 'date-range';
-    value: 'custom' | any;
     from?: string;
     to?: string;
+    type: 'date-range';
+    value: 'custom' | any;
 }
 export type FieldHandlerLink = {
     type: string;
 };
 interface BaseCustomField extends BaseFieldDefinition {
-    type: 'custom';
-    style?: 'select';
     options: {
-        isCreatable?: boolean;
         formatCreateLabel?: (inputValue: string) => React.ReactNode;
+        isCreatable?: boolean;
         resolver: FieldHandlerLink;
     };
     placeholder?: string;
+    style?: 'select';
+    type: 'custom';
 }
 export interface CustomSingleField extends BaseCustomField {
-    isMultiple?: false;
     defaultValue?: string;
+    isMultiple?: false;
 }
 export interface CustomMultipleField extends BaseCustomField {
-    isMultiple: true;
     defaultValue?: string[];
+    isMultiple: true;
 }
 export interface UserField extends BaseFieldDefinition {
-    type: 'user';
     defaultValue?: string | string[] | null | undefined;
-    placeholder?: string;
     isMultiple?: boolean;
     options: {
         provider: FieldHandlerLink;
     };
+    placeholder?: string;
+    type: 'user';
 }
 export type CustomField = CustomSingleField | CustomMultipleField;
 export type NativeField = EnumField | StringField | NumberField | BooleanField | ColorField | DateField | DateRangeField;
 export type NestedFieldDefinition = NativeField | CustomField | UserField;
 export interface Fieldset extends BaseFieldDefinition {
-    type: 'fieldset';
     fields: NestedFieldDefinition[];
     options: {
         isDynamic?: boolean;
-        transformer: FieldHandlerLink;
         showTitle?: boolean;
+        transformer: FieldHandlerLink;
     };
+    type: 'fieldset';
 }
 export type FieldDefinition = NestedFieldDefinition | Fieldset | GroupingField;
 export declare const isFieldset: (field: FieldDefinition) => field is Fieldset;
@@ -156,17 +156,17 @@ export interface GroupedField extends BaseFieldDefinition {
     hasGroupedValues?: boolean;
 }
 export interface ExpandField extends GroupedField {
-    type: 'expand';
     isExpanded?: boolean;
+    type: 'expand';
 }
 export interface TabGroupField extends Omit<GroupedField, 'fields'> {
-    type: 'tab-group';
     defaultTab?: string;
     fields: TabField[];
+    type: 'tab-group';
 }
 export interface TabField extends Omit<GroupedField, 'fields'> {
-    type: 'tab';
     fields: (NestedFieldDefinition | ExpandField)[];
+    type: 'tab';
 }
 export type GroupingField = ExpandField | TabGroupField;
 export {};

package/dist/types-ts4.5/extensions/types/utils.d.ts

@@ -1,18 +1,18 @@
 import type { ADFEntity } from '@atlaskit/adf-utils/types';
 import type { ExtensionKey, ExtensionModuleActionHandler, ExtensionType, Icon } from './extension-manifest';
 export type MenuItem = {
-    key: string;
-    extensionType: ExtensionType;
-    extensionKey: ExtensionKey;
-    title: string;
+    categories: string[];
     description?: string;
-    summary?: string;
     documentationUrl?: string;
+    extensionKey: ExtensionKey;
+    extensionType: ExtensionType;
     featured: boolean;
-    keywords: string[];
-    categories: string[];
     icon: Icon;
+    key: string;
+    keywords: string[];
     node: ADFEntity | ExtensionModuleActionHandler;
+    summary?: string;
+    title: string;
 };
 export type MenuItemMap = {
     [key: string]: MenuItem;

package/dist/types-ts4.5/floating-toolbar/DropdownMenuExtensionItems.d.ts

@@ -4,17 +4,17 @@ import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { ExtensionAPI, ExtensionProvider } from '../extensions';
 export interface DropdownMenuOptions {
-    hide: Function;
     dispatchCommand: Function;
+    hide: Function;
     intl: IntlShape;
     showSelected: boolean;
 }
 type OverflowExtensionPlaceholderProps = {
-    node: PMNode;
-    editorView: EditorView;
-    extension: ExtensionProps;
     disabled?: (key: string) => boolean;
     dropdownOptions?: DropdownMenuOptions;
+    editorView: EditorView;
+    extension: ExtensionProps;
+    node: PMNode;
 };
 export type ExtensionProps = {
     extensionApi?: ExtensionAPI;

package/dist/types-ts4.5/floating-toolbar/DropdownMenuItem.d.ts

@@ -10,33 +10,33 @@ export declare const menuItemDimensions: {
     height: number;
 };
 export interface Props {
-    hide: Function;
     dispatchCommand: Function;
-    items: Array<DropdownOptionT<Function>> | FloatingToolbarOverflowDropdownOptions<Function>;
-    showSelected?: boolean;
     editorView?: EditorView;
     extensions?: ExtensionProps;
+    hide: Function;
+    items: Array<DropdownOptionT<Function>> | FloatingToolbarOverflowDropdownOptions<Function>;
+    showSelected?: boolean;
 }
 export type ExtensionProps = {
-    node: Node;
     extensionApi?: ExtensionAPI;
     extensionsProvider?: Promise<ExtensionProvider>;
+    node: Node;
 };
 export interface DropdownButtonItemProps extends ButtonItemProps {
+    onBlur?: (event: React.MouseEvent | React.KeyboardEvent) => void;
+    onFocus?: (event: React.MouseEvent | React.KeyboardEvent) => void;
     onMouseEnter?: (event: React.MouseEvent | React.KeyboardEvent) => void;
-    onMouseOver?: (event: React.MouseEvent | React.KeyboardEvent) => void;
     onMouseLeave?: (event: React.MouseEvent | React.KeyboardEvent) => void;
     onMouseOut?: (event: React.MouseEvent | React.KeyboardEvent) => void;
-    onFocus?: (event: React.MouseEvent | React.KeyboardEvent) => void;
-    onBlur?: (event: React.MouseEvent | React.KeyboardEvent) => void;
+    onMouseOver?: (event: React.MouseEvent | React.KeyboardEvent) => void;
 }
 export type DropdownMenuItemProps = {
-    item: DropdownOptionT<Function>;
-    hide: Function;
     dispatchCommand: Function;
     editorView?: EditorView;
+    hide: Function;
     intl: IntlShape;
-    showSelected: boolean;
+    item: DropdownOptionT<Function>;
     itemSelected?: boolean;
+    showSelected: boolean;
 };
 export declare const DropdownMenuItem: (props: DropdownMenuItemProps) => jsx.JSX.Element;

package/dist/types-ts4.5/guideline/relativeGuideline.d.ts

@@ -3,6 +3,6 @@ import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { GuidelineConfig, RelativeGuides } from './types';
 export declare const getRelativeGuideSnaps: (relativeGuides: RelativeGuides, aspectRatio: number) => number[];
 export declare const getRelativeGuidelines: (relativeGuides: RelativeGuides, nodeWithPos: NodeWithPos, view: EditorView, editorWidth: number, topOffset: number, size: {
-    width: number;
     height: number;
+    width: number;
 }) => GuidelineConfig[];

package/dist/types-ts4.5/guideline/types.d.ts

@@ -3,14 +3,14 @@ import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { CSSToken } from '@atlaskit/tokens';
 export type WidthTypes = 'percentage' | 'pixel';
 export type LengthGuide = {
+    isFullWidth?: boolean;
     left: number;
-    right: number;
     length: number;
-    isFullWidth?: boolean;
+    right: number;
 };
 export type Range = {
-    start: number;
     end: number;
+    start: number;
 };
 export type VerticalPosition = {
     x: number;
@@ -26,18 +26,18 @@ export type GuidelineStyles = {
     show?: boolean;
     styles?: {
         capStyle?: 'line';
-        lineStyle?: 'dashed' | 'solid';
         color?: CSSToken;
+        lineStyle?: 'dashed' | 'solid';
     };
 };
 export type GuidelineConfig = {
+    isFullWidth?: boolean;
     key: string;
     position: Position;
-    isFullWidth?: boolean;
 } & GuidelineStyles;
 export type GuidelineContainerRect = {
-    top: number;
     left: number;
+    top: number;
 };
 export type GuidelinePluginState = {
     guidelines: GuidelineConfig[];
@@ -51,18 +51,18 @@ export type GuidelineSnap = {
     width: number;
 };
 export type GuidelineSnapsReference = {
+    guidelineReference: GuidelineSnap[];
     snaps: {
         x?: number[];
         y?: number[];
     };
-    guidelineReference: GuidelineSnap[];
 };
 export type GuidelineTypes = 'default' | 'temporary' | 'relative' | 'none';
 export type RelativeGuides = {
-    width?: {
+    height?: {
         [key: number]: NodeWithPos[];
     };
-    height?: {
+    width?: {
         [key: number]: NodeWithPos[];
     };
 };

package/dist/types-ts4.5/guideline/updateGuideline.d.ts

@@ -1,5 +1,5 @@
 export declare const getGuidelinesWithHighlights: <T extends {
-    key: string;
     active?: boolean;
+    key: string;
     show?: boolean;
 }>(gap: number, maxGap: number, activeGuidelineKeys: string[], guidelines: T[]) => T[];

package/dist/types-ts4.5/guideline/utils.d.ts

@@ -19,9 +19,9 @@ export declare const getContainerWidthOrFullEditorWidth: (containerWidth: number
  * @returns null or dimensions info
  */
 export declare const getMediaSingleDimensions: (mediaSingle: PMNode, editorWidth?: number) => {
-    width: number;
     height: number;
-    originalWidth: number;
     originalHeight: number;
+    originalWidth: number;
     ratio: number;
+    width: number;
 } | null;

package/dist/types-ts4.5/icons/shared/DynamicStrokeIconDecoration.d.ts

@@ -4,9 +4,9 @@
  */
 import { jsx } from '@emotion/react';
 type DynamicStrokeIconDecorationProps = {
-    selectedColor?: string | null;
     disabled?: boolean;
     icon: React.ReactNode;
+    selectedColor?: string | null;
 };
 export declare const DynamicStrokeIconDecoration: ({ selectedColor, disabled, icon, }: DynamicStrokeIconDecorationProps) => jsx.JSX.Element;
 export {};

package/dist/types-ts4.5/icons/shared/SteppedRainbowIconDecoration.d.ts

@@ -4,9 +4,9 @@
  */
 import { jsx } from '@emotion/react';
 type SteppedRainbowIconDecorationProps = {
-    selectedColor?: string | null;
     disabled?: boolean;
     icon: React.ReactNode;
+    selectedColor?: string | null;
 };
 export declare const SteppedRainbowIconDecoration: ({ selectedColor, disabled, icon, }: SteppedRainbowIconDecorationProps) => jsx.JSX.Element;
 export {};

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

@@ -20,9 +20,9 @@ export declare const insertSelectedItem: (maybeNode?: Node | Object | string | F
  * In this case, the destination node should split
  */
 export declare const shouldSplitSelectedNodeOnNodeInsertion: ({ parentNodeType, grandParentNodeType, content, }: {
-    parentNodeType: NodeType;
-    grandParentNodeType: NodeType;
     content: Node;
+    grandParentNodeType: NodeType;
+    parentNodeType: NodeType;
 }) => boolean;
 /**
  * Check if the current selection contains any nodes that are not permitted

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

@@ -124,10 +124,10 @@ export declare function makeKeymap(description: string, windows: string, mac: st
 export declare function makeKeyMapWithCommon(description: string, common: string): Keymap;
 export declare function makeKeyMapArrayWithCommon(description: string, shortcuts: string[]): Keymap[];
 export interface Keymap {
+    common?: string;
     description: string;
-    windows: string;
     mac: string;
-    common?: string;
+    windows: string;
 }
 export declare function bindKeymapWithCommand(shortcut: string, cmd: Command, keymap: {
     [key: string]: Command;

package/dist/types-ts4.5/lazy-node-view/index.d.ts

@@ -25,10 +25,10 @@ export type CreateReactNodeViewProps<NodeViewOptions> = (node: PMNode, view: Edi
  * @see {withLazyLoading}
  */
 export type LazyLoadingProps<NodeViewOptions> = {
-    nodeName: string;
-    loader: () => Promise<CreateReactNodeViewProps<NodeViewOptions>>;
-    getNodeViewOptions: () => NodeViewOptions;
     dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    getNodeViewOptions: () => NodeViewOptions;
+    loader: () => Promise<CreateReactNodeViewProps<NodeViewOptions>>;
+    nodeName: string;
 };
 /**
  * 🧱 Internal: Editor FE Platform

package/dist/types-ts4.5/link/ConfigureLinkOverlay/Dropdown.d.ts

@@ -6,13 +6,13 @@ import { type MouseEvent } from 'react';
 import { type EditorView } from '@atlaskit/editor-prosemirror/view';
 export type OnDropdownChange = (isOpen: boolean) => void;
 export type DropdownProps = {
+    editorView: EditorView;
     /** Callback fired when the Configure dropdown item is clicked */
     onConfigureClick: () => void;
-    /** Callback fired when the Open Link dropdown item is clicked */
-    onOpenLinkClick?: (event: MouseEvent<HTMLAnchorElement>) => void;
     /** Callback fired when the dropdown is open or close */
     onDropdownChange?: OnDropdownChange;
-    editorView: EditorView;
+    /** Callback fired when the Open Link dropdown item is clicked */
+    onOpenLinkClick?: (event: MouseEvent<HTMLAnchorElement>) => void;
     testId: string;
 };
 declare const _default: import("react").ForwardRefExoticComponent<DropdownProps & import("@atlaskit/analytics-next/withAnalyticsContext").WithContextProps & import("react").RefAttributes<any>>;

package/dist/types-ts4.5/link/ConfigureLinkOverlay/handleNavigation.d.ts

@@ -5,8 +5,8 @@ import { type OnClickCallback } from '../../card';
  * Function that opens a new page and fires the relevant analytics events
  */
 export declare function handleNavigation({ url, event, onClickCallback, fireAnalyticsEvent, }: {
+    event: MouseEvent<HTMLAnchorElement>;
     fireAnalyticsEvent: ((payload: AnalyticsEventPayload) => void | undefined) | undefined;
     onClickCallback?: OnClickCallback;
     url: string;
-    event: MouseEvent<HTMLAnchorElement>;
 }): void;

package/dist/types-ts4.5/link/ConfigureLinkOverlay/index.d.ts

@@ -7,8 +7,6 @@ import { type EditorView } from '@atlaskit/editor-prosemirror/view';
 import { type OnDropdownChange } from './Dropdown';
 export interface OverlayButtonProps {
     editorView: EditorView;
-    testId?: string;
-    targetElementPos?: number;
     /**
      * Called when the dropdown is open/closed with isOpen state as true and false respectively.
      */
@@ -17,5 +15,7 @@ export interface OverlayButtonProps {
      * Called when the open link button in the dropdown is clicked.
      */
     onOpenLinkClick?: (event: MouseEvent<HTMLAnchorElement>) => void;
+    targetElementPos?: number;
+    testId?: string;
 }
 export declare const OverlayButton: import("react").ForwardRefExoticComponent<OverlayButtonProps & import("@atlaskit/analytics-next/withAnalyticsContext").WithContextProps & import("react").RefAttributes<any>>;

package/dist/types-ts4.5/link/LinkPicker/EditorLinkPicker/index.d.ts

@@ -7,17 +7,17 @@ import type { Command, EditorAppearance } from '../../../types';
  */
 type OptionalKeys<T extends Object, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 export interface EditorLinkPickerProps extends OptionalKeys<React.ComponentProps<typeof LazyLinkPicker>, 'onCancel'> {
-    view: EditorView;
+    editorAppearance?: EditorAppearance;
     /**
      * Used for analytics purposes to describe how the link picker was invoked
      * Should be roughly equivalent to the `inputMethod` analytics value
      */
     invokeMethod?: string;
-    editorAppearance?: EditorAppearance;
+    onClickAwayCallback?: Command;
     /** Callback to execute on unmount */
     onClose?: () => void;
     onEscapeCallback?: Command;
-    onClickAwayCallback?: Command;
+    view: EditorView;
 }
 export declare const EditorLinkPicker: ({ view, onCancel, invokeMethod, editorAppearance, onClose, onEscapeCallback, onClickAwayCallback, ...restProps }: EditorLinkPickerProps) => React.JSX.Element;
 export {};