@atlaskit/media-card 74.8.1 → 75.0.1

package/dist/types-ts4.5/card/cardAnalytics.d.ts

@@ -0,0 +1,10 @@
+import { FileAttributes, MediaTraceContext, PerformanceAttributes } from '@atlaskit/media-common';
+import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { SSRStatus } from '../utils/analytics';
+import { CardStatus } from '../types';
+import { MediaCardError } from '../errors';
+export declare const fireOperationalEvent: (createAnalyticsEvent: CreateUIAnalyticsEvent, status: CardStatus, fileAttributes: FileAttributes, performanceAttributes: PerformanceAttributes, ssrReliability: SSRStatus, error: MediaCardError | undefined, traceContext: MediaTraceContext, metadataTraceContext?: MediaTraceContext) => void;
+export declare const fireCommencedEvent: (createAnalyticsEvent: CreateUIAnalyticsEvent, fileAttributes: FileAttributes, performanceAttributes: PerformanceAttributes, traceContext: MediaTraceContext) => void;
+export declare const fireCopiedEvent: (createAnalyticsEvent: CreateUIAnalyticsEvent, fileId: string, cardRef: HTMLDivElement) => void;
+export declare const fireScreenEvent: (createAnalyticsEvent: CreateUIAnalyticsEvent, fileAttributes: FileAttributes) => void;
+export declare const fireNonCriticalErrorEvent: (createAnalyticsEvent: CreateUIAnalyticsEvent, cardStatus: CardStatus, fileAttributes: FileAttributes, ssrReliability: SSRStatus, error: MediaCardError | undefined, traceContext: MediaTraceContext, metadataTraceContext?: MediaTraceContext) => void;

package/dist/types-ts4.5/card/cardConstants.d.ts

@@ -0,0 +1 @@
+export declare const newFileExperienceClassName = "new-file-experience-wrapper";

package/dist/types-ts4.5/card/cardImageView/cardImageViewWrapper.d.ts

@@ -0,0 +1,6 @@
+/**@jsx jsx */
+import { jsx } from '@emotion/react';
+import { WrapperProps } from './styles';
+export declare const CardImageViewWrapper: (props: WrapperProps) => jsx.JSX.Element;
+export declare const PlayIconWrapper: (props: any) => jsx.JSX.Element;
+export declare const ProgressBarWrapper: (props: any) => jsx.JSX.Element;

package/dist/types-ts4.5/card/cardImageView/cardOverlay/cardOverlayComponents.d.ts

@@ -0,0 +1,8 @@
+/**@jsx jsx */
+import { jsx } from '@emotion/react';
+import { OverlayProps } from './styles';
+export declare const Overlay: (props: OverlayProps) => jsx.JSX.Element;
+export declare const ErrorMessage: (props: any) => jsx.JSX.Element;
+export declare const AltWrapper: (props: any) => jsx.JSX.Element;
+export declare const TitleWrapper: (props: any) => jsx.JSX.Element;
+export declare const Metadata: (props: any) => jsx.JSX.Element;

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

@@ -0,0 +1,39 @@
+/**@jsx jsx */
+import { jsx } from '@emotion/react';
+import { MouseEvent, Component, ReactNode } from 'react';
+import { MediaType } from '@atlaskit/media-client';
+import { CardAction, CardEventHandler } from '../../actions';
+import { CardStatus } from '../../../types';
+export interface CardOverlayProps {
+    readonly cardStatus: CardStatus;
+    mediaType?: MediaType;
+    mediaName?: string;
+    subtitle?: string;
+    selectable?: boolean;
+    selected?: boolean;
+    persistent: boolean;
+    error?: ReactNode;
+    alt?: string;
+    noHover?: boolean;
+    actions?: Array<CardAction>;
+    icon?: string;
+}
+export interface CardOverlayState {
+    isMenuExpanded: boolean;
+}
+export declare class CardOverlay extends Component<CardOverlayProps, CardOverlayState> {
+    static defaultProps: {
+        actions: never[];
+        mediaName: string;
+    };
+    constructor(props: CardOverlayProps);
+    private get wrapperClassNames();
+    render(): jsx.JSX.Element;
+    errorLine(): false | "" | 0 | jsx.JSX.Element | null | undefined;
+    tickBox(): false | jsx.JSX.Element | undefined;
+    bottomLeftColumn(): jsx.JSX.Element | undefined;
+    onMenuToggle: (attrs: {
+        isOpen: boolean;
+    }) => void;
+    removeBtnClick(handler: CardEventHandler): (e: MouseEvent<HTMLDivElement, any>) => void;
+}

