@atlaskit/smart-card 26.1.0 → 26.1.2

package/dist/types-ts4.0/utils/analytics/__mocks__/analytics.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/types-ts4.0/utils/analytics/analytics.d.ts

@@ -0,0 +1,53 @@
+import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { AnalyticsPayload } from '../types';
+import { CardInnerAppearance } from '../../view/Card/types';
+import { CommonEventProps, ConnectFailedEventProps, ConnectSucceededEventProps, InvokeFailedEventProps, InvokeSucceededEventProps, ResolvedEventProps, ScreenAuthPopupEventProps, TrackAppAccountConnectedProps, UiActionClickedEventProps, UiAuthAlternateAccountEventProps, UiAuthEventProps, UiCardClickedEventProps, UiClosedAuthEventProps, UiHoverCardDismissedEventProps, UiHoverCardOpenLinkClickedEventProps, UiHoverCardViewedEventProps, UiIframeDwelledEventProps, UiIframeFocusedEventProps, UiRenderFailedEventProps, UiRenderSuccessEventProps, UnresolvedEventProps } from './types';
+import { SmartLinkActionType } from '@atlaskit/linking-types';
+export declare const ANALYTICS_CHANNEL = "media";
+export declare const context: {
+    componentName: string;
+    packageName: any;
+    packageVersion: any;
+};
+export declare class SmartLinkEvents {
+    insertSmartLink(url: string, type: CardInnerAppearance, createAnalyticsEvent?: CreateUIAnalyticsEvent): void;
+}
+export declare const fireSmartLinkEvent: (payload: AnalyticsPayload, createAnalyticsEvent?: CreateUIAnalyticsEvent | undefined) => void;
+export declare const resolvedEvent: (props: ResolvedEventProps) => AnalyticsPayload;
+export declare const unresolvedEvent: ({ id, definitionId, extensionKey, resourceType, destinationSubproduct, destinationProduct, error, status, location, }: UnresolvedEventProps) => AnalyticsPayload;
+export declare const invokeSucceededEvent: ({ id, actionType, display, extensionKey, definitionId, destinationProduct, destinationSubproduct, location, }: InvokeSucceededEventProps) => AnalyticsPayload;
+export declare const invokeFailedEvent: ({ id, actionType, display, reason, extensionKey, definitionId, destinationProduct, destinationSubproduct, location, }: InvokeFailedEventProps) => AnalyticsPayload;
+export declare const connectSucceededEvent: ({ definitionId, extensionKey, destinationProduct, destinationSubproduct, location, }: ConnectSucceededEventProps) => AnalyticsPayload;
+export declare const connectFailedEvent: ({ definitionId, extensionKey, destinationProduct, destinationSubproduct, location, reason, }: ConnectFailedEventProps) => AnalyticsPayload;
+export declare const trackAppAccountConnected: ({ definitionId, extensionKey, destinationProduct, destinationSubproduct, location, }: TrackAppAccountConnectedProps) => AnalyticsPayload;
+export declare const trackAppAccountAuthStarted: ({ extensionKey, location, }: TrackAppAccountConnectedProps) => AnalyticsPayload;
+export declare const trackLinkUpdated: ({ actionSubjectId, ...attributes }: CommonEventProps & {
+    [key: string]: any;
+}) => AnalyticsPayload;
+export declare const trackSmartLinkQuickActionStarted: ({ smartLinkActionType, ...attributes }: CommonEventProps & {
+    smartLinkActionType: SmartLinkActionType;
+}) => AnalyticsPayload;
+export declare const trackSmartLinkQuickActionSuccess: ({ smartLinkActionType, ...attributes }: CommonEventProps & {
+    smartLinkActionType: SmartLinkActionType;
+}) => AnalyticsPayload;
+export declare const trackSmartLinkQuickActionFailed: ({ smartLinkActionType, ...attributes }: CommonEventProps & {
+    smartLinkActionType: SmartLinkActionType;
+}) => AnalyticsPayload;
+export declare const uiAuthEvent: ({ definitionId, extensionKey, destinationProduct, destinationSubproduct, location, display, }: UiAuthEventProps) => AnalyticsPayload;
+export declare const uiAuthAlternateAccountEvent: ({ definitionId, extensionKey, destinationProduct, destinationSubproduct, location, display, }: UiAuthAlternateAccountEventProps) => AnalyticsPayload;
+export declare const uiCardClickedEvent: ({ id, display, status, definitionId, extensionKey, isModifierKeyPressed, location, destinationProduct, destinationSubproduct, actionSubjectId, }: UiCardClickedEventProps) => AnalyticsPayload;
+export declare const uiIframeDwelledEvent: ({ id, display, status, definitionId, extensionKey, location, destinationProduct, destinationSubproduct, dwellTime, dwellPercentVisible, }: UiIframeDwelledEventProps) => AnalyticsPayload;
+export declare const uiIframeFocusedEvent: ({ id, display, status, definitionId, extensionKey, location, destinationProduct, destinationSubproduct, }: UiIframeFocusedEventProps) => AnalyticsPayload;
+export declare const uiActionClickedEvent: ({ id, actionType, extensionKey, display, definitionId, destinationProduct, destinationSubproduct, location, }: UiActionClickedEventProps) => AnalyticsPayload;
+export declare const uiClosedAuthEvent: ({ display, extensionKey, definitionId, destinationProduct, destinationSubproduct, location, }: UiClosedAuthEventProps) => AnalyticsPayload;
+export declare const screenAuthPopupEvent: ({ extensionKey, definitionId, destinationProduct, destinationSubproduct, location, }: ScreenAuthPopupEventProps) => AnalyticsPayload;
+export declare const uiRenderSuccessEvent: ({ display, status, extensionKey, definitionId, destinationProduct, destinationSubproduct, location, }: UiRenderSuccessEventProps) => AnalyticsPayload;
+export declare const uiRenderFailedEvent: ({ display, error, errorInfo, extensionKey, definitionId, destinationProduct, destinationSubproduct, location, }: UiRenderFailedEventProps) => AnalyticsPayload;
+export declare const uiHoverCardViewedEvent: ({ id, previewDisplay, extensionKey, definitionId, destinationProduct, destinationSubproduct, location, previewInvokeMethod, status, }: UiHoverCardViewedEventProps) => AnalyticsPayload;
+export declare const uiHoverCardDismissedEvent: ({ id, previewDisplay, hoverTime, extensionKey, definitionId, destinationProduct, destinationSubproduct, location, previewInvokeMethod, status, }: UiHoverCardDismissedEventProps) => AnalyticsPayload;
+export declare const uiHoverCardOpenLinkClickedEvent: ({ id, previewDisplay, extensionKey, definitionId, destinationProduct, destinationSubproduct, location, previewInvokeMethod, }: UiHoverCardOpenLinkClickedEventProps) => AnalyticsPayload;
+export declare const uiLearnMoreLinkClickedEvent: () => AnalyticsPayload;
+export declare const chunkloadFailedEvent: ({ display, error, errorInfo, extensionKey, definitionId, destinationProduct, destinationSubproduct, location, }: UiRenderFailedEventProps) => AnalyticsPayload;
+export declare const uiSmartLinkStatusLozengeButtonClicked: () => AnalyticsPayload;
+export declare const uiSmartLinkStatusListItemButtonClicked: () => AnalyticsPayload;
+export declare const uiSmartLinkStatusOpenPreviewButtonClicked: () => AnalyticsPayload;

