@atlaskit/editor-plugin-card 7.4.7 → 7.4.9

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

@@ -3,12 +3,12 @@ import type { DatasourceModalType } from '@atlaskit/editor-common/types';
 import type { APIError } from '@atlaskit/linking-common';
 import type { DatasourceProps } from '../nodeviews/datasource';
 export type DatasourceErrorBoundaryProps = React.PropsWithChildren<{
-    url?: string;
-    unsupportedComponent?: React.ComponentType<React.PropsWithChildren<unknown>>;
+    datasourceId?: string;
+    datasourceModalType?: DatasourceModalType;
     handleError?: () => void;
+    unsupportedComponent?: React.ComponentType<React.PropsWithChildren<unknown>>;
+    url?: string;
     view: DatasourceProps['view'];
-    datasourceModalType?: DatasourceModalType;
-    datasourceId?: string;
 }>;
 export declare class DatasourceErrorBoundary extends React.Component<DatasourceErrorBoundaryProps> {
     state: {

package/dist/types/ui/hooks/useLinkUpgradeDiscoverability.d.ts

@@ -2,12 +2,12 @@ import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
 import type { CardContext } from '@atlaskit/link-provider';
 import type { cardPlugin } from '../../cardPlugin';
 export type LinkUpgradeDiscoverabilityProps = {
-    url: string;
-    linkPosition: number;
     cardContext?: CardContext;
-    pluginInjectionApi?: ExtractInjectionAPI<typeof cardPlugin>;
-    isPulseEnabled?: boolean;
     isOverlayEnabled?: boolean;
+    isPulseEnabled?: boolean;
+    linkPosition: number;
+    pluginInjectionApi?: ExtractInjectionAPI<typeof cardPlugin>;
+    url: string;
 };
 declare const useLinkUpgradeDiscoverability: ({ url, linkPosition, cardContext, pluginInjectionApi, isPulseEnabled, isOverlayEnabled, }: LinkUpgradeDiscoverabilityProps) => {
     shouldShowToolbarPulse: boolean | undefined;

package/dist/types/ui/preview/PreviewInvoker.d.ts

@@ -1,12 +1,12 @@
 import type { ReactNode } from 'react';
 import React from 'react';
 type PreviewInvokerProps = {
-    url: string;
     appearance: 'inline' | 'block' | 'embed';
     children: (api: {
         canPreview: boolean;
         invokePreview?: () => void;
     }) => ReactNode;
+    url: string;
 };
 export declare const PreviewInvoker: ({ url, appearance, children }: PreviewInvokerProps) => React.JSX.Element;
 export {};

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

@@ -13,7 +13,7 @@ export declare const floatingToolbar: (cardOptions: CardOptions, lpLinkPicker: b
 export declare const getSettingsButton: (intl: IntlShape, editorAnalyticsApi: EditorAnalyticsAPI | undefined, userPreferencesLink?: string) => FloatingToolbarItem<Command>;
 export declare const shouldRenderToolbarPulse: (embedEnabled: boolean, appearance: string, status: string, isDiscoverabilityEnabled: boolean) => boolean;
 export declare const getStartingToolbarItems: (options: CardPluginOptions, api?: ExtractInjectionAPI<typeof cardPlugin> | undefined) => (intl: IntlShape, link: string, onEditLink: Command, metadata: {
-    url: string;
     title: string;
+    url: string;
 }, state?: EditorState) => FloatingToolbarItem<Command>[];
 export declare const getEndingToolbarItems: (options: CardPluginOptions, api?: ExtractInjectionAPI<typeof cardPlugin> | undefined) => (intl: IntlShape, link: string) => FloatingToolbarItem<Command>[];

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

@@ -2,10 +2,10 @@ import type { JiraIssueDatasourceParameters } from '@atlaskit/link-datasource';
 import type { CardContext } from '@atlaskit/link-provider';
 import type { DatasourceParameters } from '@atlaskit/linking-types';
 export interface useFetchDatasourceInfoProps {
-    isRegularCardNode: boolean;
-    url?: string;
     cardContext?: CardContext;
+    isRegularCardNode: boolean;
     nodeParameters?: DatasourceParameters | JiraIssueDatasourceParameters;
+    url?: string;
 }
 export declare const useFetchDatasourceInfo: ({ isRegularCardNode, url, cardContext, nodeParameters, }: useFetchDatasourceInfoProps) => {
     datasourceId: string | undefined;

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

@@ -15,10 +15,10 @@ import type { SelectionPlugin } from '@atlaskit/editor-plugin-selection';
 import type { WidthPlugin } from '@atlaskit/editor-plugin-width';
 import type { CardPluginOptions, CardPluginState } from './types';
 type DummyAnnotationPlugin = NextEditorPlugin<'annotation', {
-    sharedState: InlineCommentPluginState;
     actions: {
         setInlineCommentDraftState: (isDraft: boolean, inputMethod: INPUT_METHOD) => Command;
     };
+    sharedState: InlineCommentPluginState;
 }>;
 export type CardPluginDependencies = [
     OptionalPlugin<FeatureFlagsPlugin>,
@@ -35,9 +35,9 @@ export type CardPluginDependencies = [
     OptionalPlugin<BasePlugin>
 ];
 export type CardPlugin = NextEditorPlugin<'card', {
-    pluginConfiguration: CardPluginOptions | undefined;
+    actions: CardPluginActions;
     dependencies: CardPluginDependencies;
+    pluginConfiguration: CardPluginOptions | undefined;
     sharedState: CardPluginState | null;
-    actions: CardPluginActions;
 }>;
 export {};

package/dist/types-ts4.5/nodeviews/blockCard.d.ts

@@ -13,8 +13,8 @@ export declare class BlockCardComponent extends React.PureComponent<SmartCardPro
         id?: string;
     });
     onResolve: (data: {
-        url?: string;
         title?: string;
+        url?: string;
     }) => void;
     componentWillUnmount(): void;
     private removeCardDispatched;
@@ -37,16 +37,16 @@ export declare class BlockCard extends ReactNodeView<BlockCardNodeViewProps> {
     destroy(): void;
 }
 export interface BlockCardNodeViewProperties {
-    pmPluginFactoryParams: PMPluginFactoryParams;
     actionOptions: BlockCardNodeViewProps['actionOptions'];
-    pluginInjectionApi: BlockCardNodeViewProps['pluginInjectionApi'];
-    onClickCallback: BlockCardNodeViewProps['onClickCallback'];
     allowDatasource: boolean | undefined;
-    inlineCardViewProducer: ReturnType<typeof getInlineNodeViewProducer>;
-    isPageSSRed: BlockCardNodeViewProps['isPageSSRed'];
     CompetitorPrompt?: React.ComponentType<{
-        sourceUrl: string;
         linkType?: string;
+        sourceUrl: string;
     }>;
+    inlineCardViewProducer: ReturnType<typeof getInlineNodeViewProducer>;
+    isPageSSRed: BlockCardNodeViewProps['isPageSSRed'];
+    onClickCallback: BlockCardNodeViewProps['onClickCallback'];
+    pluginInjectionApi: BlockCardNodeViewProps['pluginInjectionApi'];
+    pmPluginFactoryParams: PMPluginFactoryParams;
 }
 export declare const blockCardNodeView: ({ pmPluginFactoryParams, actionOptions, pluginInjectionApi, onClickCallback, allowDatasource, inlineCardViewProducer, CompetitorPrompt, isPageSSRed, }: BlockCardNodeViewProperties) => (node: Node, view: EditorView, getPos: () => number | undefined, decorations: readonly Decoration[]) => import("prosemirror-view").NodeView | Datasource | BlockCard;

package/dist/types-ts4.5/nodeviews/datasource.d.ts

@@ -13,13 +13,13 @@ import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
 import type { Decoration, DecorationSource, EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { cardPlugin } from '../index';
 export interface DatasourceProps extends ReactComponentProps {
-    node: PMNode;
-    view: EditorView;
-    getPos: getPosHandler;
-    portalProviderAPI: PortalProviderAPI;
     eventDispatcher: EventDispatcher;
-    pluginInjectionApi: ExtractInjectionAPI<typeof cardPlugin> | undefined;
+    getPos: getPosHandler;
     isNodeNested?: boolean;
+    node: PMNode;
+    pluginInjectionApi: ExtractInjectionAPI<typeof cardPlugin> | undefined;
+    portalProviderAPI: PortalProviderAPI;
+    view: EditorView;
 }
 interface DatasourceComponentProps extends ReactComponentProps, Pick<DatasourceProps, 'node' | 'view' | 'getPos'> {
 }

package/dist/types-ts4.5/nodeviews/embedCard.d.ts

@@ -8,8 +8,8 @@ import type { cardPlugin } from '../index';
 import type { SmartCardProps } from './genericCard';
 export type EmbedCardState = {
     hasPreview: boolean;
-    liveHeight?: number;
     initialAspectRatio?: number;
+    liveHeight?: number;
 };
 export declare class EmbedCardComponent extends React.PureComponent<SmartCardProps & {
     id?: string;
@@ -22,9 +22,9 @@ export declare class EmbedCardComponent extends React.PureComponent<SmartCardPro
     state: EmbedCardState;
     private getPosSafely;
     onResolve: (data: {
-        url?: string;
-        title?: string;
         aspectRatio?: number;
+        title?: string;
+        url?: string;
     }) => void;
     updateSize: (pctWidth: number | null, layout: RichMediaLayout) => true | undefined;
     private getLineLength;
@@ -55,13 +55,13 @@ export declare class EmbedCard extends ReactNodeView<EmbedCardNodeViewProps> {
     destroy(): void;
 }
 export interface EmbedCardNodeViewProperties {
+    actionOptions: EmbedCardNodeViewProps['actionOptions'];
     allowResizing: EmbedCardNodeViewProps['allowResizing'];
+    CompetitorPrompt?: EmbedCardNodeViewProps['CompetitorPrompt'];
     fullWidthMode: EmbedCardNodeViewProps['fullWidthMode'];
-    pmPluginFactoryParams: PMPluginFactoryParams;
-    pluginInjectionApi: ExtractInjectionAPI<typeof cardPlugin> | undefined;
-    actionOptions: EmbedCardNodeViewProps['actionOptions'];
-    onClickCallback: EmbedCardNodeViewProps['onClickCallback'];
     isPageSSRed: EmbedCardNodeViewProps['isPageSSRed'];
-    CompetitorPrompt?: EmbedCardNodeViewProps['CompetitorPrompt'];
+    onClickCallback: EmbedCardNodeViewProps['onClickCallback'];
+    pluginInjectionApi: ExtractInjectionAPI<typeof cardPlugin> | undefined;
+    pmPluginFactoryParams: PMPluginFactoryParams;
 }
 export declare const embedCardNodeView: ({ allowResizing, fullWidthMode, pmPluginFactoryParams, pluginInjectionApi, actionOptions, onClickCallback, CompetitorPrompt, isPageSSRed, }: EmbedCardNodeViewProperties) => (node: PMNode, view: EditorView, getPos: () => number | undefined) => EmbedCard;

package/dist/types-ts4.5/nodeviews/genericCard.d.ts

@@ -16,40 +16,41 @@ export type EditorContext<T> = React.Context<T> & {
     value: T;
 };
 export interface CardNodeViewProps extends ReactComponentProps {
-    providerFactory?: ProviderFactory;
     eventDispatcher?: EventDispatcher;
+    providerFactory?: ProviderFactory;
 }
 export interface CardProps extends CardNodeViewProps {
+    __livePage?: boolean;
+    actionOptions?: BaseCardProps['actionOptions'];
+    allowResizing?: boolean;
     children?: React.ReactNode;
-    node: PMNode;
-    view: EditorView;
-    getPos: getPosHandler;
     dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
     eventDispatcher?: EventDispatcher;
-    allowResizing?: boolean;
     fullWidthMode?: boolean;
-    useAlternativePreloader?: boolean;
-    actionOptions?: BaseCardProps['actionOptions'];
-    pluginInjectionApi?: ExtractInjectionAPI<typeof cardPlugin>;
+    getPos: getPosHandler;
+    hoverPreviewOptions?: BaseCardProps['hoverPreviewOptions'];
+    node: PMNode;
     onClickCallback?: OnClickCallback;
+    pluginInjectionApi?: ExtractInjectionAPI<typeof cardPlugin>;
     showHoverPreview?: BaseCardProps['showHoverPreview'];
-    hoverPreviewOptions?: BaseCardProps['hoverPreviewOptions'];
-    __livePage?: boolean;
+    useAlternativePreloader?: boolean;
+    view: EditorView;
 }
 export interface SmartCardProps extends CardProps {
-    pluginInjectionApi?: ExtractInjectionAPI<typeof cardPlugin>;
-    cardContext?: EditorContext<CardContext | undefined>;
-    onClick?: EventHandler<MouseEvent | KeyboardEvent> | undefined;
-    onResolve?: (tr: Transaction, title?: string) => void;
-    isHovered?: boolean;
-    allowEmbeds?: boolean;
     allowBlockCards?: boolean;
-    enableInlineUpgradeFeatures?: boolean;
-    isPageSSRed?: boolean;
+    allowEmbeds?: boolean;
+    cardContext?: EditorContext<CardContext | undefined>;
     CompetitorPrompt?: React.ComponentType<{
-        sourceUrl: string;
         linkType?: string;
+        sourceUrl: string;
     }>;
+    disablePreviewPanel?: BaseCardProps['disablePreviewPanel'];
+    enableInlineUpgradeFeatures?: boolean;
+    isHovered?: boolean;
+    isPageSSRed?: boolean;
+    onClick?: EventHandler<MouseEvent | KeyboardEvent> | undefined;
+    onResolve?: (tr: Transaction, title?: string) => void;
+    pluginInjectionApi?: ExtractInjectionAPI<typeof cardPlugin>;
 }
 /**
  *

package/dist/types-ts4.5/nodeviews/inlineCard.d.ts

@@ -4,7 +4,7 @@ import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
 import type { Decoration, EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { SmartCardProps } from './genericCard';
 import { type InlineCardWithAwarenessProps } from './inlineCardWithAwareness';
-export declare const InlineCard: React.MemoExoticComponent<({ node, cardContext, actionOptions, useAlternativePreloader, view, getPos, onClick: propsOnClick, onResolve: onRes, isHovered, showHoverPreview, hoverPreviewOptions, isPageSSRed, pluginInjectionApi, }: SmartCardProps) => React.JSX.Element | null>;
+export declare const InlineCard: React.MemoExoticComponent<({ node, cardContext, actionOptions, useAlternativePreloader, view, getPos, onClick: propsOnClick, onResolve: onRes, isHovered, showHoverPreview, hoverPreviewOptions, isPageSSRed, pluginInjectionApi, disablePreviewPanel, }: SmartCardProps) => React.JSX.Element | null>;
 export type InlineCardNodeViewProps = Pick<SmartCardProps, 'useAlternativePreloader' | 'actionOptions' | 'allowEmbeds' | 'allowBlockCards' | 'enableInlineUpgradeFeatures' | 'pluginInjectionApi' | 'onClickCallback' | 'isPageSSRed' | 'CompetitorPrompt'>;
 /**
  *

package/dist/types-ts4.5/nodeviews/inlineCardWithAwareness.d.ts

@@ -1,8 +1,8 @@
 import React from 'react';
 import type { SmartCardProps } from './genericCard';
 export type InlineCardWithAwarenessProps = {
-    isPulseEnabled?: boolean;
     isOverlayEnabled?: boolean;
+    isPulseEnabled?: boolean;
     isSelected?: boolean;
 };
 export declare const InlineCardWithAwareness: React.MemoExoticComponent<({ node, cardContext, actionOptions, useAlternativePreloader, view, getPos, pluginInjectionApi, onClick, isPulseEnabled, isOverlayEnabled, isSelected, isPageSSRed, appearance, }: SmartCardProps & InlineCardWithAwarenessProps) => React.JSX.Element>;

package/dist/types-ts4.5/pm-plugins/actions.d.ts

@@ -16,8 +16,8 @@ export declare const setProvider: (cardProvider: CardProvider | null) => (tr: Tr
 export declare const setDatasourceTableRef: (datasourceTableRef?: HTMLElement) => (tr: Transaction) => Transaction;
 export declare const setCardLayout: (layout: DatasourceTableLayout) => (tr: Transaction) => Transaction;
 export declare const setCardLayoutAndDatasourceTableRef: ({ layout, datasourceTableRef, }: {
-    layout: DatasourceTableLayout;
     datasourceTableRef?: HTMLElement;
+    layout: DatasourceTableLayout;
 }) => (tr: Transaction) => Transaction;
 export declare const showLinkToolbar: (tr: Transaction) => Transaction;
 export declare const hideLinkToolbar: (tr: Transaction) => Transaction;

package/dist/types-ts4.5/pm-plugins/doc.d.ts

@@ -24,13 +24,13 @@ export type LinkNodes = {
 };
 export declare const getLinkNodeType: (appearance: CardAppearance, linkNodes: LinkNodes) => NodeType;
 type UpdateCardArgs = {
-    state: EditorState;
-    node: Node;
+    inputMethod?: string;
+    isDeletingConfig?: boolean;
     newAdf: DatasourceAdf | InlineCardAdf;
-    view: EditorView;
+    node: Node;
     sourceEvent?: UIAnalyticsEvent;
-    isDeletingConfig?: boolean;
-    inputMethod?: string;
+    state: EditorState;
+    view: EditorView;
 };
 export declare const updateCardViaDatasource: (args: UpdateCardArgs) => void;
 export declare const insertDatasource: (state: EditorState, adf: DatasourceAdf | InlineCardAdf, view: EditorView, sourceEvent?: UIAnalyticsEvent) => void;

package/dist/types-ts4.5/pm-plugins/util/state.d.ts

@@ -4,39 +4,39 @@ export declare const getPluginState: (editorState: EditorState) => CardPluginSta
 export declare const getPluginStateWithUpdatedPos: (pluginState: CardPluginState, tr: ReadonlyTransaction) => {
     requests: {
         pos: number;
-        url: string;
+        analyticsAction?: import("@atlaskit/editor-common/analytics").ACTION;
         appearance: import("@atlaskit/editor-common/provider-factory").CardAppearance;
         compareLinkText: boolean;
-        source: import("@atlaskit/editor-common/card").CardReplacementInputMethod;
         previousAppearance?: import("@atlaskit/editor-common/provider-factory").CardAppearance | "url";
-        analyticsAction?: import("@atlaskit/editor-common/analytics").ACTION;
         shouldReplaceLink?: boolean;
+        source: import("@atlaskit/editor-common/card").CardReplacementInputMethod;
         sourceEvent?: import("@atlaskit/analytics-next").UIAnalyticsEvent | null | undefined;
+        url: string;
     }[];
     cards: {
         pos: number;
+        id?: string;
         title?: string;
         url?: string;
-        id?: string;
     }[];
-    provider: import("@atlaskit/editor-common/provider-factory").CardProvider | null;
+    allowBlockCards?: boolean;
+    allowEmbeds?: boolean;
+    datasourceModalType?: import("@atlaskit/editor-common/types").DatasourceModalType;
     datasourceStash: {
         [x: string]: {
             views: import("@atlaskit/linking-common").DatasourceAdfView[];
         };
     };
-    showLinkingToolbar: boolean;
-    smartLinkEvents?: import("@atlaskit/smart-card").SmartLinkEvents;
-    editorAppearance?: import("@atlaskit/editor-common/types").EditorAppearance;
-    showDatasourceModal: boolean;
-    datasourceModalType?: import("@atlaskit/editor-common/types").DatasourceModalType;
     datasourceTableRef?: HTMLElement;
-    layout?: import("../../ui/LayoutButton/types").DatasourceTableLayout;
+    editorAppearance?: import("@atlaskit/editor-common/types").EditorAppearance;
     inlineCardAwarenessCandidatePosition?: number;
+    layout?: import("../../ui/LayoutButton/types").DatasourceTableLayout;
     overlayCandidatePosition?: number;
+    provider: import("@atlaskit/editor-common/provider-factory").CardProvider | null;
     removeOverlay?: () => void;
     selectedInlineLinkPosition?: number;
-    allowEmbeds?: boolean;
-    allowBlockCards?: boolean;
+    showDatasourceModal: boolean;
+    showLinkingToolbar: boolean;
+    smartLinkEvents?: import("@atlaskit/smart-card").SmartLinkEvents;
 };
 export declare const getNewRequests: (oldState: CardPluginState | undefined, currentState: CardPluginState) => Request[];

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

@@ -15,20 +15,19 @@ export type DatasourceNode = Omit<Node, 'attrs'> & {
     readonly attrs: DatasourceAdf['attrs'] & Partial<RichMediaAttributes>;
 };
 export type CardInfo = {
-    title?: string;
-    url?: string;
     id?: string;
     pos: number;
+    title?: string;
+    url?: string;
 };
 export type Request = {
     /**
-     * The position of the link in the doc this request for upgrade is for
-     */
-    pos: number;
-    /**
-     * The URL of the link being upgraded/resolved
+     * Analytics action to be used when disaptching
+     * analytics events once the link is successfully/unsuccessfully
+     * resolved. Preserves the users "intent" ie was this a link
+     * being inserted or updated?
      */
-    url: string;
+    analyticsAction?: ACTION;
     /**
      * The requested appearance to upgrade to
      */
@@ -40,11 +39,9 @@ export type Request = {
      */
     compareLinkText: boolean;
     /**
-     * Analytics input method which preserves "how" the change
-     * has occured. Used when analytics are dispatched after the link
-     * is successfully/unsuccessfully resolved.
+     * The position of the link in the doc this request for upgrade is for
      */
-    source: CardReplacementInputMethod;
+    pos: number;
     /**
      * The previous appearance of the link
      * This is necessary when tracking an update of a link
@@ -52,13 +49,6 @@ export type Request = {
      * replacing with a hyperlink and queueing it for upgrade
      */
     previousAppearance?: CardAppearance | 'url';
-    /**
-     * Analytics action to be used when disaptching
-     * analytics events once the link is successfully/unsuccessfully
-     * resolved. Preserves the users "intent" ie was this a link
-     * being inserted or updated?
-     */
-    analyticsAction?: ACTION;
     /**
      * Describes if the requested `appearance` MUST be returned by the card provider
      * when resolving the link, because the request is associated with the user intent
@@ -66,12 +56,22 @@ export type Request = {
      * should not be affected by "default appearances" or "user preferences"
      */
     shouldReplaceLink?: boolean;
+    /**
+     * Analytics input method which preserves "how" the change
+     * has occured. Used when analytics are dispatched after the link
+     * is successfully/unsuccessfully resolved.
+     */
+    source: CardReplacementInputMethod;
     /**
      * Source UI that triggered this step if relevant
      * Primarily for transfering link picker UI event from initial UI action
      * through to the end of the link queue/request saga
      */
     sourceEvent?: UIAnalyticsEvent | null | undefined;
+    /**
+     * The URL of the link being upgraded/resolved
+     */
+    url: string;
 };
 /**
  * Each key in the stash is URL.
@@ -81,57 +81,57 @@ type DatasourceStash = Record<string, {
     views: DatasourceAdfView[];
 }>;
 export type CardPluginState = {
-    requests: Request[];
-    provider: CardProvider | null;
+    allowBlockCards?: boolean;
+    allowEmbeds?: boolean;
     cards: CardInfo[];
-    datasourceStash: DatasourceStash;
-    showLinkingToolbar: boolean;
-    smartLinkEvents?: SmartLinkEvents;
-    editorAppearance?: EditorAppearance;
-    showDatasourceModal: boolean;
     datasourceModalType?: DatasourceModalType;
+    datasourceStash: DatasourceStash;
     datasourceTableRef?: HTMLElement;
-    layout?: DatasourceTableLayout;
+    editorAppearance?: EditorAppearance;
     inlineCardAwarenessCandidatePosition?: number;
+    layout?: DatasourceTableLayout;
     overlayCandidatePosition?: number;
+    provider: CardProvider | null;
     removeOverlay?: () => void;
+    requests: Request[];
     selectedInlineLinkPosition?: number;
-    allowEmbeds?: boolean;
-    allowBlockCards?: boolean;
+    showDatasourceModal: boolean;
+    showLinkingToolbar: boolean;
+    smartLinkEvents?: SmartLinkEvents;
 };
 export type CardPluginOptions = CardOptions & {
+    cardPluginEvents?: EditorCardPluginEvents<CardPluginEvent>;
+    CompetitorPrompt?: React.ComponentType<{
+        linkType?: string;
+        sourceUrl: string;
+    }>;
+    disableFloatingToolbar?: boolean;
     editorAppearance?: EditorAppearance;
     fullWidthMode?: boolean;
+    isPageSSRed?: boolean;
     linkPicker?: LinkPickerOptions;
-    cardPluginEvents?: EditorCardPluginEvents<CardPluginEvent>;
     lpLinkPicker?: boolean;
-    disableFloatingToolbar?: boolean;
     onClickCallback?: OnClickCallback;
-    isPageSSRed?: boolean;
-    CompetitorPrompt?: React.ComponentType<{
-        sourceUrl: string;
-        linkType?: string;
-    }>;
 };
 export type SetProvider = {
-    type: 'SET_PROVIDER';
     provider: CardProvider | null;
+    type: 'SET_PROVIDER';
 };
 export type Queue = {
-    type: 'QUEUE';
     requests: Request[];
+    type: 'QUEUE';
 };
 export type Resolve = {
     type: 'RESOLVE';
     url: string;
 };
 export type Register = {
-    type: 'REGISTER';
     info: CardInfo;
+    type: 'REGISTER';
 };
 export type RemoveCard = {
-    type: 'REMOVE_CARD';
     info: Partial<CardInfo>;
+    type: 'REMOVE_CARD';
 };
 export type ShowLinkToolbar = {
     type: 'SHOW_LINK_TOOLBAR';
@@ -140,43 +140,43 @@ export type HideLinkToolbar = {
     type: 'HIDE_LINK_TOOLBAR';
 };
 export type ShowDatasourceModal = {
-    type: 'SHOW_DATASOURCE_MODAL';
     modalType: DatasourceModalType;
+    type: 'SHOW_DATASOURCE_MODAL';
 };
 export type HideDatasourceModal = {
     type: 'HIDE_DATASOURCE_MODAL';
 };
 export type RegisterSmartCardEvents = {
-    type: 'REGISTER_EVENTS';
     smartLinkEvents: SmartLinkEvents;
+    type: 'REGISTER_EVENTS';
 };
 export type SetDatasourceTableRef = {
-    type: 'SET_DATASOURCE_TABLE_REF';
     datasourceTableRef?: HTMLElement;
+    type: 'SET_DATASOURCE_TABLE_REF';
 };
 export type SetCardLayout = {
-    type: 'SET_CARD_LAYOUT';
     layout: DatasourceTableLayout;
+    type: 'SET_CARD_LAYOUT';
 };
 export type SetCardLayoutAndDatasourceTableRef = {
-    type: 'SET_CARD_LAYOUT_AND_DATASOURCE_TABLE_REF';
-    layout: DatasourceTableLayout;
     datasourceTableRef?: HTMLElement;
+    layout: DatasourceTableLayout;
+    type: 'SET_CARD_LAYOUT_AND_DATASOURCE_TABLE_REF';
 };
 type ClearOverlayCandidate = {
     type: 'CLEAR_OVERLAY_CANDIDATE';
 };
 type RegisterRemoveOverlayOnInsertedLink = {
-    type: 'REGISTER_REMOVE_OVERLAY_ON_INSERTED_LINK';
     callback: () => void;
     info?: Register['info'];
+    type: 'REGISTER_REMOVE_OVERLAY_ON_INSERTED_LINK';
 };
 export type SetDatasourceStash = {
-    type: 'SET_DATASOURCE_STASH';
     datasourceStash: {
         url: string;
         views: DatasourceAdfView[];
     };
+    type: 'SET_DATASOURCE_STASH';
 };
 export type RemoveDatasourceStash = {
     type: 'REMOVE_DATASOURCE_STASH';

package/dist/types-ts4.5/ui/AwarenessWrapper/index.d.ts

@@ -1,15 +1,15 @@
 import { jsx } from '@emotion/react';
 import type { SmartCardProps } from '../../nodeviews/genericCard';
 type AwarenessWrapperProps = {
+    children: JSX.Element;
     isInserted?: boolean;
+    isOverlayEnabled?: boolean;
+    isPulseEnabled?: boolean;
     isResolvedViewRendered?: boolean;
-    children: JSX.Element;
+    isSelected?: boolean;
     markMostRecentlyInsertedLink: (isLinkMostRecentlyInserted: boolean) => void;
     setOverlayHoveredStyles: (isHovered: boolean) => void;
     url: string;
-    isOverlayEnabled?: boolean;
-    isPulseEnabled?: boolean;
-    isSelected?: boolean;
 } & Partial<SmartCardProps>;
 export declare const AwarenessWrapper: ({ cardContext, children, getPos, isInserted, isOverlayEnabled, isSelected, isResolvedViewRendered, isPulseEnabled, markMostRecentlyInsertedLink, pluginInjectionApi, setOverlayHoveredStyles, url, appearance, }: AwarenessWrapperProps) => jsx.JSX.Element;
 export {};

package/dist/types-ts4.5/ui/ConfigureOverlay/index.d.ts

@@ -1,11 +1,11 @@
 import { jsx } from '@emotion/react';
 import { type EditorView } from '@atlaskit/editor-prosemirror/view';
 declare const OverlayWrapper: ({ view, targetElementPos, children, isHoveredCallback: hoverCallback, onOpenLinkClick, }: {
-    view: EditorView;
-    targetElementPos: number | undefined;
     children: JSX.Element;
     /** Fired when the mouse enters or leaves the overlay button */
     isHoveredCallback: (isHovered: boolean) => void;
     onOpenLinkClick: (event: React.MouseEvent<HTMLAnchorElement, MouseEvent>) => void;
+    targetElementPos: number | undefined;
+    view: EditorView;
 }) => jsx.JSX.Element;
 export default OverlayWrapper;

package/dist/types-ts4.5/ui/DatasourceAppearanceButton.d.ts

@@ -5,13 +5,13 @@ import type { EditorState } from '@atlaskit/editor-prosemirror/state';
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import { type CardContext } from '@atlaskit/link-provider';
 export interface DatasourceAppearanceButtonProps {
-    intl: IntlShape;
+    cardContext?: CardContext;
     editorAnalyticsApi?: EditorAnalyticsAPI;
-    url: string;
-    editorView?: EditorView;
     editorState: EditorState;
-    cardContext?: CardContext;
-    selected?: boolean;
+    editorView?: EditorView;
     inputMethod: string;
+    intl: IntlShape;
+    selected?: boolean;
+    url: string;
 }
 export declare const DatasourceAppearanceButton: ({ intl, editorAnalyticsApi, url, editorView, editorState, selected, inputMethod, }: DatasourceAppearanceButtonProps) => jsx.JSX.Element;

package/dist/types-ts4.5/ui/DatasourceDropdownOption.d.ts

@@ -3,11 +3,11 @@ import type { IntlShape } from 'react-intl-next';
 import type { Command } from '@atlaskit/editor-common/types';
 interface Props {
     allowDatasource?: boolean;
+    dispatchCommand: (command: Command) => void;
+    inputMethod: string;
     intl: IntlShape;
-    url: string;
     selected: boolean;
-    inputMethod: string;
-    dispatchCommand: (command: Command) => void;
+    url: string;
 }
 export declare const datasourceDisplayInformation: {
     title: {

package/dist/types-ts4.5/ui/DatasourceModal/index.d.ts

@@ -4,9 +4,9 @@ import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { CardContext } from '@atlaskit/link-provider';
 import type { ModalTypeToComponentMap } from './ModalWithState';
 type DatasourceModalProps = {
-    view: EditorView;
-    editorAnalyticsApi?: EditorAnalyticsAPI;
     cardContext?: CardContext;
+    editorAnalyticsApi?: EditorAnalyticsAPI;
+    view: EditorView;
 } & ModalTypeToComponentMap;
 export declare const DatasourceModal: ({ view, cardContext, datasourceId: defaultDatasourceId, componentType: Component, }: DatasourceModalProps) => React.JSX.Element | null;
 export {};