package/dist/types-ts4.5/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-ts4.5/card/cardImageView/cardViewWrapper.d.ts

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

package/dist/types-ts4.5/card/cardImageView/classnames.d.ts

@@ -0,0 +1,2 @@
+export declare const fileCardImageViewSelector = "media-file-card-view";
+export declare const fileCardImageViewSelectedSelector = "media-file-card-view-selected";

package/dist/types-ts4.5/card/cardImageView/fileCardImageView.d.ts

@@ -0,0 +1,49 @@
+/**@jsx jsx */
+import { jsx } from '@emotion/react';
+import { Component, ReactNode } from 'react';
+import { MediaItemType, MediaType, ImageResizeMode } from '@atlaskit/media-client';
+import { CardStatus, CardPreview, CardDimensions } from '../../types';
+import { CardAction } from '../actions';
+export interface FileCardImageViewProps {
+    readonly mediaName?: string;
+    readonly mediaType?: MediaType;
+    readonly mimeType?: string;
+    readonly fileSize?: string;
+    readonly dataURI?: string;
+    readonly alt?: string;
+    readonly progress?: number;
+    readonly status: CardStatus;
+    readonly mediaItemType: MediaItemType;
+    readonly dimensions?: CardDimensions;
+    readonly resizeMode?: ImageResizeMode;
+    readonly disableOverlay?: boolean;
+    readonly selectable?: boolean;
+    readonly selected?: boolean;
+    readonly error?: ReactNode;
+    readonly actions?: CardAction[];
+    readonly onDisplayImage?: () => void;
+    readonly previewOrientation?: number;
+    readonly onImageError?: (cardPreview: CardPreview) => void;
+    readonly onImageLoad?: (cardPreview: CardPreview) => void;
+    readonly cardPreview: CardPreview;
+}
+export declare class FileCardImageView extends Component<FileCardImageViewProps> {
+    private wasThumbnailDisplayed;
+    static defaultProps: Partial<FileCardImageViewProps>;
+    render(): jsx.JSX.Element;
+    private renderCardContents;
+    private renderLoadingContents;
+    private renderErrorContents;
+    private renderFailedContents;
+    private renderUploadingCardOverlay;
+    private renderPlayButton;
+    onImageLoad: () => void;
+    onImageError: () => void;
+    private renderMediaImage;
+    private renderProgressBar;
+    private renderSuccessCardContents;
+    private renderSuccessCardOverlay;
+    private get isFileCardImageReadyForDisplay();
+    private get isCropped();
+    private get isStretched();
+}

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

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

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

@@ -0,0 +1,24 @@
+/// <reference types="react" />
+import { GlobalThemeTokens } from '@atlaskit/theme/components';
+import { CardStatus } from '../../types';
+export interface WrapperProps {
+    disableOverlay?: boolean;
+    selectable?: boolean;
+    selected?: boolean;
+    hasOnClick?: boolean;
+    mediaType?: string;
+    mediaName?: string;
+    progress?: number;
+    status?: CardStatus;
+    theme?: GlobalThemeTokens;
+    children?: JSX.Element | JSX.Element[];
+}
+export declare const wrapperStyles: (props: WrapperProps) => import("@emotion/react").SerializedStyles;
+export declare const playIconWrapperStyles: import("@emotion/react").SerializedStyles;
+export declare const playIconBackgroundStyles: import("@emotion/react").SerializedStyles;
+export declare const progressBarWrapperStyles: import("@emotion/react").SerializedStyles;
+export declare const overlayStyles: import("@emotion/react").SerializedStyles;
+export declare const titleStyles: import("@emotion/react").SerializedStyles;
+export declare const bodyStyles: import("@emotion/react").SerializedStyles;
+export declare const progressWrapperStyles: import("@emotion/react").SerializedStyles;
+export declare const cardActionsWrapperStyles: import("@emotion/react").SerializedStyles;