package/dist/types-ts4.0/utils/analytics/click.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="react" />
+import { AnalyticsEventPayload, UIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { GasPayload } from '@atlaskit/analytics-gas-types';
+import { ClickOutcome, ClickType, UiLinkClickedEventProps } from './types';
+import { AnalyticsPayload } from '../types';
+export declare const buttonMap: Map<number | undefined, "left" | "right" | "none" | "middle">;
+export declare const getKeys: (e: React.MouseEvent) => ("meta" | "alt" | "shift" | "ctrl")[];
+export declare function getLinkClickOutcome(e: React.MouseEvent, clickType: ClickType): ClickOutcome;
+export declare const createLinkClickedPayload: (event: React.MouseEvent) => AnalyticsPayload | undefined;
+declare type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+export declare const fireLinkClickedEvent: (createAnalyticsEvent: (payload: AnalyticsEventPayload) => UIAnalyticsEvent) => (event: React.MouseEvent, overrides?: {
+    [x: string]: any;
+    attributes?: {
+        clickType?: ClickType | undefined;
+        clickOutcome?: ClickOutcome | undefined;
+        keysHeld?: ("meta" | "alt" | "shift" | "ctrl" | undefined)[] | undefined;
+        defaultPrevented?: boolean | undefined;
+    } | undefined;
+} | undefined) => void;
+export {};

package/dist/types-ts4.0/utils/analytics/index.d.ts

@@ -0,0 +1,4 @@
+import { AnalyticsPayload } from '../types';
+import { InstrumentEventProps } from './types';
+export { ANALYTICS_CHANNEL, context, fireSmartLinkEvent, resolvedEvent, unresolvedEvent, invokeSucceededEvent, invokeFailedEvent, chunkloadFailedEvent, connectSucceededEvent, connectFailedEvent, trackAppAccountAuthStarted, trackAppAccountConnected, uiAuthEvent, uiAuthAlternateAccountEvent, uiCardClickedEvent, uiActionClickedEvent, uiClosedAuthEvent, screenAuthPopupEvent, uiRenderSuccessEvent, uiRenderFailedEvent, uiHoverCardViewedEvent, uiHoverCardDismissedEvent, uiHoverCardOpenLinkClickedEvent, uiLearnMoreLinkClickedEvent, uiIframeDwelledEvent, uiSmartLinkStatusLozengeButtonClicked, uiSmartLinkStatusListItemButtonClicked, uiSmartLinkStatusOpenPreviewButtonClicked, } from './analytics';
+export declare const instrumentEvent: ({ id, status, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, error, }: InstrumentEventProps) => AnalyticsPayload | undefined;

package/dist/types-ts4.0/utils/analytics/types.d.ts

@@ -0,0 +1,130 @@
+import { APIError, CardType } from '@atlaskit/linking-common';
+import { PreviewDisplay, PreviewInvokeMethod } from '../../view/HoverCard/types';
+import { ErrorInfo } from 'react';
+import { CardInnerAppearance } from '../../view/Card/types';
+import { InvokeType } from '../../model/invoke-opts';
+export declare type DestinationProduct = 'jira' | 'confluence' | 'bitbucket' | 'trello';
+export declare type DestinationSubproduct = 'core' | 'software' | 'servicedesk';
+export interface CommonEventProps {
+    id?: string;
+    definitionId?: string;
+    extensionKey?: string;
+    resourceType?: string;
+    destinatinoObjectType?: string;
+    destinationSubproduct?: DestinationSubproduct | string;
+    destinationProduct?: DestinationProduct | string;
+    location?: string;
+}
+export declare type ResolvedEventProps = CommonEventProps & {
+    id: string;
+};
+export declare type UnresolvedEventProps = CommonEventProps & {
+    id: string;
+    status: string;
+    error?: APIError;
+};
+export declare type InvokeSucceededEventProps = CommonEventProps & {
+    id: string;
+    actionType: string;
+    display: CardInnerAppearance;
+};
+export declare type InvokeFailedEventProps = CommonEventProps & {
+    id: string;
+    actionType: string;
+    display: CardInnerAppearance;
+    reason: string;
+};
+export declare type ConnectSucceededEventProps = CommonEventProps & {
+    id?: string;
+};
+export declare type ConnectFailedEventProps = CommonEventProps & {
+    id?: string;
+    reason?: string;
+};
+export declare type TrackAppAccountConnectedProps = CommonEventProps;
+export declare type UiAuthEventProps = CommonEventProps & {
+    display: CardInnerAppearance;
+};
+export declare type UiAuthAlternateAccountEventProps = CommonEventProps & {
+    display: CardInnerAppearance;
+};
+export declare type UiCardClickedEventProps = CommonEventProps & {
+    id: string;
+    display: CardInnerAppearance;
+    status: CardType;
+    isModifierKeyPressed?: boolean;
+    actionSubjectId?: string;
+};
+export declare type UiIframeDwelledEventProps = CommonEventProps & {
+    id: string;
+    display: CardInnerAppearance;
+    status: CardType;
+    dwellTime: number;
+    dwellPercentVisible: number;
+};
+export declare type UiIframeFocusedEventProps = CommonEventProps & {
+    id: string;
+    display: CardInnerAppearance;
+    status: CardType;
+};
+export declare type UiActionClickedEventProps = CommonEventProps & {
+    id: string;
+    display: CardInnerAppearance;
+    actionType: string;
+    invokeType?: InvokeType;
+};
+export declare type ScreenAuthPopupEventProps = CommonEventProps;
+export declare type UiClosedAuthEventProps = CommonEventProps & {
+    display: CardInnerAppearance;
+};
+export declare type UiRenderSuccessEventProps = CommonEventProps & {
+    display: CardInnerAppearance;
+    status: CardType;
+};
+export declare type UiRenderFailedEventProps = CommonEventProps & {
+    display: CardInnerAppearance;
+    error: Error;
+    errorInfo: ErrorInfo;
+};
+export declare type UiHoverCardViewedEventProps = CommonEventProps & {
+    previewDisplay: PreviewDisplay;
+    previewInvokeMethod?: PreviewInvokeMethod;
+    status: CardType;
+};
+export declare type UiHoverCardDismissedEventProps = CommonEventProps & {
+    previewDisplay: PreviewDisplay;
+    hoverTime: number;
+    previewInvokeMethod?: PreviewInvokeMethod;
+    status: CardType;
+};
+export declare type UiHoverCardOpenLinkClickedEventProps = CommonEventProps & {
+    previewDisplay: PreviewDisplay;
+    previewInvokeMethod?: PreviewInvokeMethod;
+};
+export declare type InstrumentEventProps = CommonEventProps & {
+    error?: APIError;
+    status: CardType;
+    id: string;
+};
+export declare type ClickType = 'left' | 'middle' | 'right' | 'keyboard' | 'none';
+export declare type ClickOutcome = 'prevented' | 'clickThrough' | 'clickThroughNewTabOrWindow' | 'contextMenu' | 'alt' | 'contentEditable' | 'unknown';
+export declare 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
+     * thus this represents the user intent, not necessarily the actual outcome
+     */
+    clickOutcome: ClickOutcome;
+    /**
+     * The keys held by the user at the time of clicking the link (which influence `clickOutcome`)
+     */
+    keysHeld: ('alt' | 'ctrl' | 'meta' | 'shift')[];
+    /**
+     * Whether the browser's default behaviour was prevented programmatically
+     */
+    defaultPrevented: boolean;
+};

