@atlaskit/editor-plugin-card 7.4.7 → 7.4.8

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

@@ -1,8 +1,8 @@
 import React from 'react';
 import { type EditorView } from '@atlaskit/editor-prosemirror/view';
 export type EditorAnalyticsContextProps = {
-    editorView?: EditorView;
     children: React.ReactNode;
+    editorView?: EditorView;
 };
 /**
  * Provides location attribute to child events

package/dist/types/ui/EditorLinkingPlatformAnalytics/common.d.ts

@@ -3,15 +3,15 @@ import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { EditorCardPluginEvents } from '../analytics/create-events-queue';
 import type { CardPluginEvent } from '../analytics/types';
 export type AnalyticsBindingsProps = {
-    editorView: EditorView;
     cardPluginEvents: EditorCardPluginEvents<CardPluginEvent>;
+    editorView: EditorView;
 };
 type EventMetadata = {
     action?: string;
     inputMethod?: string;
-    sourceEvent?: unknown;
     isRedo?: boolean;
     isUndo?: boolean;
+    sourceEvent?: unknown;
 };
 export declare const getMethod: (metadata: EventMetadata) => string | undefined;
 export declare const getUpdateType: (metadata: EventMetadata) => string | undefined;

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

@@ -7,12 +7,12 @@ import type { EditorState } from '@atlaskit/editor-prosemirror/state';
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import { type CardPlugin } from '../cardPluginType';
 export interface HyperlinkToolbarAppearanceProps {
-    intl: IntlShape;
-    editorState: EditorState;
-    url: string;
-    editorView?: EditorView;
     cardOptions?: CardOptions;
     editorAnalyticsApi: EditorAnalyticsAPI | undefined;
     editorPluginApi: ExtractInjectionAPI<CardPlugin> | undefined;
+    editorState: EditorState;
+    editorView?: EditorView;
+    intl: IntlShape;
+    url: string;
 }
 export declare function HyperlinkToolbarAppearance(props: HyperlinkToolbarAppearanceProps): React.JSX.Element | null;

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

@@ -1,7 +1,7 @@
 import type { Command, FloatingToolbarCustom, FloatingToolbarItem } from '@atlaskit/editor-common/types';
 import type { HyperlinkToolbarAppearanceProps } from './HyperlinkToolbarAppearance';
 export declare const getCustomHyperlinkAppearanceDropdown: ({ url, intl, editorAnalyticsApi, editorPluginApi, settingsConfig, cardOptions, allowDatasource, isDatasourceView, }: Omit<HyperlinkToolbarAppearanceProps, "editorState"> & {
-    settingsConfig: FloatingToolbarItem<Command>;
     allowDatasource?: boolean;
     isDatasourceView?: boolean;
+    settingsConfig: FloatingToolbarItem<Command>;
 }) => FloatingToolbarCustom<Command>;

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

@@ -5,14 +5,14 @@ import type { cardPlugin } from '../../index';
 export declare const DATASOURCE_TABLE_LAYOUTS: readonly ["full-width", "center", "wide"];
 export type DatasourceTableLayout = (typeof DATASOURCE_TABLE_LAYOUTS)[number];
 export type LayoutButtonProps = {
-    mountPoint?: HTMLElement;
     boundariesElement?: HTMLElement;
-    scrollableElement?: HTMLElement;
-    targetElement?: HTMLElement;
+    intl: IntlShape;
     layout?: DatasourceTableLayout;
+    mountPoint?: HTMLElement;
     onLayoutChange?: (layout: DatasourceTableLayout) => void;
+    scrollableElement?: HTMLElement;
+    targetElement?: HTMLElement;
     testId?: string;
-    intl: IntlShape;
 };
 export interface LayoutButtonWrapperProps extends Pick<LayoutButtonProps, 'mountPoint' | 'boundariesElement' | 'scrollableElement'> {
     api: ExtractInjectionAPI<typeof cardPlugin> | undefined;

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

@@ -6,16 +6,16 @@ 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 LinkToolbarAppearanceProps {
-    intl: IntlShape;
-    editorAnalyticsApi: EditorAnalyticsAPI | undefined;
+    allowBlockCards?: boolean;
+    allowEmbeds?: boolean;
     currentAppearance?: CardAppearance;
+    editorAnalyticsApi: EditorAnalyticsAPI | undefined;
     editorState: EditorState;
     editorView?: EditorView;
-    url?: string;
-    allowEmbeds?: boolean;
-    allowBlockCards?: boolean;
-    showUpgradeDiscoverability?: boolean;
+    intl: IntlShape;
     isDatasourceView?: boolean;
+    showUpgradeDiscoverability?: boolean;
+    url?: string;
 }
 export declare class LinkToolbarAppearance extends React.Component<LinkToolbarAppearanceProps, Object> {
     renderDropdown: (view?: EditorView, cardContext?: CardContext) => React.JSX.Element | null;

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

@@ -2,13 +2,13 @@ import React from 'react';
 import type { Command, FloatingToolbarDropdown, FloatingToolbarItem } from '@atlaskit/editor-common/types';
 import { type LinkToolbarAppearanceProps } from './LinkToolbarAppearance';
 type Props = LinkToolbarAppearanceProps & {
+    allowDatasource?: boolean;
     dispatchCommand: (command: Command) => void;
     settingsConfig: FloatingToolbarItem<Command>;
-    allowDatasource?: boolean;
 };
 export declare const LinkAppearanceMenu: ({ url, intl, currentAppearance, editorState, allowEmbeds, allowBlockCards, allowDatasource, editorAnalyticsApi, isDatasourceView, dispatchCommand, settingsConfig, }: Props) => React.JSX.Element | null;
 export declare const getLinkAppearanceDropdown: ({ url, intl, currentAppearance, editorState, allowEmbeds, allowBlockCards, allowDatasource, editorAnalyticsApi, showUpgradeDiscoverability, isDatasourceView, settingsConfig, }: LinkToolbarAppearanceProps & {
-    settingsConfig: FloatingToolbarItem<Command>;
     allowDatasource?: boolean;
+    settingsConfig: FloatingToolbarItem<Command>;
 }) => FloatingToolbarDropdown<Command>;
 export {};

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

@@ -3,9 +3,9 @@ import { type IntlShape } from 'react-intl-next';
 import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
 import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
 type OpenPreviewPanelToolbarButtonProps = {
-    node: PMNode;
-    intl: IntlShape;
     editorAnalyticsApi?: EditorAnalyticsAPI;
+    intl: IntlShape;
+    node: PMNode;
 };
 export declare const OpenPreviewPanelToolbarButton: ({ node, intl, }: OpenPreviewPanelToolbarButtonProps) => React.JSX.Element | null;
 export {};

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

@@ -5,6 +5,12 @@ export interface PulseProps {
      * The component around which the Pulse should be displayed
      */
     children: JSX.Element;