package/dist/types-ts4.5/card/cardLoader.d.ts

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

package/dist/types-ts4.5/card/cardState.d.ts

@@ -0,0 +1,10 @@
+import { FileState } from '@atlaskit/media-client';
+import { MediaFeatureFlags } from '@atlaskit/media-common';
+import { CardState } from '../types';
+import { MediaCardError } from '../errors';
+/**
+ * From docs: "Both state and props received by the updater function are guaranteed to be up-to-date.
+ * The output of the updater is shallowly merged with state."
+ */
+export declare const createStateUpdater: (newState: Partial<CardState>, fireErrorEvent: (error: MediaCardError) => void) => (prevState: CardState) => Partial<CardState>;
+export declare const getCardStateFromFileState: (fileState: FileState, isBannedLocalPreview: boolean, featureFlags?: MediaFeatureFlags) => Partial<CardState>;

package/dist/types-ts4.5/card/cardView.d.ts

@@ -0,0 +1,80 @@
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+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 '../types';
+import { MediaCardError } from '../errors';
+import { CardPreview } from '../types';
+import { MediaCardCursor } from '../types';
+export interface CardViewOwnProps extends SharedCardProps {
+    readonly status: CardStatus;
+    readonly mediaItemType: MediaItemType;
+    readonly mediaCardCursor?: MediaCardCursor;
+    readonly metadata?: FileDetails;
+    readonly error?: MediaCardError;
+    readonly onClick?: (event: React.MouseEvent<HTMLDivElement>, analyticsEvent?: UIAnalyticsEvent) => void;
+    readonly onMouseEnter?: (event: MouseEvent<HTMLDivElement>) => void;
+    readonly onDisplayImage?: () => void;
+    readonly cardPreview?: CardPreview;
+    readonly progress?: number;
+    readonly innerRef?: (instance: HTMLDivElement | null) => void;
+    readonly onImageLoad: (cardPreview: CardPreview) => void;
+    readonly onImageError: (cardPreview: CardPreview) => void;
+    readonly nativeLazyLoad?: boolean;
+    readonly forceSyncDisplay?: boolean;
+    disableAnimation?: boolean;
+}
+export interface CardViewState {
+    elementWidth?: number;
+    didImageRender: boolean;
+}
+export type CardViewProps = CardViewOwnProps & WithAnalyticsEventsProps;
+export interface RenderConfigByStatus {
+    renderTypeIcon?: boolean;
+    iconMessage?: JSX.Element;
+    renderImageRenderer?: boolean;
+    renderPlayButton?: boolean;
+    renderTitleBox?: boolean;
+    renderBlanket?: boolean;
+    isFixedBlanket?: boolean;
+    renderProgressBar?: boolean;
+    renderSpinner?: boolean;
+    renderFailedTitleBox?: boolean;
+    renderTickBox?: boolean;
+    customTitleMessage?: MessageDescriptor;
+}
+/**
+ * This is classic vanilla CardView class. To create an instance of class one would need to supply
+ * `createAnalyticsEvent` prop to satisfy it's Analytics Events needs.
+ */
+export declare class CardViewBase extends React.Component<CardViewProps, CardViewState> {
+    state: CardViewState;
+    divRef: React.RefObject<HTMLDivElement>;
+    static defaultProps: Partial<CardViewOwnProps>;
+    componentDidMount(): void;
+    componentDidUpdate({ cardPreview: prevCardPreview }: CardViewProps): void;
+    private onImageLoad;
+    private onImageError;
+    private get width();
+    private get breakpoint();
+    saveElementWidth: () => void;
+    render(): jsx.JSX.Element;
+    private renderSpinner;
+    private shouldRenderPlayButton;
+    private renderPlayButton;
+    private renderBlanket;
+    private renderTitleBox;
+    private renderFailedTitleBox;
+    private renderProgressBar;
+    private renderImageRenderer;
+    private renderTickBox;
+    private renderMediaTypeIcon;
+    private renderActionsBar;
+    private renderFileNewExperience;
+    private renderFile;
+    private getRenderConfigByStatus;
+    private renderNewExperienceCard;
+}
+export declare const CardView: React.ForwardRefExoticComponent<Pick<Omit<CardViewProps, keyof WithAnalyticsEventsProps>, never> & Partial<Pick<Omit<CardViewProps, keyof WithAnalyticsEventsProps>, keyof CardViewOwnProps>> & Partial<Pick<Partial<CardViewOwnProps>, never>> & React.RefAttributes<any>>;