package/dist/types-ts4.0/utils/flexible.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+export declare const isFlexibleUiCard: (children?: React.ReactNode) => boolean;
+export declare const isFlexibleUiBlock: (node: React.ReactNode) => boolean;
+export declare const isFlexibleUiElement: (node: React.ReactNode) => boolean;
+export declare const isFlexibleUiTitleBlock: (node: React.ReactNode) => boolean;
+export declare const isFlexibleUiPreviewBlock: (node: React.ReactNode) => boolean;
+export declare const isFlexibleUiFooterBlock: (node: React.ReactNode) => boolean;

package/dist/types-ts4.0/utils/index.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+import { CardProps } from '../view/Card';
+export declare const isCardWithData: (props: CardProps) => boolean;
+export declare const isSpecialEvent: (evt: React.MouseEvent | React.KeyboardEvent) => boolean;
+export declare const isIframe: () => boolean;
+/**
+ * Meta key = cmd on mac, windows key on windows
+ * Ctrl key on mac by default triggers a right click instead of left click
+ * Ctrl key on Windows has the same behaviour of cmd key of mac (open in new tab)
+ *
+ * `isSpecialKey` on a mouse event on mac with default behaviour should be equivalent to opening in new tab
+ * On Windows it will be equivalent to opening a new tab, unless its the Window key that is held
+ * in which case typically only a standard clickthrough will occur, this is likely a small portion of events
+ */
+export declare const isSpecialKey: (event: React.MouseEvent | React.KeyboardEvent) => boolean;
+export declare const isSpecialClick: (event: React.MouseEvent) => boolean;
+export declare const getIconForFileType: (fileMimeType: string) => React.ReactNode | undefined;
+export declare const getLabelForFileType: (fileMimeType: string) => React.ReactNode | undefined;
+export declare const getIframeSandboxAttribute: (isTrusted: boolean) => "allow-downloads allow-forms allow-popups allow-popups-to-escape-sandbox allow-presentation allow-same-origin allow-scripts" | undefined;
+export declare const handleOnClick: (handler: Function) => (e: React.BaseSyntheticEvent) => void;
+export declare const isIntersectionObserverSupported: () => boolean;
+export declare const sleep: (ms: number) => Promise<void>;
+export declare const importWithRetry: <T>(importFn: () => Promise<T>, retries?: number, interval?: number) => Promise<T>;

