@atlaskit/media-card 74.1.6 → 74.1.8

package/dist/types-ts4.0/card/cardImageView/cardOverlay/styles.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="react" />
+/**
+ * Everything about this file change is just wrong.
+ * Mostly because we do bad things with classes.
+ * This is all wrong and hopefully will be removed from existence with card v3,
+ * so please don’t be too sad about all this!
+ */
+import { GlobalThemeTokens } from '@atlaskit/theme/components';
+export interface OverlayProps {
+    hasError?: boolean;
+    noHover?: boolean;
+    className?: string;
+    children?: JSX.Element[];
+}
+export declare const tickBoxStyles: import("@emotion/react").SerializedStyles;
+export declare const overlayStyles: (props: OverlayProps) => import("@emotion/react").SerializedStyles;
+export declare const errorLineStyles: import("@emotion/react").SerializedStyles;
+export declare const leftColumnStyles: import("@emotion/react").SerializedStyles;
+export declare const topRowStyles: import("@emotion/react").SerializedStyles;
+export declare const bottomRowStyles: import("@emotion/react").SerializedStyles;
+export declare const rightColumnStyles: import("@emotion/react").SerializedStyles;
+export declare const errorMessageStyles: import("@emotion/react").SerializedStyles;
+export declare const altWrapperStyles: import("@emotion/react").SerializedStyles;
+export declare const titleWrapperStyles: (theme: GlobalThemeTokens) => import("@emotion/react").SerializedStyles;
+export declare const subtitleStyles: import("@emotion/react").SerializedStyles;
+export declare const metadataStyles: import("@emotion/react").SerializedStyles;

package/dist/{types/root → types-ts4.0/card/cardImageView}/cardViewWrapper.d.ts

@@ -1,4 +1,4 @@
 /**@jsx jsx */
 import { jsx } from '@emotion/react';
-import { WrapperProps } from './types';
+import { WrapperProps } from '../types';
 export declare const Wrapper: (props: WrapperProps) => jsx.JSX.Element;

package/dist/{types/files/cardImageView/index.d.ts → types-ts4.0/card/cardImageView/fileCardImageView.d.ts}

@@ -2,9 +2,8 @@
 import { jsx } from '@emotion/react';
 import { Component, ReactNode } from 'react';
 import { MediaItemType, MediaType, ImageResizeMode } from '@atlaskit/media-client';