package/dist/types-ts4.5/card/getCardPreview/cache.d.ts

@@ -0,0 +1,19 @@
+import { ImageResizeMode } from '@atlaskit/media-client';
+import { ObjectURLCache } from '../../utils/objectURLCache';
+import { CardPreview } from '../../types';
+type Mode = ImageResizeMode | undefined;
+export declare const getCacheKey: (id: string, mode: Mode) => string;
+export interface CardPreviewCache {
+    get(id: string, mode: Mode): CardPreview | undefined;
+    set(id: string, mode: Mode, cardPreview: CardPreview): void;
+    remove(id: string, mode: Mode): void;
+}
+export declare class CardPreviewCacheImpl implements CardPreviewCache {
+    private previewCache;
+    constructor(previewCache: ObjectURLCache);
+    get: (id: string, mode: Mode) => CardPreview | undefined;
+    set: (id: string, mode: Mode, cardPreview: CardPreview) => void;
+    remove: (id: string, mode: Mode) => void;
+}
+declare const _default: CardPreviewCacheImpl;
+export default _default;

package/dist/types-ts4.5/card/getCardPreview/filePreviewStatus.d.ts

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

package/dist/types-ts4.5/card/getCardPreview/helpers.d.ts

@@ -0,0 +1,10 @@
+import { MediaClient, FilePreview, MediaStoreGetFileImageParams, MediaType } from '@atlaskit/media-client';
+import { MediaTraceContext } from '@atlaskit/media-common';
+import { CardPreview } from '../../types';
+/**
+ * This method tells the support for the media
+ * types covered in getCardPreviewFromFilePreview
+ */
+export declare const isSupportedLocalPreview: (mediaType?: MediaType) => boolean;
+export declare const getCardPreviewFromFilePreview: (filePreview: FilePreview | Promise<FilePreview>) => Promise<CardPreview>;
+export declare const getCardPreviewFromBackend: (mediaClient: MediaClient, id: string, params: MediaStoreGetFileImageParams, traceContext?: MediaTraceContext) => Promise<CardPreview>;

package/dist/types-ts4.5/card/getCardPreview/imageRefetchingAnalytics.d.ts

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

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