+    /**
+     * Indicates when the feature is considered discovered. If "start" is passed, local storage key will be invalidated
+     * as soon as the animation starts. If "iteration" is passed (the default one), it will be invalidated after the first iteration
+     */
+    discoveryMode?: PulseDiscoveryMode;
+    isInline?: boolean;
     /**
      * The key that is used in local storage to identify the descoverability of a feature where the Pulse is used
      */
@@ -13,13 +19,7 @@ export interface PulseProps {
      * The time in ms after which the key in local storage will be considered expired and the Pulse will be shown again
      */
     localStorageKeyExpirationInMs?: number;
-    /**
-     * Indicates when the feature is considered discovered. If "start" is passed, local storage key will be invalidated
-     * as soon as the animation starts. If "iteration" is passed (the default one), it will be invalidated after the first iteration
-     */
-    discoveryMode?: PulseDiscoveryMode;
     shouldShowPulse?: boolean;
     testId?: string;
-    isInline?: boolean;
 }
 export declare const DiscoveryPulse: ({ children, localStorageKey, localStorageKeyExpirationInMs, discoveryMode, shouldShowPulse, testId, isInline, }: PulseProps) => React.JSX.Element;

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

@@ -11,10 +11,10 @@ type State = {
     resizedPctWidth?: number;
 };
 export type Props = Omit<ResizerProps, 'height' | 'width'> & {
-    width?: number;
-    height?: number;
     aspectRatio: number;
+    height?: number;
     isResizeDisabled?: boolean;
+    width?: number;
 };
 export default class ResizableEmbedCard extends React.Component<Props, State> {
     static defaultProps: {

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

@@ -1,8 +1,8 @@
 import React from 'react';
 import type { EditorAnalyticsContextProps } from './EditorAnalyticsContext';
 type ToolbarViewedEventProps = {
-    url?: string;
     display: string | null;
+    url?: string;
 };
 /**
  * Provides analytics context and card context

package/dist/types/ui/analytics/create-events-queue.d.ts

@@ -1,9 +1,9 @@
 export type Subscriber<T> = (event: T) => void;
 export type EditorCardPluginEvents<T> = {
-    push: (...events: T[]) => void;
-    subscribe: (listener: Subscriber<T>) => () => void;
     flush: () => void;
     getSize: () => number;
+    push: (...events: T[]) => void;
+    subscribe: (listener: Subscriber<T>) => () => void;
 };
 /**
  * Simple mechanism to defer event related callbacks

package/dist/types/ui/analytics/events-from-tr.d.ts

@@ -7,8 +7,8 @@ export declare const findChanged: (tr: Transaction | ReadonlyTransaction, state:
     removed: Entity[];
     inserted: Entity[];
     updated: ({
-        removed: Entity;
         inserted: Entity;
+        removed: Entity;
     } | {
         inserted: Entity;
         previous: {

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

@@ -1,17 +1,17 @@
 import type { Node } from '@atlaskit/editor-prosemirror/model';
 export type Entity = {
-    pos: number;
     node: Node;
     nodeContext: string;
+    pos: number;
 };
 type Metadata<T = Object> = {
-    node: Node;
-    isUndo?: boolean;
-    isRedo?: boolean;
     action?: string;
     inputMethod?: string;
-    sourceEvent?: unknown;
+    isRedo?: boolean;
+    isUndo?: boolean;
+    node: Node;
     nodeContext?: string;
+    sourceEvent?: unknown;
 } & T;
 type UpdateMetadata = {
     previousDisplay?: string;
@@ -31,34 +31,34 @@ export declare enum EVENT_SUBJECT {
  * events can be derived from them / think of them in the same way
  */
 export type LinkCreatedEvent = {
+    data: Metadata;
     event: EVENT.CREATED;
     subject: EVENT_SUBJECT.LINK;
-    data: Metadata;
 };
 export type LinkUpdatedEvent = {
+    data: Metadata<UpdateMetadata>;
     event: EVENT.UPDATED;
     subject: EVENT_SUBJECT.LINK;
-    data: Metadata<UpdateMetadata>;
 };
 export type LinkDeletedEvent = {
+    data: Metadata;
     event: EVENT.DELETED;
     subject: EVENT_SUBJECT.LINK;
-    data: Metadata;
 };
 export type DatasourceCreatedEvent = {
+    data: Metadata;
     event: EVENT.CREATED;
     subject: EVENT_SUBJECT.DATASOURCE;
-    data: Metadata;
 };
 export type DatasourceUpdatedEvent = {
+    data: Metadata<UpdateMetadata>;
     event: EVENT.UPDATED;
     subject: EVENT_SUBJECT.DATASOURCE;
-    data: Metadata<UpdateMetadata>;
 };
 export type DatasourceDeletedEvent = {
+    data: Metadata;
     event: EVENT.DELETED;
     subject: EVENT_SUBJECT.DATASOURCE;
-    data: Metadata;
 };
 export type LinkEvent = LinkCreatedEvent | LinkUpdatedEvent | LinkDeletedEvent;
 export type DatasourceEvent = DatasourceCreatedEvent | DatasourceUpdatedEvent | DatasourceDeletedEvent;

package/dist/types/ui/analytics/utils.d.ts

@@ -10,7 +10,7 @@ export declare function getNodeSubject(node: Node): EVENT_SUBJECT | null;
 /**
  * Analytics appearance for link object
  */
-export declare function appearanceForLink(node: Node): "url" | import("@atlaskit/editor-common/provider-factory").CardAppearance;
+export declare function appearanceForLink(node: Node): import("@atlaskit/editor-common/provider-factory").CardAppearance | "url";
 export declare function getUrl(node: Node): string | undefined;
 export declare const getNodeContext: (doc: Node, pos: number) => string;
 export declare const findAtPositions: (tr: Transaction | ReadonlyTransaction, positions: number[]) => Entity[];

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,40 @@ 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;
     }>;
+    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/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[];