-import { CardDimensions, CardStatus } from '../../index';
-import { CardAction } from '../../actions';
-import { CardPreview } from '../..';
+import { CardStatus, CardPreview, CardDimensions } from '../../types';
+import { CardAction } from '../actions';
 export interface FileCardImageViewProps {
     readonly mediaName?: string;
     readonly mediaType?: MediaType;

package/dist/types-ts4.0/card/cardImageView/index.d.ts

@@ -0,0 +1,2 @@
+export { FileCardImageView } from './fileCardImageView';
+export type { FileCardImageViewProps } from './fileCardImageView';

package/dist/{types/files → types-ts4.0/card}/cardImageView/styles.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="react" />
 import { GlobalThemeTokens } from '@atlaskit/theme/components';
-import { CardStatus } from '../../index';
+import { CardStatus } from '../../types';
 export interface WrapperProps {
     disableOverlay?: boolean;
     selectable?: boolean;

package/dist/{types/root → types-ts4.0}/card/cardLoader.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 import type { WithMediaClientConfigProps } from '@atlaskit/media-client';
-import type { CardBaseProps } from '.';
+import type { CardBaseProps } from './card';
 export declare type CardWithMediaClientConfigProps = WithMediaClientConfigProps<CardBaseProps>;
 declare const CardLoader: React.FC<CardWithMediaClientConfigProps>;
 export default CardLoader;

package/dist/{types/root → types-ts4.0}/card/cardState.d.ts

@@ -1,5 +1,5 @@
 import { FileState } from '@atlaskit/media-client';
 import { MediaFeatureFlags } from '@atlaskit/media-common';
-import { CardState } from '../..';
+import { CardState } from '../types';
 export declare const createStateUpdater: (newState: Partial<CardState>) => (prevState: CardState) => Pick<CardState, keyof CardState>;
 export declare const getCardStateFromFileState: (fileState: FileState, isBannedLocalPreview: boolean, featureFlags?: MediaFeatureFlags | undefined) => Partial<CardState>;

package/dist/{types/root → types-ts4.0/card}/cardView.d.ts

@@ -4,9 +4,9 @@ import React, { MouseEvent } from 'react';
 import { MessageDescriptor } from 'react-intl-next';
 import { MediaItemType, FileDetails } from '@atlaskit/media-client';
 import { WithAnalyticsEventsProps, UIAnalyticsEvent } from '@atlaskit/analytics-next';
-import { SharedCardProps, CardStatus } from '../index';
+import { SharedCardProps, CardStatus } from '../types';
 import { MediaCardError } from '../errors';
-import { CardPreview } from '..';
+import { CardPreview } from '../types';
 import { MediaCardCursor } from '../types';
 export interface CardViewOwnProps extends SharedCardProps {
     readonly status: CardStatus;

package/dist/{types/root → types-ts4.0}/card/getCardPreview/cache.d.ts

@@ -1,6 +1,6 @@
 import { ImageResizeMode } from '@atlaskit/media-client';
-import { ObjectURLCache } from '../../../utils/objectURLCache';
-import { CardPreview } from '../../../types';
+import { ObjectURLCache } from '../../utils/objectURLCache';
+import { CardPreview } from '../../types';
 declare type Mode = ImageResizeMode | undefined;
 export declare const getCacheKey: (id: string, mode: Mode) => string;
 export interface CardPreviewCache {

package/dist/{types/root → types-ts4.0}/card/getCardPreview/filePreviewStatus.d.ts

@@ -1,5 +1,5 @@
 import { MediaFeatureFlags } from '@atlaskit/media-common';
-import { CardStatus, FilePreviewStatus } from '../../../types';
+import { CardStatus, FilePreviewStatus } from '../../types';
 import { FileState } from '@atlaskit/media-client';
 export declare const extractFilePreviewStatus: (fileState: FileState, isBannedLocalPreview: boolean, featureFlags?: MediaFeatureFlags | undefined) => FilePreviewStatus;
 export declare const isPreviewableStatus: (cardStatus: CardStatus, { isPreviewable, hasPreview, isSupportedByBrowser }: FilePreviewStatus) => boolean;

package/dist/{types/root → types-ts4.0}/card/getCardPreview/helpers.d.ts

@@ -1,5 +1,5 @@
 import { MediaClient, FilePreview, MediaStoreGetFileImageParams, MediaType } from '@atlaskit/media-client';
-import { CardPreview } from '../../../types';
+import { CardPreview } from '../../types';
 /**
  * This method tells the support for the media
  * types covered in getCardPreviewFromFilePreview

package/dist/{types/root/card → types-ts4.0/card/getCardPreview}/imageRefetchingAnalytics.d.ts

@@ -1,5 +1,5 @@
 import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
-import { CardDimensions } from '../../utils';
+import { CardDimensions } from '../../types';
 import { CardPreviewAttributes } from '../../utils/analytics';
 declare type cardAction = 'cache-hit' | 'remote-success';
 export declare const fireImageFetchingOperationalEvent: (createAnalyticsEvent: CreateUIAnalyticsEvent, action: cardAction, cardPreviewAttributes: CardPreviewAttributes) => void;

package/dist/{types/root → types-ts4.0}/card/getCardPreview/index.d.ts

@@ -2,9 +2,9 @@ import { MediaClient, FilePreview, FileState, MediaStoreGetFileImageParams, Medi
 import { MediaFeatureFlags, SSR } from '@atlaskit/media-common';
 import { ImageResizeMode } from '@atlaskit/media-client';
 import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
-import { CardDimensions } from '../../../utils/cardDimensions';
-import { MediaCardError } from '../../../errors';
-import { CardStatus, CardPreview } from '../../../types';
+import { CardDimensions } from '../../types';
+import { MediaCardError } from '../../errors';
+import { CardStatus, CardPreview } from '../../types';
 export { getCardPreviewFromFilePreview, getCardPreviewFromBackend, isSupportedLocalPreview, } from './helpers';
 export { extractFilePreviewStatus } from './filePreviewStatus';
 export declare const getCardPreviewFromCache: (id: string, mode: ImageResizeMode | undefined) => CardPreview | undefined;

package/dist/{types/root → types-ts4.0}/card/getCardStatus.d.ts

@@ -1,4 +1,4 @@
 import { FileStatus } from '@atlaskit/media-client';
-import { CardStatus, FilePreviewStatus } from '../../types';
+import { CardStatus, FilePreviewStatus } from '../types';
 export declare const isFinalCardStatus: (status: CardStatus) => boolean;
 export declare const getCardStatus: (fileStatus: FileStatus, { hasFilesize, isPreviewable, hasPreview }: FilePreviewStatus) => CardStatus;

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

@@ -0,0 +1 @@
+export { default as Card } from './cardLoader';

package/dist/{types/root → types-ts4.0/card}/inlinePlayer.d.ts

@@ -1,9 +1,10 @@
 import React from 'react';
 import { Component } from 'react';
 import { MediaClient, FileIdentifier, FileState, MediaFileArtifacts, MediaSubscription } from '@atlaskit/media-client';
-import { CardDimensions, NumericalCardDimensions } from '..';
+import { NumericalCardDimensions } from '@atlaskit/media-common';
+import { CardDimensions } from '../types';
 import { WithAnalyticsEventsProps, UIAnalyticsEvent } from '@atlaskit/analytics-next';
-import type { CardPreview } from '..';
+import type { CardPreview } from '../types';
 export interface InlinePlayerOwnProps {
     identifier: FileIdentifier;
     mediaClient: MediaClient;

package/dist/types-ts4.0/card/styles/animations.d.ts

@@ -0,0 +1 @@
+export declare const spin: import("@emotion/serialize").Keyframes;

package/dist/{types → types-ts4.0/card}/styles/mixins.d.ts

@@ -1,4 +1,4 @@
-import { CardAppearance } from '../index';
+import { CardAppearance } from '../../types';
 export declare const centerX = "\n  display: flex;\n  justify-content: center;\n";
 export declare const antialiased = "\n  -webkit-font-smoothing: antialiased;\n  -moz-osx-font-smoothing: grayscale;\n";
 export declare const centerSelfY = "\n  position: absolute;\n  top: 50%;\n  transform: translateY(-50%);\n";
@@ -14,8 +14,8 @@ export interface WithAppearanceProps {
     appearance?: CardAppearance;
 }
 export declare const withAppearance: (styleMap: {
-    image?: string | undefined;
     auto?: string | undefined;
-    horizontal?: string | undefined;
+    image?: string | undefined;
     square?: string | undefined;
+    horizontal?: string | undefined;
 }) => ({ appearance }: WithAppearanceProps) => string;

package/dist/{types/root → types-ts4.0/card/styles}/styles.d.ts

@@ -1,4 +1,4 @@
-import { InlinePlayerWrapperProps, WrapperProps } from './types';
+import { InlinePlayerWrapperProps, WrapperProps } from '../types';
 export declare const inlinePlayerClassName = "media-card-inline-player";
 export declare const wrapperStyles: {
     ({ dimensions, breakpointSize, shouldUsePointerCursor, }: WrapperProps): import("@emotion/react").SerializedStyles;

package/dist/{types/root → types-ts4.0/card}/types.d.ts

@@ -1,6 +1,6 @@
 import React, { MouseEvent, ReactElement, RefObject } from 'react';
 import { UIAnalyticsEvent } from '@atlaskit/analytics-next';
-import { CardDimensions } from '../';
+import { CardDimensions } from '../types';
 import { BreakpointSizeValue } from '../utils/breakpoint';
 export interface WrapperProps {
     testId?: string;

package/dist/{types/root → types-ts4.0/card}/ui/actionsBar/types.d.ts

@@ -1,5 +1,5 @@
 import { ReactNode } from 'react';
-import { CardAction } from '../../../actions';
+import { CardAction } from '../../actions';
 export interface ActionsBarProps {
     actions: Array<CardAction>;
     isFixed?: boolean;

package/dist/{types/root → types-ts4.0/card}/ui/imageRenderer/imageRenderer.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 import { MediaType, ImageResizeMode } from '@atlaskit/media-client';
-import { CardPreview } from '../../..';
+import { CardPreview } from '../../../types';
 export declare type ImageRendererProps = {
     readonly cardPreview: CardPreview;
     readonly mediaType: MediaType;

package/dist/{types/root → types-ts4.0/card}/ui/newFileExperience/types.d.ts

@@ -1,7 +1,7 @@
 import React, { MouseEvent, RefObject } from 'react';
 import { UIAnalyticsEvent } from '@atlaskit/analytics-next';
-import { CardDimensions, CardAppearance } from '../../..';
-import { Breakpoint } from '.././common';
+import { CardDimensions, CardAppearance } from '../../../types';
+import { Breakpoint } from '../common';
 import { MediaCardCursor } from '../../../types';
 export interface NewFileExperienceWrapperProps {
     testId?: string;

package/dist/{types/root → types-ts4.0/card}/ui/styles.d.ts

@@ -1,4 +1,4 @@
-import { CardDimensions, CardAppearance } from '../..';
+import { CardDimensions, CardAppearance } from '../../types';
 import { Breakpoint } from './common';
 import { MediaCardCursor } from '../../types';
 export declare const calcBreakpointSize: (wrapperWidth?: number) => Breakpoint;

package/dist/{types/root → types-ts4.0/card}/ui/titleBox/types.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="react" />
 import { MessageDescriptor } from 'react-intl-next';
 import { Breakpoint } from '../common';
-import { TitleBoxIcon as TitleBoxIconType } from '../../../index';
+import { TitleBoxIcon as TitleBoxIconType } from '../../../types';
 export declare type TitleBoxProps = {
     name: string;
     breakpoint: Breakpoint;

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

@@ -0,0 +1,5 @@
+/**
+ * Entry Point: @atlaskit/media-card/classnames
+ * tsconfig.entry-points.json
+ */
+export { fileCardImageViewSelector, fileCardImageViewSelectedSelector, } from './card/cardImageView/classnames';

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

@@ -0,0 +1,41 @@
+import { CardPreview } from './types';
+/**
+ * Primary reason is logged through Data Portal.
+ * Make sure all the values are whitelisted in Measure -> Event Regitry -> "mediaCardRender failed" event
+ */
+export declare type MediaCardErrorPrimaryReason = 'upload' | 'metadata-fetch' | 'error-file-state' | RemotePreviewPrimaryReason | LocalPreviewPrimaryReason | ImageLoadPrimaryReason | SsrPreviewPrimaryReason | 'missing-error-data' | 'preview-fetch';
+export declare type ImageLoadPrimaryReason = 'cache-remote-uri' | 'cache-local-uri' | 'local-uri' | 'remote-uri' | 'external-uri' | 'unknown-uri';
+export declare type RemotePreviewPrimaryReason = 'remote-preview-fetch' | 'remote-preview-not-ready';
+export declare type LocalPreviewPrimaryReason = 'local-preview-get' | 'local-preview-unsupported' | 'local-preview-rejected' | 'local-preview-image' | 'local-preview-video';
+export declare type SsrPreviewPrimaryReason = 'ssr-client-uri' | 'ssr-client-load' | 'ssr-server-uri' | 'ssr-server-load';
+export declare class MediaCardError extends Error {
+    readonly primaryReason: MediaCardErrorPrimaryReason;
+    readonly secondaryError?: Error | undefined;
+    constructor(primaryReason: MediaCardErrorPrimaryReason, secondaryError?: Error | undefined);
+}
+export declare class LocalPreviewError extends MediaCardError {
+    readonly primaryReason: LocalPreviewPrimaryReason;
+    readonly secondaryError?: Error | undefined;
+    constructor(primaryReason: LocalPreviewPrimaryReason, secondaryError?: Error | undefined);
+}
+export declare class RemotePreviewError extends MediaCardError {
+    readonly primaryReason: RemotePreviewPrimaryReason;
+    readonly secondaryError?: Error | undefined;
+    constructor(primaryReason: RemotePreviewPrimaryReason, secondaryError?: Error | undefined);
+}
+export declare class SsrPreviewError extends MediaCardError {
+    readonly primaryReason: SsrPreviewPrimaryReason;
+    readonly secondaryError?: Error | undefined;
+    constructor(primaryReason: SsrPreviewPrimaryReason, secondaryError?: Error | undefined);
+}
+export declare const getImageLoadPrimaryReason: (source?: import("./types").CardPreviewSource | undefined) => ImageLoadPrimaryReason;
+export declare class ImageLoadError extends MediaCardError {
+    constructor(source?: CardPreview['source']);
+}
+export declare function isMediaCardError(err: Error): err is MediaCardError;
+export declare const isLocalPreviewError: (err: Error) => err is LocalPreviewError;
+export declare const isRemotePreviewError: (err: Error) => err is LocalPreviewError;
+export declare const isUnsupportedLocalPreviewError: (err: Error) => boolean;
+export declare function isImageLoadError(err: Error): err is ImageLoadError;
+export declare const ensureMediaCardError: (primaryReason: MediaCardErrorPrimaryReason, error: Error) => MediaCardError;
+export declare const isUploadError: (error?: MediaCardError | undefined) => boolean | undefined;

package/dist/types-ts4.0/in-product.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Entry Point: @atlaskit/media-card/in-product
+ * tsconfig.entry-points.json
+ */
+export { MediaCardPageObject } from './__tests_external__';

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

@@ -0,0 +1,15 @@
+/**
+ * Entry Point: @atlaskit/media-card
+ * tsconfig.entry-points.json
+ */
+export type { NumericalCardDimensions } from '@atlaskit/media-common';
+export type { CardAction, CardEventHandler } from './card/actions';
+export type { CardStatus, CardAppearance, CardDimensionValue, CardPreview, TitleBoxIcon, CardEvent, SharedCardProps, CardOnClickCallback, CardProps, CardState, CardDimensions, } from './types';
+export { Card } from './card';
+export { MediaInlineCard } from './inline';
+export { CardLoading } from './utils/lightCards/cardLoading';
+export { CardError } from './utils/lightCards/cardError';
+export { defaultImageCardDimensions } from './utils/cardDimensions';
+export { fileCardImageViewSelector, fileCardImageViewSelectedSelector, } from './card/cardImageView/classnames';
+export { inlinePlayerClassName } from './card/styles/styles';
+export { newFileExperienceClassName } from './card/cardConstants';

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

@@ -0,0 +1 @@
+export { default as MediaInlineCard } from './loader';

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

@@ -0,0 +1,96 @@
+/**
+ * Entry Point: @atlaskit/media-card/types
+ * tsconfig.entry-points.json
+ */
+import { MouseEvent } from 'react';
+import { FileDetails, MediaClient, Identifier, ImageResizeMode, FileState } from '@atlaskit/media-client';
+import { UIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { MediaFeatureFlags, NumericalCardDimensions, SSR } from '@atlaskit/media-common';
+import { CardAction } from './card/actions';
+import { MediaViewerDataSource } from '@atlaskit/media-viewer';
+import { MediaCardError } from './errors';
+export declare type CardStatus = 'uploading' | 'loading' | 'processing' | 'loading-preview' | 'complete' | 'error' | 'failed-processing';
+export declare type FilePreviewStatus = {
+    hasFilesize: boolean;
+    isPreviewable: boolean;
+    hasPreview: boolean;
+    isSupportedByBrowser: boolean;
+};
+export declare type FileStateFlags = {
+    wasStatusProcessing: boolean;
+    wasStatusUploading: boolean;
+};
+export declare type CardAppearance = 'auto' | 'image' | 'square' | 'horizontal';
+export declare type CardDimensionValue = number | string;
+export declare type CardPreviewSource = 'local' | 'remote' | 'ssr-server' | 'ssr-client' | 'ssr-data' | 'cache-local' | 'cache-remote' | 'cache-ssr-client' | 'cache-ssr-server' | 'external';
+export interface CardPreview {
+    dataURI: string;
+    orientation?: number;
+    dimensions?: CardDimensions;
+    source: CardPreviewSource;
+}
+export declare enum MediaCardCursor {
+    Action = "pointer",
+    NotReady = "wait"
+}
+export interface CardDimensions {
+    width?: CardDimensionValue;
+    height?: CardDimensionValue;
+}
+export declare type TitleBoxIcon = 'LockFilledIcon';
+export interface CardEvent {
+    event: MouseEvent<HTMLElement>;
+    mediaItemDetails?: FileDetails;
+}
+export interface SharedCardProps {
+    readonly disableOverlay?: boolean;
+    readonly resizeMode?: ImageResizeMode;
+    readonly featureFlags?: MediaFeatureFlags;
+    readonly appearance?: CardAppearance;
+    readonly dimensions?: CardDimensions;
+    readonly originalDimensions?: NumericalCardDimensions;
+    readonly actions?: Array<CardAction>;
+    readonly selectable?: boolean;
+    readonly selected?: boolean;
+    readonly alt?: string;
+    readonly testId?: string;
+    readonly titleBoxBgColor?: string;
+    readonly titleBoxIcon?: TitleBoxIcon;
+}
+export interface CardOnClickCallback {
+    (result: CardEvent, analyticsEvent?: UIAnalyticsEvent): void;
+}
+export interface CardEventProps {
+    readonly onClick?: CardOnClickCallback;
+    readonly onMouseEnter?: (result: CardEvent) => void;
+    /** Callback function to be called when video enters and exit fullscreen.
+     * `fullscreen = true` indicates video enters fullscreen
+     * `fullscreen = false` indicates video exits fullscreen
+     */
+    readonly onFullscreenChange?: (fullscreen: boolean) => void;
+}
+export interface CardProps extends SharedCardProps, CardEventProps {
+    readonly mediaClient: MediaClient;
+    readonly identifier: Identifier;
+    readonly isLazy?: boolean;
+    readonly useInlinePlayer?: boolean;
+    readonly shouldOpenMediaViewer?: boolean;
+    readonly mediaViewerDataSource?: MediaViewerDataSource;
+    readonly contextId?: string;
+    readonly shouldEnableDownloadButton?: boolean;
+    readonly ssr?: SSR;
+}
+export interface CardState {
+    status: CardStatus;
+    isCardVisible: boolean;
+    shouldAutoplay?: boolean;
+    isPlayingFile: boolean;
+    mediaViewerSelectedItem?: Identifier;
+    fileState?: FileState;
+    progress?: number;
+    cardPreview?: CardPreview;
+    error?: MediaCardError;
+    cardRef: HTMLDivElement | null;
+    isBannedLocalPreview: boolean;
+    previewDidRender: boolean;
+}

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

@@ -0,0 +1,77 @@
+import { FileDetails, MediaClientErrorReason, RequestMetadata } from '@atlaskit/media-client';
+import { FileAttributes, PerformanceAttributes, OperationalEventPayload, UIEventPayload, WithFileAttributes, WithPerformanceAttributes, SuccessAttributes, FailureAttributes, ScreenEventPayload, ScreenAttributes } from '@atlaskit/media-common';
+import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { MediaCardError, MediaCardErrorPrimaryReason } from '../errors';
+import { CardPreviewSource, CardDimensions } from '../types';
+export declare type CardPreviewAttributes = {
+    fileId: string;
+    prevDimensions: CardDimensions | undefined;
+    currentDimensions: CardDimensions | undefined;
+    dimensionsPercentageDiff?: CardDimensions | undefined;
+    source: CardPreviewSource;
+};
+declare type WithCardPreviewCacheAttributes = {
+    cardPreviewAttributes: CardPreviewAttributes;
+};
+export declare const LOGGED_FEATURE_FLAGS: (keyof import("@atlaskit/media-common").MediaFeatureFlags)[];
+export declare const LOGGED_FEATURE_FLAG_KEYS: string[];
+export declare type FileUriFailReason = 'local-uri' | 'remote-uri' | `unknown-uri`;
+export declare type FailedErrorFailReason = MediaCardErrorPrimaryReason | 'nativeError';
+export declare type MediaCardErrorInfo = {
+    failReason: FailedErrorFailReason;
+    error: MediaClientErrorReason | 'nativeError';
+    errorDetail: string;
+};
+export declare type SSRStatusFail = MediaCardErrorInfo & {
+    status: 'fail';
+};
+declare type SSRStatusSuccess = SuccessAttributes;
+declare type SSRStatusUnknown = {
+    status: 'unknown';
+};
+declare type SSRStatusAttributes = SSRStatusSuccess | SSRStatusFail | SSRStatusUnknown;
+export declare type SSRStatus = {
+    server: SSRStatusAttributes;
+    client: SSRStatusAttributes;
+};
+export declare type WithSSRReliability = {
+    ssrReliability?: SSRStatus;
+};
+export declare type RenderFailedEventPayload = OperationalEventPayload<WithFileAttributes & WithPerformanceAttributes & WithSSRReliability & FailureAttributes & {
+    failReason: FailedErrorFailReason | 'failed-processing';
+    error?: MediaClientErrorReason | 'nativeError';
+    request?: RequestMetadata;
+}, 'failed', 'mediaCardRender'>;
+export declare type RenderSucceededEventPayload = OperationalEventPayload<WithFileAttributes & WithPerformanceAttributes & WithSSRReliability & SuccessAttributes, 'succeeded', 'mediaCardRender'>;
+export declare type RenderCommencedEventPayload = OperationalEventPayload<WithFileAttributes & WithPerformanceAttributes, 'commenced', 'mediaCardRender'>;
+export declare type CacheHitEventPayload = OperationalEventPayload<WithCardPreviewCacheAttributes, 'cache-hit', 'mediaCardCache'>;
+export declare type RemoteSuccessEventPayload = OperationalEventPayload<WithCardPreviewCacheAttributes, 'Remote-success', 'mediaCardCache'>;
+export declare type CopiedFileEventPayload = UIEventPayload<{}, 'copied', string>;
+export declare type ClickedEventPayload = UIEventPayload<{
+    label?: string;
+}, 'clicked', string>;
+export declare type RenderScreenEventPayload = Omit<ScreenEventPayload<ScreenAttributes, 'mediaCardRenderScreen'>, 'attributes'> & {
+    attributes: {
+        type: string | undefined;
+        fileAttributes: FileAttributes;
+    };
+};
+export declare type MediaCardAnalyticsEventPayload = RenderCommencedEventPayload | RenderSucceededEventPayload | RenderFailedEventPayload | CopiedFileEventPayload | ClickedEventPayload | RenderScreenEventPayload | CacheHitEventPayload | RemoteSuccessEventPayload;
+export declare const getFileAttributes: (metadata: FileDetails, fileStatus?: import("@atlaskit/media-common").FileStatus | undefined) => FileAttributes;
+export declare const getRenderPreviewableCardPayload: (fileAttributes: FileAttributes) => RenderScreenEventPayload;
+export declare const getRenderCommencedEventPayload: (fileAttributes: FileAttributes, performanceAttributes: PerformanceAttributes) => RenderCommencedEventPayload;
+export declare const getRenderSucceededEventPayload: (fileAttributes: FileAttributes, performanceAttributes: PerformanceAttributes, ssrReliability: SSRStatus) => RenderSucceededEventPayload;
+export declare const getCacheHitEventPayload: (cardPreviewAttributes: CardPreviewAttributes) => CacheHitEventPayload;
+export declare const getRemoteSuccessEventPayload: (cardPreviewAttributes: CardPreviewAttributes) => RemoteSuccessEventPayload;
+export declare const getRenderFailedExternalUriPayload: (fileAttributes: FileAttributes, performanceAttributes: PerformanceAttributes) => RenderFailedEventPayload;
+export declare const getRenderErrorFailReason: (error: MediaCardError) => FailedErrorFailReason;
+export declare const getRenderErrorErrorReason: (error: MediaCardError) => MediaClientErrorReason | 'nativeError';
+export declare const getRenderErrorErrorDetail: (error: MediaCardError) => string;
+export declare const getRenderErrorRequestMetadata: (error: MediaCardError) => RequestMetadata | undefined;
+export declare const extractErrorInfo: (error: MediaCardError) => MediaCardErrorInfo;
+export declare const getRenderErrorEventPayload: (fileAttributes: FileAttributes, performanceAttributes: PerformanceAttributes, error: MediaCardError, ssrReliability: SSRStatus) => RenderFailedEventPayload;
+export declare const getRenderFailedFileStatusPayload: (fileAttributes: FileAttributes, performanceAttributes: PerformanceAttributes, ssrReliability: SSRStatus) => RenderFailedEventPayload;
+export declare const getCopiedFilePayload: (fileId: string) => CopiedFileEventPayload;
+export declare function fireMediaCardEvent(payload: MediaCardAnalyticsEventPayload, createAnalyticsEvent?: CreateUIAnalyticsEvent): void;
+export declare const createAndFireMediaCardEvent: (payload: MediaCardAnalyticsEventPayload) => (createAnalyticsEvent: CreateUIAnalyticsEvent) => import("@atlaskit/analytics-next").UIAnalyticsEvent;
+export {};