@@ -0,0 +1,59 @@
+import { MediaClient, FilePreview, FileState, MediaStoreGetFileImageParams, MediaBlobUrlAttrs, FileIdentifier } from '@atlaskit/media-client';
+import { MediaFeatureFlags, SSR, MediaTraceContext } from '@atlaskit/media-common';
+import { ImageResizeMode } from '@atlaskit/media-client';
+import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+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;
+export declare const removeCardPreviewFromCache: (id: string, mode: ImageResizeMode | undefined) => void;
+/**
+ * Will return the preview if available and supported by the browser
+ * See extractFilePreviewStatus "hasLocalPreview" logic
+ */
+export declare const getFilePreviewFromFileState: (fileState: FileState) => FilePreview | Promise<FilePreview> | undefined;
+export type CardPreviewParams = {
+    mediaClient: MediaClient;
+    id: string;
+    dimensions?: CardDimensions;
+    filePreview?: FilePreview | Promise<FilePreview>;
+    onLocalPreviewError: (error: MediaCardError) => void;
+    isRemotePreviewReady: boolean;
+    imageUrlParams: MediaStoreGetFileImageParams;
+    mediaBlobUrlAttrs?: MediaBlobUrlAttrs;
+    createAnalyticsEvent?: CreateUIAnalyticsEvent;
+    featureFlags?: MediaFeatureFlags;
+    traceContext?: MediaTraceContext;
+};
+/**
+ * This function will try to return a Card preview, either from cache, local preview or remote preview.
+ * It should only be called if there is a chance to get either a remote or a local preview, or both.
+ * This, in order to ensure there is always going to be a valid return value OR throw an error if the process fails.
+ * It is worth noting that local preview failures break the process if there is no remote preview available.
+ * In that case we throw an error immediately.
+ * Otherwise, if the local preview fails but there is a remote preview available, the failure does not break the process.
+ * In that case, we still want to report the local preview error to the caller, for feature realiability track.
+ * hence the use of the optional callback onLocalPreviewError
+ */
+export declare const getCardPreview: ({ mediaClient, id, dimensions, filePreview, onLocalPreviewError, isRemotePreviewReady, imageUrlParams, mediaBlobUrlAttrs, createAnalyticsEvent, featureFlags, traceContext, }: CardPreviewParams) => Promise<CardPreview>;
+export declare const shouldResolvePreview: ({ status, fileState, prevDimensions, dimensions, identifier, fileImageMode, hasCardPreview, isBannedLocalPreview, featureFlags, wasResolvedUpfrontPreview, }: {
+    status: CardStatus;
+    fileState: FileState;
+    prevDimensions?: CardDimensions | undefined;
+    dimensions?: CardDimensions | undefined;
+    identifier: FileIdentifier;
+    fileImageMode?: ImageResizeMode | undefined;
+    hasCardPreview: boolean;
+    isBannedLocalPreview: boolean;
+    featureFlags?: MediaFeatureFlags | undefined;
+    wasResolvedUpfrontPreview: boolean;
+}) => boolean;
+export declare const getSSRCardPreview: (ssr: SSR, mediaClient: MediaClient, id: string, params: MediaStoreGetFileImageParams, mediaBlobUrlAttrs?: MediaBlobUrlAttrs) => CardPreview;
+export declare const isLocalPreview: (preview: CardPreview) => boolean;
+export declare const isSSRPreview: (preview: CardPreview) => boolean;
+export declare const isSSRServerPreview: (preview: CardPreview) => boolean;
+export declare const isSSRClientPreview: (preview: CardPreview) => boolean;
+export declare const isSSRDataPreview: (preview: CardPreview) => boolean;
+export declare const fetchAndCacheRemotePreview: (mediaClient: MediaClient, id: string, dimensions: CardDimensions, params: MediaStoreGetFileImageParams, mediaBlobUrlAttrs?: MediaBlobUrlAttrs, traceContext?: MediaTraceContext) => Promise<CardPreview>;

package/dist/types-ts4.5/card/getCardStatus.d.ts

@@ -0,0 +1,5 @@
+import { FileStatus } from '@atlaskit/media-client';
+import { MediaFeatureFlags } from '@atlaskit/media-common';
+import { CardStatus, FilePreviewStatus } from '../types';
+export declare const isFinalCardStatus: (status: CardStatus) => boolean;
+export declare const getCardStatus: (fileStatus: FileStatus, filePreviewStatus: FilePreviewStatus, featureFlags?: MediaFeatureFlags) => CardStatus;

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

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

package/dist/types-ts4.5/card/inlinePlayer.d.ts

@@ -0,0 +1,52 @@
+import React from 'react';
+import { Component } from 'react';
+import { MediaClient, FileIdentifier, FileState, MediaFileArtifacts, MediaSubscription } from '@atlaskit/media-client';
+import { NumericalCardDimensions } from '@atlaskit/media-common';
+import { CardDimensions } from '../types';
+import { WithAnalyticsEventsProps, UIAnalyticsEvent } from '@atlaskit/analytics-next';
+import type { CardPreview } from '../types';
+export interface InlinePlayerOwnProps {
+    identifier: FileIdentifier;
+    mediaClient: MediaClient;
+    dimensions?: CardDimensions;
+    originalDimensions?: NumericalCardDimensions;
+    autoplay: boolean;
+    selected?: boolean;
+    onFullscreenChange?: (fullscreen: boolean) => void;
+    onError?: (error: Error) => void;
+    readonly onClick?: (event: React.MouseEvent<HTMLDivElement>, analyticsEvent?: UIAnalyticsEvent) => void;
+    testId?: string;
+    readonly cardPreview?: CardPreview;
+    readonly forwardRef?: React.Ref<HTMLDivElement>;
+}
+export type InlinePlayerProps = InlinePlayerOwnProps & WithAnalyticsEventsProps;
+export interface InlinePlayerState {
+    fileSrc?: string;
+    isUploading?: boolean;
+    progress?: number;
+    elementWidth?: number;
+}
+export declare const getPreferredVideoArtifact: (fileState: FileState) => keyof MediaFileArtifacts | undefined;
+export declare class InlinePlayerBase extends Component<InlinePlayerProps, InlinePlayerState> {
+    subscription?: MediaSubscription;
+    state: InlinePlayerState;
+    divRef: React.RefObject<HTMLDivElement>;
+    static defaultProps: {
+        dimensions: {
+            width: number;
+            height: number;
+        };
+    };
+    componentDidMount(): void;
+    setFileSrc: (fileSrc: string) => void;
+    setBinaryURL: () => Promise<void>;
+    unsubscribe: () => void;
+    revoke: () => void;
+    componentWillUnmount(): void;
+    onDownloadClick: () => void;
+    onFirstPlay: () => void;
+    private get breakpoint();
+    saveElementWidth: () => void;
+    render(): JSX.Element;
+}
+export declare const InlinePlayer: React.ForwardRefExoticComponent<Pick<InlinePlayerProps, "createAnalyticsEvent" | keyof InlinePlayerOwnProps> & React.RefAttributes<HTMLDivElement>>;