package/dist/types-ts4.0/utils/jsonld.d.ts

@@ -0,0 +1,4 @@
+import { JsonLd } from 'json-ld-types';
+export declare const getEmptyJsonLd: () => JsonLd.Data.BaseData;
+export declare const getUnauthorizedJsonLd: () => JsonLd.Response;
+export declare const getForbiddenJsonLd: () => JsonLd.Response;

package/dist/types-ts4.0/utils/mocks.d.ts

@@ -0,0 +1,97 @@
+import { JsonLd } from 'json-ld-types';
+export declare const mockContext: {
+    readonly '@vocab': "https://www.w3.org/ns/activitystreams#";
+    readonly atlassian: "https://schema.atlassian.com/ns/vocabulary#";
+    readonly schema: "http://schema.org/";
+};
+export declare const mockByUrl: (url: string) => JsonLd.Response<JsonLd.Data.BaseData>;
+export declare const mocks: {
+    success: JsonLd.Response<JsonLd.Data.BaseData>;
+    notFound: JsonLd.Response<JsonLd.Data.BaseData>;
+    forbidden: JsonLd.Response<JsonLd.Data.BaseData>;
+    forbiddenWithNoAuth: JsonLd.Response<JsonLd.Data.BaseData>;
+    unauthorized: JsonLd.Response<JsonLd.Data.BaseData>;
+    unauthorizedWithNoAuth: JsonLd.Response<JsonLd.Data.BaseData>;
+    actionSuccess: {
+        meta: {
+            visibility: string;
+            access: string;
+            auth: never[];
+            definitionId: string;
+        };
+        data: {
+            status: string;
+        };
+    };
+    analytics: {
+        status: string;
+        details: {
+            meta: {
+                definitionId: string;
+                key: string;
+                resourceType: string;
+                subproduct: string;
+                product: string;
+            };
+        };
+    };
+};
+export declare const fakeResponse: () => Promise<JsonLd.Response<JsonLd.Data.BaseData>>;
+export declare const fakeFactory: any;
+export declare const waitFor: (time?: number) => Promise<unknown>;
+export declare const mockAnalytics: {
+    ui: {
+        authEvent: ({ display, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("./analytics/types").UiAuthEventProps) => void;
+        authAlternateAccountEvent: ({ display, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("./analytics/types").UiAuthAlternateAccountEventProps) => void;
+        buttonClickedEvent: (data: Partial<import("./types").AnalyticsPayload> & {
+            actionSubjectId: string;
+        }) => void;
+        cardClickedEvent: ({ id, display, status, definitionId, extensionKey, isModifierKeyPressed, location, destinationProduct, destinationSubproduct, actionSubjectId, }: import("./analytics/types").UiCardClickedEventProps) => void;
+        iframeDwelledEvent: ({ id, display, status, definitionId, extensionKey, location, destinationProduct, destinationSubproduct, dwellTime, dwellPercentVisible, }: import("./analytics/types").UiIframeDwelledEventProps) => void;
+        iframeFocusedEvent: ({ id, display, status, definitionId, extensionKey, location, destinationProduct, destinationSubproduct, }: import("./analytics/types").UiIframeFocusedEventProps) => void;
+        actionClickedEvent: ({ id, actionType, display, invokeType, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("./analytics/types").UiActionClickedEventProps) => void;
+        hoverCardOpenLinkClickedEvent: ({ previewDisplay, definitionId, extensionKey, destinationProduct, destinationSubproduct, location, previewInvokeMethod, }: import("./analytics/types").UiHoverCardOpenLinkClickedEventProps) => void;
+        closedAuthEvent: ({ display, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("./analytics/types").UiClosedAuthEventProps) => void;
+        modalClosedEvent: (data: Partial<import("./types").AnalyticsPayload> & {
+            actionSubjectId: string;
+        }) => void;
+        renderSuccessEvent: ({ display, status, id, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("./analytics/types").UiRenderSuccessEventProps) => void;
+        renderFailedEvent: ({ display, id, error, errorInfo, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("./analytics/types").UiRenderFailedEventProps) => void;
+        hoverCardViewedEvent: ({ previewDisplay, previewInvokeMethod, id, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, status, }: import("./analytics/types").UiHoverCardViewedEventProps) => void;
+        hoverCardDismissedEvent: ({ id, previewDisplay, hoverTime, previewInvokeMethod, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, status, }: import("./analytics/types").UiHoverCardDismissedEventProps) => void;
+        learnMoreClickedEvent: () => void;
+        smartLinkLozengeActionClickedEvent: () => void;
+        smartLinkLozengeActionListItemClickedEvent: () => void;
+        smartLinkLozengeActionErrorOpenPreviewClickedEvent: () => void;
+    };
+    operational: {
+        invokeSucceededEvent: ({ id, actionType, display, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("./analytics/types").InvokeSucceededEventProps) => void;
+        invokeFailedEvent: ({ id, actionType, display, reason, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("./analytics/types").InvokeFailedEventProps) => void;
+        connectSucceededEvent: ({ id, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("./analytics/types").ConnectSucceededEventProps) => void;
+        connectFailedEvent: ({ id, reason, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("./analytics/types").ConnectFailedEventProps) => void;
+        instrument: ({ id, status, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, error, }: import("./analytics/types").InstrumentEventProps) => void;
+        chunkloadFailedEvent: ({ display, error, errorInfo, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("./analytics/types").UiRenderFailedEventProps) => void;
+    };
+    track: {
+        appAccountConnected: ({ extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("./analytics/types").CommonEventProps) => void;
+        appAccountAuthStarted: ({ extensionKey, location, }: import("./analytics/types").CommonEventProps) => void;
+        linkUpdated: (props: import("./analytics/types").CommonEventProps & {
+            [key: string]: any;
+        }) => void;
+        smartLinkQuickActionStarted: (props: {
+            smartLinkActionType: import("@atlaskit/linking-types").SmartLinkActionType;
+        }) => void;
+        smartLinkQuickActionSuccess: (props: {
+            smartLinkActionType: import("@atlaskit/linking-types").SmartLinkActionType;
+        }) => void;
+        smartLinkQuickActionFailed: (props: {
+            smartLinkActionType: import("@atlaskit/linking-types").SmartLinkActionType;
+        }) => void;
+    };
+    screen: {
+        authPopupEvent: ({ extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("./analytics/types").CommonEventProps) => void;
+        modalViewedEvent: (data: Partial<import("./types").AnalyticsPayload> & {
+            name: "embedPreviewModal";
+        }) => void;
+    };
+};

package/dist/types-ts4.0/utils/performance.d.ts

@@ -0,0 +1,8 @@
+import { CardType } from '@atlaskit/linking-common';
+export declare const getMarkName: (id: string, status: CardType) => string;
+export declare const getMeasureName: (id: string, status: CardType) => string;
+export declare const clearMarks: (id: string) => void;
+export declare const clearMeasures: (id: string) => void;
+export declare const getMeasure: (id: string, status: CardType) => PerformanceEntry | undefined;
+export declare const mark: (id: string, status: CardType) => void;
+export declare const create: (id: string, status: CardType) => void;

package/dist/types-ts4.0/utils/test-utils.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { ProviderProps } from '../state';
+export declare const renderHook: (callback: Function) => JSX.Element;
+export declare const renderSmartLinkHook: (callback: Function, providerProps?: Partial<ProviderProps> | undefined) => JSX.Element;

package/dist/types-ts4.0/utils/token.d.ts

@@ -0,0 +1,16 @@
+export declare const tokens: {
+    actionIcon: "var(--ds-icon)";
+    background: "var(--ds-surface-raised)";
+    badgeIcon: "var(--ds-icon-subtle)";
+    badgeText: "var(--ds-text-subtlest)";
+    blackLink: "var(--ds-text-subtle)";
+    blackLinkPressed: "var(--ds-text)";
+    blueLink: "var(--ds-link)";
+    blueLinkPressed: "var(--ds-link-pressed)";
+    elevation: "var(--ds-shadow-raised)";
+    errorMessage: "var(--ds-text-disabled)";
+    errorMessageHover: "var(--ds-text-subtle)";
+    focus: "var(--ds-border-focused)";
+    snippet: "var(--ds-text)";
+    text: "var(--ds-text-subtlest)";
+};

package/dist/types-ts4.0/utils/types.d.ts

@@ -0,0 +1,14 @@
+import { GasPayload } from '@atlaskit/analytics-gas-types';
+import { CardInnerAppearance } from '../view/Card/types';
+export declare type AnalyticsAction = 'authStarted' | 'clicked' | 'closed' | 'connected' | 'connectFailed' | 'connectSucceeded' | 'created' | 'dismissed' | 'inserted' | 'renderFailed' | 'renderSuccess' | 'renderWithStatus' | 'resolved' | 'viewed' | 'unresolved' | 'updated' | 'chunkLoadFailed' | 'dwelled' | 'focused' | 'started' | 'success' | 'failed';
+export declare type AnalyticsActionSubject = 'smartLink' | 'smartLinkAction' | 'applicationAccount' | 'button' | 'consentModal' | 'hoverCard' | 'modal' | 'embedPreviewModal' | 'smartLinkIframe' | 'link' | 'smartLinkQuickAction';
+export declare type AnalyticsName = 'embedPreviewModal';
+export declare type AnalyticsOrigin = 'smartLinkCard' | 'smartLinkEmbed' | 'smartLinkInline' | 'smartLinkPreviewHoverCard';
+export declare type AnalyticsPayload = GasPayload & {
+    action?: AnalyticsAction;
+    actionSubject: AnalyticsActionSubject;
+    attributes: GasPayload['attributes'] & {
+        display?: CardInnerAppearance;
+    };
+};
+export declare type AnalyticsHandler = (event: AnalyticsPayload) => void;

package/dist/types-ts4.0/view/BlockCard/actions/AuthorizeAction.d.ts

@@ -0,0 +1,2 @@
+import { ActionProps } from '../components/Action';
+export declare const AuthorizeAction: (handler: () => void) => ActionProps;

package/dist/types-ts4.0/view/BlockCard/actions/DownloadAction.d.ts

@@ -0,0 +1,8 @@
+import { ActionProps } from '../components/Action';
+export interface DownloadFunctionArg {
+    url?: string;
+}
+export declare function downloadFunction({ url }: DownloadFunctionArg): Promise<void>;
+export declare const DownloadAction: ({ url }: {
+    url?: string | undefined;
+}) => ActionProps;

package/dist/types-ts4.0/view/BlockCard/actions/ForbiddenAction.d.ts

@@ -0,0 +1,2 @@
+import { ActionProps } from '../components/Action';
+export declare const ForbiddenAction: (handler: () => void, id?: string, message?: import("react-intl-next").MessageDescriptor, context?: string) => ActionProps;

package/dist/types-ts4.0/view/BlockCard/actions/PreviewAction.d.ts

@@ -0,0 +1,31 @@
+import React, { ErrorInfo } from 'react';
+import { AnalyticsFacade } from '../../../state/analytics';
+import { EmbedModalProps } from '../../EmbedModal/types';
+import { ActionProps } from '../components/Action';
+import { IconProps } from '../../common/Icon';
+import { MetadataProps } from '../../common/Metadata';
+import { AnalyticsOrigin } from '../../../utils/types';
+export interface PreviewFunctionArg extends EmbedModalProps {
+    popupMountPointId: string;
+}
+export declare function previewFunction({ popupMountPointId, onClose, ...rest }: PreviewFunctionArg): Promise<void>;
+declare type PreviewInfo = {
+    src?: string;
+    testId?: string;
+    details?: Array<MetadataProps>;
+    icon?: IconProps;
+    url?: string;
+    title?: string;
+    providerName?: string;
+    download?: string;
+    byline?: React.ReactNode;
+    onViewActionClick?: () => void;
+    onDownloadActionClick?: () => void;
+    onOpen?: () => void;
+    onOpenFailed?: (error: Error, errorInfo: ErrorInfo) => void;
+    analytics: AnalyticsFacade;
+    origin?: AnalyticsOrigin;
+    isSupportTheming?: boolean;
+};
+declare const _default: ({ details, ...rest }: PreviewInfo) => ActionProps;
+export default _default;

package/dist/types-ts4.0/view/BlockCard/actions/RetryAction.d.ts

@@ -0,0 +1,2 @@
+import { ActionProps } from '../components/Action';
+export declare const RetryAction: (handler: () => void) => ActionProps;

package/dist/types-ts4.0/view/BlockCard/actions/ViewAction.d.ts

@@ -0,0 +1,8 @@
+import { ActionProps } from '../components/Action';
+export interface ViewFunctionArg {
+    url?: string;
+}
+export declare function viewFunction({ url }: ViewFunctionArg): Promise<void>;
+export declare const ViewAction: ({ url }: {
+    url?: string | undefined;
+}) => ActionProps;

package/dist/types-ts4.0/view/BlockCard/actions/flexible/AuthorizeAction.d.ts

@@ -0,0 +1,9 @@
+import { CustomActionItem } from '../../../FlexibleCard/components/blocks/types';
+/**
+ * Returns a CustomActionItem with a "Connect to <providerName>" message
+ *
+ * @see CustomActionItem
+ * @param onAuthorize a function that will be called on the click of the button
+ * @param providerName a string which is inserted into the message of the button
+ */
+export declare const AuthorizeAction: (onAuthorize: () => void, providerName?: string | undefined) => CustomActionItem;

package/dist/types-ts4.0/view/BlockCard/actions/flexible/ForbiddenAction.d.ts

@@ -0,0 +1,11 @@
+import { CustomActionItem } from '../../../FlexibleCard/components/blocks/types';
+import { MessageKey, RequestAccessMessageKey } from '../../../../messages';
+/**
+ * Returns a CustomActionItem with a "Try Another Account" default message
+ *
+ * @see CustomActionItem
+ * @param onClick a function that will be called on the click of the button
+ * @param content is a message key for a message to be displayed in the action
+ * @param context is a variable for a message in case a message contains a placeholder
+ */
+export declare const ForbiddenAction: (onClick: () => void, content: RequestAccessMessageKey | MessageKey, context?: string | undefined) => CustomActionItem;

package/dist/types-ts4.0/view/BlockCard/actions/flexible/RetryAction.d.ts

@@ -0,0 +1,8 @@
+import { CustomActionItem } from '../../../FlexibleCard/components/blocks/types';
+/**
+ * Returns a CustomActionItem with a "Retry" default message
+ *
+ * @see CustomActionItem
+ * @param onRetry a function that will be called on the click of the "Retry" button
+ */
+export declare const RetryAction: (onRetry: () => void) => CustomActionItem;

package/dist/types-ts4.0/view/BlockCard/components/Action.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+import { Appearance } from '@atlaskit/button/types';
+export interface ActionProps {
+    id: string;
+    text: React.ReactNode;
+    promise: <T>(opts?: T) => Promise<any>;
+    buttonAppearance?: Appearance;
+}
+export declare type ActionState = 'init' | 'loading' | 'success' | 'failure';
+export declare const spinnerDelay = 1000;
+export declare const Action: ({ promise, text, buttonAppearance, id, }: ActionProps) => jsx.JSX.Element;

package/dist/types-ts4.0/view/BlockCard/components/ActionIcon.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import type { ActionState } from './Action';
+export declare const spinnerStyles: {
+    readonly display: "flex";
+    readonly position: "absolute";
+    readonly left: "50%";
+    readonly top: "50%";
+    readonly transform: "translate(-50%, -50%)";
+};
+export declare const ActionIcon: ({ state }: {
+    state: ActionState;
+}) => JSX.Element | null;

package/dist/types-ts4.0/view/BlockCard/components/ActionList.d.ts

@@ -0,0 +1,7 @@
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+import { ActionProps } from './Action';
+export interface ActionListProps {
+    items: Array<ActionProps>;
+}
+export declare const ActionList: ({ items }: ActionListProps) => jsx.JSX.Element;

package/dist/types-ts4.0/view/BlockCard/components/CollaboratorList.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+import { AvatarClickEventHandler } from '@atlaskit/avatar';
+export interface Collaborator {
+    src?: string;
+    name: string;
+}
+export interface CollaboratorListProps {
+    items: Collaborator[];
+    handleAvatarClick: AvatarClickEventHandler;
+    handleMoreAvatarsClick: React.MouseEventHandler;
+    testId?: string;
+}
+export declare const CollaboratorList: ({ items, handleAvatarClick, handleMoreAvatarsClick, testId, }: CollaboratorListProps) => jsx.JSX.Element | null;

package/dist/types-ts4.0/view/BlockCard/components/Content.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+export interface ContentProps {
+    children: React.ReactNode;
+    isCompact?: boolean;
+}
+export declare const blockCardContentClassName = "block-card-content";
+export declare const Content: ({ children, isCompact }: ContentProps) => jsx.JSX.Element;

package/dist/types-ts4.0/view/BlockCard/components/ContentFooter.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+export interface ContentFooterProps {
+    children: React.ReactNode;
+    hasSpaceBetween?: boolean;
+}
+export declare const contentFooterClassName = "smart-link-content-footer";
+export declare const ContentFooter: ({ children, hasSpaceBetween, }: ContentFooterProps) => jsx.JSX.Element;

package/dist/types-ts4.0/view/BlockCard/components/ContentHeader.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+export interface ContentHeaderProps {
+    onClick: React.MouseEventHandler;
+    link: string;
+    children: React.ReactNode;
+}
+export declare const blockCardContentHeaderClassName = "block-card-content-header";
+export declare const ContentHeader: ({ onClick, link, children, }: ContentHeaderProps) => jsx.JSX.Element;

package/dist/types-ts4.0/view/BlockCard/components/Emoji.d.ts

@@ -0,0 +1,7 @@
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+import React from 'react';
+export interface EmojiProps {
+    emoji?: React.ReactNode;
+}
+export declare const Emoji: ({ emoji }: EmojiProps) => jsx.JSX.Element;

package/dist/types-ts4.0/view/BlockCard/components/Frame.d.ts

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

package/dist/types-ts4.0/view/BlockCard/components/Link.d.ts

@@ -0,0 +1,8 @@
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+export interface LinkProps {
+    url: string;
+    testId?: string;
+    className?: string;
+}
+export declare const Link: ({ url, testId, className }: LinkProps) => jsx.JSX.Element;