@atlaskit/smart-card 40.13.0 → 40.13.1

package/dist/types/state/hooks-external/useSmartLinkActions.d.ts

@@ -7,42 +7,42 @@ export interface LinkAction {
      * @example `delete-action`
      */
     id: string;
+    /**
+     * Promise to invoke on triggering this action.
+     * @example Clicking on `Delete` leading to deletion of content.
+     */
+    invoke: () => Promise<any>;
     /**
      * Text to render for the action.
      * @description Use this in tooltips and UI.
      * @example `Delete`.
      */
     text: React.ReactNode;
-    /**
-     * Promise to invoke on triggering this action.
-     * @example Clicking on `Delete` leading to deletion of content.
-     */
-    invoke: () => Promise<any>;
 }
 export interface UseSmartLinkActionsOpts {
     /**
-     * Smart Link URL for which actions will be invoked.
-     * @example https://start.atlassian.com
+     * Configure the visiblity of actions
      */
-    url: string;
+    actionOptions?: CardActionOptions;
     /**
      * Appearance under which these actions will be invoked.
      * @example `block` for card views.
      */
     appearance: CardInnerAppearance;
+    /**
+     * Smart link origin that the action being invoked from.
+     */
+    origin?: AnalyticsOrigin;
     /**
      * Platform on which actions are being invoked.
      * @default 'web'
      */
     platform?: JsonLd.Primitives.Platforms;
     /**
-     * Smart link origin that the action being invoked from.
-     */
-    origin?: AnalyticsOrigin;
-    /**
-     * Configure the visiblity of actions
+     * Smart Link URL for which actions will be invoked.
+     * @example https://start.atlassian.com
      */
-    actionOptions?: CardActionOptions;
+    url: string;
 }
 export declare function useSmartLinkActions({ url, appearance, origin, actionOptions, }: UseSmartLinkActionsOpts): {
     id: string;

package/dist/types/state/modal/types.d.ts

@@ -1,15 +1,15 @@
 import { type ReactNode } from 'react';
 export type SmartLinkModalAPI = {
+    /**
+     * Remove modal component.
+     */
+    close: () => void;
     /**
      * Insert a modal component on the root of Card or standalone HoverCard.
      * This is to ensure that the modal would not be unmounted
      * when HoverCard is unmounted.
      */
     open: (node: JSX.Element) => void;
-    /**
-     * Remove modal component.
-     */
-    close: () => void;
 };
 export type SmartLinkModalProviderProps = {
     children?: ReactNode;

package/dist/types/types.d.ts

@@ -8,8 +8,8 @@ export { type CardProps, type CardAppearance, type CardPlatform } from './view/C
 export type InlinePreloaderStyle = 'on-left-with-skeleton' | 'on-right-without-skeleton';
 export type LozengeColor = 'default' | 'success' | 'removed' | 'inprogress' | 'new' | 'moved';
 export interface LozengeProps {
-    text: string;
     appearance?: LozengeColor;
-    style?: AtlaskitLozengeProps['style'];
     isBold?: boolean;
+    style?: AtlaskitLozengeProps['style'];
+    text: string;
 }

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

@@ -1,6 +1,6 @@
 import React from 'react';
 type LinkAnalyticsContextProps = {
-    url?: string;
+    children?: React.ReactNode;
     /**
      * The display mode of the link
      * @example 'url'
@@ -8,7 +8,7 @@ type LinkAnalyticsContextProps = {
     display?: string | undefined;
     id?: string | undefined;
     source?: string;
-    children?: React.ReactNode;
+    url?: string;
 };
 /**
  * Provides an analytics context to supply attributes to events based on a URL

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

@@ -2,18 +2,18 @@ import React from 'react';
 import { getResolvedAttributes } from '@atlaskit/link-analytics/resolved-attributes';
 import { context } from './analytics';
 type SmartLinkAnalyticsContextProps = {
-    url: string;
+    children?: React.ReactNode;
     display?: string;
     id?: string | undefined;
     source?: string;
-    children?: React.ReactNode;
+    url: string;
 };
 type SmartLinkAnalyticsContextType = {
-    source?: string;
     attributes?: typeof context & ReturnType<typeof getResolvedAttributes> & {
         display?: string;
         id?: string;
     };
+    source?: string;
 };
 /**
  * Provides an analytics context data to supply attributes to events based on a URL

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

@@ -3,10 +3,6 @@ export type DestinationSubproduct = 'core' | 'software' | 'servicedesk';
 export type ClickType = 'left' | 'middle' | 'right' | 'keyboard' | 'none';
 export type ClickOutcome = 'prevented' | 'clickThrough' | 'clickThroughNewTabOrWindow' | 'contextMenu' | 'alt' | 'contentEditable' | 'previewPanel' | 'unknown';
 export type UiLinkClickedEventProps = {
-    /**
-     * Whether the click occurred with the left, middle or right mouse button
-     */
-    clickType: ClickType;
     /**
      * The user outcome for clicking the link as far as can be reasonably be determined
      * This ignores any programmatic cancellation of the outcome (ie e.preventDefault()) and
@@ -14,11 +10,15 @@ export type UiLinkClickedEventProps = {
      */
     clickOutcome: ClickOutcome;
     /**
-     * The keys held by the user at the time of clicking the link (which influence `clickOutcome`)
+     * Whether the click occurred with the left, middle or right mouse button
      */
-    keysHeld: ('alt' | 'ctrl' | 'meta' | 'shift')[];
+    clickType: ClickType;
     /**
      * Whether the browser's default behaviour was prevented programmatically
      */
     defaultPrevented: boolean;
+    /**
+     * The keys held by the user at the time of clicking the link (which influence `clickOutcome`)
+     */
+    keysHeld: ('alt' | 'ctrl' | 'meta' | 'shift')[];
 };

package/dist/types/view/BlockCard/types.d.ts

@@ -3,21 +3,21 @@ import { type CardState } from '../../state/types';
 import { type CardActionOptions, type OnResolveCallback } from '../Card/types';
 import { type OnErrorCallback } from '../types';
 export type BlockCardProps = {
-    id: string;
-    url: string;
-    cardState: CardState;
+    actionOptions?: CardActionOptions;
     authFlow?: CardAuthFlowOpts['authFlow'];
+    cardState: CardState;
+    CompetitorPrompt?: React.ComponentType<{
+        linkType?: string;
+        sourceUrl: string;
+    }>;
     handleAuthorize: (() => void) | undefined;
     handleFrameClick: React.EventHandler<React.MouseEvent | React.KeyboardEvent>;
+    hideIconLoadingSkeleton?: boolean;
+    id: string;
     isSelected?: boolean;
-    onResolve?: OnResolveCallback;
     onError?: OnErrorCallback;
-    testId?: string;
-    actionOptions?: CardActionOptions;
+    onResolve?: OnResolveCallback;
     renderers?: CardProviderRenderers;
-    CompetitorPrompt?: React.ComponentType<{
-        sourceUrl: string;
-        linkType?: string;
-    }>;
-    hideIconLoadingSkeleton?: boolean;
+    testId?: string;
+    url: string;
 };

package/dist/types/view/BlockCard/views/utils/index.d.ts

@@ -5,9 +5,9 @@ import type { ElementItem } from '../../../FlexibleCard/components/blocks/types'
 import { type InternalFlexibleUiOptions } from '../../../FlexibleCard/types';
 export declare const getSimulatedBetterMetadata: (cardDetails?: JsonLd.Response) => SimulatedMetadata;
 type SimulatedMetadata = {
+    bottomMetadata?: ElementItem[];
     titleMetadata: ElementItem[];
     topMetadata: ElementItem[];
-    bottomMetadata?: ElementItem[];
 };
 export declare const FlexibleCardUiOptions: InternalFlexibleUiOptions;
 export declare const titleBlockOptions: Partial<TitleBlockProps>;

package/dist/types/view/Card/types.d.ts

@@ -9,9 +9,9 @@ export type { CardAppearance, CardPlatform };
 export type CardInnerAppearance = CardAppearance | 'embedPreview' | 'flexible' | 'hoverCardPreview';
 export type EmbedIframeUrlType = 'href' | 'interactiveHref';
 export type OnResolveCallback = (data: {
-    url?: string;
-    title?: string;
     aspectRatio?: number;
+    title?: string;
+    url?: string;
 }) => void;
 export declare enum CardAction {
     DownloadAction = "DownloadAction",
@@ -26,8 +26,8 @@ export declare enum CardAction {
 export type CardActionOptions = {
     hide: true;
 } | {
-    hide: false;
     exclude?: Array<CardAction>;
+    hide: false;
 };
 interface ActionProps {
     /**
@@ -39,26 +39,38 @@ interface ActionProps {
     actionOptions?: CardActionOptions;
 }
 interface HoverPreviewProps extends ActionProps {
-    /**
-     * Flag to display hover preview on hover.
-     */
-    showHoverPreview?: boolean;
     /**
      * Configuration for hover card.
      */
     hoverPreviewOptions?: HoverPreviewOptions;
+    /**
+     * Flag to display hover preview on hover.
+     */
+    showHoverPreview?: boolean;
 }
 export interface BaseCardProps {
     /**
      * Define smart card default appearance.
      */
     appearance: CardAppearance;
+    /**
+     * Competitor Prompt Component for Competitor link experiment
+     */
+    CompetitorPrompt?: React.ComponentType<{
+        linkType?: string;
+        sourceUrl: string;
+    }>;
     /**
      * The container which `react-lazily-render` listens to for scroll events.
      * This property can be used in a scenario where you want to specify your own scroll container
      * while the Card component is (lazy)loading.
      */
     container?: HTMLElement;
+    /**
+     * When Preview panel is supported, onClick is ignored and the panel opens by default.
+     * This prop allows smartlinks inside of editor to bypass that as they have other ways to open Preview panel.
+     */
+    disablePreviewPanel?: boolean;
     /**
      * A React component responsible for returning a fallback UI when smart link fails to render because of uncaught errors.
      */
@@ -104,18 +116,6 @@ export interface BaseCardProps {
      * The url link of the resource to be resolved and shown as Smart Link.
      */
     url?: string;
-    /**
-     * Competitor Prompt Component for Competitor link experiment
-     */
-    CompetitorPrompt?: React.ComponentType<{
-        sourceUrl: string;
-        linkType?: string;
-    }>;
-    /**
-     * When Preview panel is supported, onClick is ignored and the panel opens by default.
-     * This prop allows smartlinks inside of editor to bypass that as they have other ways to open Preview panel.
-     */
-    disablePreviewPanel?: boolean;
 }
 export interface InlineProps extends HoverPreviewProps {
     /**

package/dist/types/view/CardWithUrl/types.d.ts

@@ -5,35 +5,35 @@ import { type FlexibleUiOptions } from '../FlexibleCard/types';
 import { type HoverPreviewOptions } from '../HoverCard/types';
 import { type InlinePreloaderStyle, type OnErrorCallback } from '../types';
 export type CardWithUrlContentProps = {
-    id: string;
-    url: string;
+    actionOptions?: CardActionOptions;
     appearance: CardAppearance;
-    platform?: CardPlatform;
-    onClick?: EventHandler<MouseEvent | KeyboardEvent>;
-    isSelected?: boolean;
-    isHovered?: boolean;
-    frameStyle?: FrameStyle;
+    children?: React.ReactNode;
+    CompetitorPrompt?: React.ComponentType<{
+        linkType?: string;
+        sourceUrl: string;
+    }>;
     container?: HTMLElement;
-    testId?: string;
-    onResolve?: OnResolveCallback;
-    onError?: OnErrorCallback;
-    actionOptions?: CardActionOptions;
-    inheritDimensions?: boolean;
+    disablePreviewPanel?: boolean;
     embedIframeRef?: React.Ref<HTMLIFrameElement>;
     embedIframeUrlType?: EmbedIframeUrlType;
-    inlinePreloaderStyle?: InlinePreloaderStyle;
-    ui?: FlexibleUiOptions;
-    children?: React.ReactNode;
-    showHoverPreview?: boolean;
+    frameStyle?: FrameStyle;
+    hideIconLoadingSkeleton?: boolean;
     hoverPreviewOptions?: HoverPreviewOptions;
+    id: string;
+    inheritDimensions?: boolean;
+    inlinePreloaderStyle?: InlinePreloaderStyle;
+    isHovered?: boolean;
+    isSelected?: boolean;
+    onClick?: EventHandler<MouseEvent | KeyboardEvent>;
+    onError?: OnErrorCallback;
+    onResolve?: OnResolveCallback;
     placeholder?: string;
+    platform?: CardPlatform;
     removeTextHighlightingFromTitle?: boolean;
     resolvingPlaceholder?: string;
+    showHoverPreview?: boolean;
+    testId?: string;
     truncateInline?: boolean;
-    CompetitorPrompt?: React.ComponentType<{
-        sourceUrl: string;
-        linkType?: string;
-    }>;
-    hideIconLoadingSkeleton?: boolean;
-    disablePreviewPanel?: boolean;
+    ui?: FlexibleUiOptions;
+    url: string;
 };

package/dist/types/view/EmbedCard/components/ErrorFrame.d.ts

@@ -5,13 +5,13 @@
 import React from 'react';
 export interface FrameProps {
     children?: React.ReactNode;
+    className?: string;
     compact?: boolean;
-    isSelected?: boolean;
-    isHoverable?: boolean;
+    inheritDimensions?: boolean;
     isFluidHeight?: boolean;
+    isHoverable?: boolean;
+    isSelected?: boolean;
     testId?: string;
-    className?: string;
-    inheritDimensions?: boolean;
 }
 export declare const Frame: (props?: FrameProps) => JSX.Element;
 export declare const ExpandedFrame: ({ children, isSelected, isHoverable, testId, className, isFluidHeight, }: FrameProps) => JSX.Element;

package/dist/types/view/EmbedCard/components/ExpandedFrame.d.ts

@@ -1,22 +1,5 @@
 import { type FrameStyle } from '../types';
 export interface ExpandedFrameProps {
-    isPlaceholder?: boolean;
-    href?: string;
-    icon?: React.ReactNode;
-    text?: React.ReactNode;
-    minWidth?: number;
-    maxWidth?: number;
-    children?: React.ReactNode;
-    /** A flag that determines whether the card is selected in edit mode. */
-    isSelected?: boolean;
-    /** A prop that determines the style of a frame: whether to show it, hide it or only show it when a user hovers over embed */
-    frameStyle?: FrameStyle;
-    /** The optional click handler */
-    onClick?: (evt: React.MouseEvent) => void;
-    /** For testing purposes only */
-    testId?: string;
-    /** If dimensions of the card are to be inherited from the parent */
-    inheritDimensions?: boolean;
     /**
      * To enable scrolling in use cases where the content will not have it's own scrollbar.
      *
@@ -25,6 +8,25 @@ export interface ExpandedFrameProps {
      * Always enable this when when the card is not resolved so the connect account button is not hiddden.
      */
     allowScrollBar?: boolean;
+    children?: React.ReactNode;
+    /** Component to prompt for competitor link */
+    CompetitorPrompt?: React.ComponentType<{
+        linkType?: string;
+        sourceUrl: string;
+    }>;
+    /** A prop that determines the style of a frame: whether to show it, hide it or only show it when a user hovers over embed */
+    frameStyle?: FrameStyle;
+    href?: string;
+    icon?: React.ReactNode;
+    /** If dimensions of the card are to be inherited from the parent */
+    inheritDimensions?: boolean;
+    isPlaceholder?: boolean;
+    /** A flag that determines whether the card is selected in edit mode. */
+    isSelected?: boolean;
+    maxWidth?: number;
+    minWidth?: number;
+    /** The optional click handler */
+    onClick?: (evt: React.MouseEvent) => void;
     /**
      * Should the CSS `overflow` property be set to hidden or auto (clipping or
      * supporting a scroll bar), or left out altogether.
@@ -35,10 +37,8 @@ export interface ExpandedFrameProps {
      * @default true
      */
     setOverflow?: boolean;
-    /** Component to prompt for competitor link */
-    CompetitorPrompt?: React.ComponentType<{
-        sourceUrl: string;
-        linkType?: string;
-    }>;
+    /** For testing purposes only */
+    testId?: string;
+    text?: React.ReactNode;
 }
 export declare const ExpandedFrame: ({ isPlaceholder, children, onClick, icon, text, isSelected, frameStyle, href, minWidth, maxWidth, testId, inheritDimensions, allowScrollBar, setOverflow, CompetitorPrompt, }: ExpandedFrameProps) => JSX.Element;

package/dist/types/view/EmbedCard/components/Frame.d.ts

@@ -4,11 +4,11 @@
  */
 import React from 'react';
 export interface FrameProps {
-    url?: string;
     isTrusted?: boolean;
-    testId?: string;
     onIframeDwell?: (dwellTime: number, dwellPercentVisible: number) => void;
     onIframeFocus?: () => void;
+    testId?: string;
     title?: string;
+    url?: string;
 }
 export declare const Frame: React.ForwardRefExoticComponent<FrameProps & React.RefAttributes<HTMLIFrameElement>>;

package/dist/types/view/EmbedCard/components/IFrame.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
 interface IFrameProps {
-    className?: string;
     childRef?: React.Ref<HTMLIFrameElement>;
+    className?: string;
 }
 /**
  * Iframe element isolated for DI purposes

package/dist/types/view/EmbedCard/components/IframeDwellTracker.d.ts

@@ -1,8 +1,8 @@
 export interface IframeDwellTrackerProps {
+    iframePercentVisible: number;
     isIframeLoaded: boolean;
     isMouseOver: boolean;
     isWindowFocused: boolean;
-    iframePercentVisible: number;
     onIframeDwell?: (dwellTime: number, dwellPercentVisible: number) => void;
 }
 export declare const IframeDwellTracker: ({ isIframeLoaded, isMouseOver, isWindowFocused, iframePercentVisible, onIframeDwell, }: IframeDwellTrackerProps) => null;

package/dist/types/view/EmbedCard/components/ImageIcon.d.ts

@@ -5,10 +5,10 @@
 import React from 'react';
 export interface ImageIconProps {
     alt?: string;
+    appearance?: 'square' | 'round';
+    default?: React.ReactElement;
     size?: number;
     src?: string;
     title?: string;
-    default?: React.ReactElement;
-    appearance?: 'square' | 'round';
 }
 export declare const ImageIcon: ({ alt, src, size, title, default: defaultIcon, appearance, }: ImageIconProps) => JSX.Element | null;

package/dist/types/view/EmbedCard/components/styled.d.ts

@@ -2,29 +2,29 @@ import type { FrameStyle } from '../types';
 export declare const className = "media-card-frame";
 export declare const embedHeaderHeight = 32;
 export interface WrapperProps {
-    minWidth?: number;
-    maxWidth?: number;
-    isInteractive?: boolean;
-    isSelected?: boolean;
+    className?: string;
     frameStyle?: FrameStyle;
     inheritDimensions?: boolean;
-    className?: string;
+    isInteractive?: boolean;
+    isSelected?: boolean;
+    maxWidth?: number;
+    minWidth?: number;
 }
 export interface HeaderProps {
     frameStyle?: FrameStyle;
 }
 export interface ContentProps {
-    isInteractive: boolean;
     /**
      * Whether to show a scroll bar (use overflow: auto) or hide overflow (overflow:hidden).
      * Always set to true for unresolved embeds, otherwise the connect account button may be hidden and unreachable.
      */
     allowScrollBar: boolean;
+    frameStyle?: FrameStyle;
+    isInteractive: boolean;
     /**
      * Remove the overflow: ... CSS property altogether.
      */
     removeOverflow?: boolean;
-    frameStyle?: FrameStyle;
 }
 export interface ImageProps {
     size: number;

package/dist/types/view/EmbedCard/types.d.ts

@@ -5,29 +5,29 @@ import { type CardState } from '../../state/types';
 import type { CardActionOptions, CardPlatform, EmbedIframeUrlType, OnResolveCallback } from '../Card/types';
 import { type OnErrorCallback } from '../types';
 export type EmbedCardProps = {
-    url: string;
+    actionOptions?: CardActionOptions;
     cardState: CardState;
+    CompetitorPrompt?: React.ComponentType<{
+        linkType?: string;
+        sourceUrl: string;
+    }>;
+    frameStyle?: FrameStyle;
     handleAuthorize: (() => void) | undefined;
     handleErrorRetry: () => void;
     handleFrameClick: React.EventHandler<React.MouseEvent | React.KeyboardEvent>;
     handleInvoke: InvokeHandler;
     id?: string;
+    iframeUrlType?: EmbedIframeUrlType;
+    inheritDimensions?: boolean;
     isSelected?: boolean;
-    frameStyle?: FrameStyle;
-    platform?: CardPlatform;
-    onResolve?: OnResolveCallback;
     onError?: OnErrorCallback;
-    testId?: string;
-    inheritDimensions?: boolean;
-    actionOptions?: CardActionOptions;
     onIframeDwell?: (dwellTime: number, dwellPercentVisible: number) => void;
     onIframeFocus?: () => void;
-    iframeUrlType?: EmbedIframeUrlType;
+    onResolve?: OnResolveCallback;
+    platform?: CardPlatform;
     renderers?: CardProviderRenderers;
-    CompetitorPrompt?: React.ComponentType<{
-        sourceUrl: string;
-        linkType?: string;
-    }>;
+    testId?: string;
+    url: string;
 };
 export interface WithShowControlMethodProp {
     showControls?: () => void;
@@ -41,8 +41,8 @@ export type AccessTypes = 'REQUEST_ACCESS' | 'PENDING_REQUEST_EXISTS' | 'FORBIDD
 export interface AccessContext {
     accessType?: AccessTypes;
     cloudId?: string;
-    url?: string;
     smartLinksAccessMetadataExperimentCohort?: 'experiment' | 'control' | 'not-enrolled';
+    url?: string;
 }
 export type InlinePreloaderStyle = 'on-left-with-skeleton' | 'on-right-without-skeleton';
 export type FrameStyle = 'show' | 'hide' | 'showOnHover';

package/dist/types/view/EmbedCard/useEmbedResolvePostMessageListener.d.ts

@@ -1,6 +1,6 @@
 interface UseEmbedResolvePostMessageListenerProps {
-    url: string;
     embedIframeRef: React.ForwardedRef<HTMLIFrameElement>;
+    url: string;
 }
 export declare const useEmbedResolvePostMessageListener: ({ url, embedIframeRef, }: UseEmbedResolvePostMessageListenerProps) => void;
 export {};

package/dist/types/view/EmbedCard/views/ErroredView.d.ts

@@ -3,9 +3,9 @@
  * @jsx jsx
  */
 export interface ErroredViewProps {
-    onRetry?: (val: any) => void;
+    inheritDimensions?: boolean;
     isSelected?: boolean;
+    onRetry?: (val: any) => void;
     testId?: string;
-    inheritDimensions?: boolean;
 }
 export declare const EmbedCardErroredView: ({ onRetry, isSelected, testId, inheritDimensions, }: ErroredViewProps) => JSX.Element;

package/dist/types/view/EmbedCard/views/ResolvedView.d.ts

@@ -1,39 +1,39 @@
 import React from 'react';
 import { type ContextViewModel, type FrameStyle } from '../types';
 export interface EmbedCardResolvedViewProps {
-    /** The title of the link */
-    title?: string;
+    /** Component to prompt for competitor link */
+    CompetitorPrompt?: React.ComponentType<{
+        linkType?: string;
+        sourceUrl: string;
+    }>;
     /** The context view model */
     context?: ContextViewModel;
-    /** The link to display */
-    link: string;
-    /** A flag that determines whether the card is selected in edit mode. */
-    isSelected?: boolean;
     /** A prop that determines the style of a frame: whether to show it, hide it or only show it when a user hovers over embed */
     frameStyle?: FrameStyle;
-    /** The src to be used for the `iframe` */
-    preview?: {
-        src?: string;
-        aspectRatio?: number;
-    };
+    inheritDimensions?: boolean;
+    /** A flag that determines whether the card is selected in edit mode. */
+    isSelected?: boolean;
+    isSupportTheming?: boolean;
     /** A flag that determines whether link source can be trusted in iframe **/
     isTrusted?: boolean;
+    /** The link to display */
+    link: string;
     /** The optional click handler */
     onClick?: (evt: React.MouseEvent) => void;
-    /** For testing purposes only. */
-    testId?: string;
-    isSupportTheming?: boolean;
-    inheritDimensions?: boolean;
     /** Optional callback for when user dwells cursor over iframe - for analytics **/
     onIframeDwell?: (dwellTime: number, dwellPercentVisible: number) => void;
     /** Optional callback for when user navigates into an iframe - for analytics **/
     onIframeFocus?: () => void;
+    /** The src to be used for the `iframe` */
+    preview?: {
+        aspectRatio?: number;
+        src?: string;
+    };
+    /** For testing purposes only. */
+    testId?: string;
+    /** The title of the link */
+    title?: string;
     /** Type of the object */
     type?: string[];
-    /** Component to prompt for competitor link */
-    CompetitorPrompt?: React.ComponentType<{
-        sourceUrl: string;
-        linkType?: string;
-    }>;
 }
 export declare const EmbedCardResolvedView: React.ForwardRefExoticComponent<EmbedCardResolvedViewProps & React.RefAttributes<HTMLIFrameElement>>;

package/dist/types/view/EmbedCard/views/forbidden-view/types.d.ts

@@ -2,7 +2,7 @@ import type { RequestAccessContextProps } from '../../../types';
 import type { ContextViewModel } from '../../types';
 import type { UnresolvedViewCardProps } from '../unresolved-view/types';
 export type ForbiddenViewProps = UnresolvedViewCardProps & {
+    accessContext: RequestAccessContextProps;
     context?: ContextViewModel;
     onAuthorize?: () => void;
-    accessContext: RequestAccessContextProps;
 };