package/dist/types-ts4.5/card/inlinePlayerLazy.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const InlinePlayerLazy: import("react").LazyExoticComponent<import("react").ForwardRefExoticComponent<Pick<import("./inlinePlayer").InlinePlayerProps, "createAnalyticsEvent" | keyof import("./inlinePlayer").InlinePlayerOwnProps> & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/types-ts4.5/card/inlinePlayerWrapper.d.ts

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

package/dist/types-ts4.5/card/media-card-analytics-error-boundary.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { MediaFeatureFlags } from '@atlaskit/media-common';
+import { CardDimensions, CardOnClickCallback } from '../types';
+import { WithAnalyticsEventsProps } from '@atlaskit/analytics-next';
+export type MediaCardAnalyticsErrorBoundaryProps = {
+    dimensions?: CardDimensions;
+    data?: {
+        [k: string]: any;
+    };
+    onClick?: CardOnClickCallback;
+    featureFlags?: MediaFeatureFlags;
+} & WithAnalyticsEventsProps;
+declare const MediaCardAnalyticsErrorBoundary: React.ComponentType<MediaCardAnalyticsErrorBoundaryProps & WithAnalyticsEventsProps>;
+export default MediaCardAnalyticsErrorBoundary;

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

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

package/dist/types-ts4.5/card/styles/config.d.ts

@@ -0,0 +1 @@
+export declare const defaultTransitionDuration = ".3s";

package/dist/types-ts4.5/card/styles/easing.d.ts

@@ -0,0 +1,2 @@
+export declare const easeOutCubic = "cubic-bezier(0.215, 0.61, 0.355, 1)";
+export declare const easeOutExpo = "cubic-bezier(0.19, 1, 0.22, 1)";

package/dist/types-ts4.5/card/styles/getSelectedBorderStyle.d.ts

@@ -0,0 +1,3 @@
+export declare const getSelectedBorderStyle: ({ selected, }: {
+    selected?: boolean | undefined;
+}) => string;

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

@@ -0,0 +1,8 @@
+export { defaultTransitionDuration } from './config';
+export { antialiased, borderRadiusLeft, capitalize, centerSelf, centerSelfX, centerSelfY, centerX, hexToRgb, rgba, spaceAround, transition, withAppearance, } from './mixins';
+export type { WithAppearanceProps } from './mixins';
+export { easeOutCubic, easeOutExpo } from './easing';
+export { spin } from './animations';
+export declare const rootStyles: () => import("@emotion/react").SerializedStyles;
+export declare const cardShadow: string;
+export default rootStyles;

package/dist/types-ts4.5/card/styles/mixins.d.ts

@@ -0,0 +1,21 @@
+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";
+export declare const centerSelfX = "\n  position: absolute;\n  left: 50%;\n  transform: translateX(-50%);\n";
+export declare const centerSelf = "\n  position: absolute;\n  left: 50%;\n  top: 50%;\n  transform: translate(-50%, -50%);\n";
+export declare const borderRadiusLeft: string;
+export declare const spaceAround = "\n  display: flex;\n  flex-direction: column;\n  justify-content: space-around;\n";
+export declare const transition: (propertyName?: string) => string;
+export declare const hexToRgb: (hex: any) => string | null;
+export declare const rgba: (hex: any, opacity: any) => string;
+export declare const capitalize = "\n  &::first-letter {\n    text-transform: uppercase;\n  }\n";
+export interface WithAppearanceProps {
+    appearance?: CardAppearance;
+}
+export declare const withAppearance: (styleMap: {
+    auto?: string | undefined;
+    image?: string | undefined;
+    square?: string | undefined;
+    horizontal?: string | undefined;
+}) => ({ appearance }: WithAppearanceProps) => string;

package/dist/types-ts4.5/card/styles/styles.d.ts

@@ -0,0 +1,10 @@
+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;
+    displayName: string;
+};
+export declare const inlinePlayerWrapperStyles: {
+    ({ dimensions, selected, }: InlinePlayerWrapperProps): import("@emotion/react").SerializedStyles;
+    displayName: string;
+};

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

@@ -0,0 +1,24 @@
+import React, { MouseEvent, ReactElement, RefObject } from 'react';
+import { UIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { CardDimensions } from '../types';
+import { BreakpointSizeValue } from '../utils/breakpoint';
+export interface WrapperProps {
+    testId?: string;
+    shouldUsePointerCursor?: boolean;
+    dimensions?: CardDimensions;
+    breakpointSize?: BreakpointSizeValue;
+    onClick?: (event: React.MouseEvent<HTMLDivElement>, analyticsEvent?: UIAnalyticsEvent) => void;
+    onMouseEnter?: (event: MouseEvent<HTMLDivElement>) => void;
+    innerRef?: RefObject<HTMLDivElement>;
+    children?: JSX.Element;
+}
+export type InlinePlayerWrapperProps = {
+    testId?: string;
+    dimensions?: CardDimensions;
+    selected: {
+        selected?: boolean | undefined;
+    };
+    onClick?: (event: React.MouseEvent<HTMLDivElement>, analyticsEvent?: UIAnalyticsEvent) => void;
+    innerRef?: RefObject<HTMLDivElement> | ((instance: HTMLDivElement | null) => void) | undefined;
+    children?: JSX.Element[] | ReactElement<any, any> | null | any;
+};

package/dist/types-ts4.5/card/ui/actionsBar/actionsBar.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { ActionsBarProps } from './types';
+export declare class ActionsBar extends React.Component<ActionsBarProps> {
+    render(): JSX.Element | null;
+}

package/dist/types-ts4.5/card/ui/actionsBar/actionsBarWrapper.d.ts

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

package/dist/types-ts4.5/card/ui/actionsBar/styles.d.ts

@@ -0,0 +1,6 @@
+export declare const actionsBarClassName = "media-card-actions-bar";
+export declare const fixedActionBarStyles = "opacity: 1;";
+export declare const wrapperStyles: {
+    (isFixed?: boolean): import("@emotion/react").SerializedStyles;
+    displayName: string;
+};

package/dist/types-ts4.5/card/ui/actionsBar/types.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+import { CardAction } from '../../actions';
+export interface ActionsBarProps {
+    actions: Array<CardAction>;
+    isFixed?: boolean;
+}
+export type ActionBarWrapperProps = {
+    isFixed?: boolean;
+    children?: ReactNode;
+};

package/dist/types-ts4.5/card/ui/blanket/blanket.d.ts

@@ -0,0 +1,6 @@
+/**@jsx jsx */
+import { jsx } from '@emotion/react';
+export interface BlanketProps {
+    isFixed?: boolean;
+}
+export declare const Blanket: (props: BlanketProps) => jsx.JSX.Element;

package/dist/types-ts4.5/card/ui/blanket/styles.d.ts

@@ -0,0 +1,6 @@
+export declare const blanketClassName = "media-card-blanket";
+export declare const fixedBlanketStyles: string;
+export declare const blanketStyles: {
+    (isFixed?: boolean): import("@emotion/react").SerializedStyles;
+    displayName: string;
+};