@atlaskit/media-card 74.1.6 → 74.1.7

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

@@ -0,0 +1,24 @@
+/// <reference types="react" />
+import { GlobalThemeTokens } from '@atlaskit/theme/components';
+import { CardStatus } from '../../index';
+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.0/files/index.d.ts

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

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

@@ -0,0 +1 @@
+export { MediaCardPageObject } from './__tests_external__';

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

@@ -0,0 +1,77 @@
+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 './actions';
+import { MediaViewerDataSource } from '@atlaskit/media-viewer';
+import { CardPreview, CardStatus, CardAppearance } from './types';
+import { MediaCardError } from './errors';
+import { CardDimensions } from './utils';
+export type { CardDimensions } from './utils';
+export type { NumericalCardDimensions } from '@atlaskit/media-common';
+export { Card, MediaInlineCard } from './root';
+export type { CardAction, CardEventHandler } from './actions';
+export type { CardStatus, CardAppearance, CardDimensionValue, CardPreview, } from './types';
+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;
+}
+export { CardLoading } from './utils/lightCards/cardLoading';
+export { CardError } from './utils/lightCards/cardError';
+export { defaultImageCardDimensions } from './utils/cardDimensions';
+export { fileCardImageViewSelector, fileCardImageViewSelectedSelector, } from './files/cardImageView/classnames';
+export { inlinePlayerClassName } from './root/styles';
+export { newFileExperienceClassName } from './root/card/cardConstants';

package/dist/types-ts4.0/root/card/cardAnalytics.d.ts

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

package/dist/types-ts4.0/root/card/cardConstants.d.ts

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

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

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

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

@@ -0,0 +1,5 @@
+import { FileState } from '@atlaskit/media-client';
+import { MediaFeatureFlags } from '@atlaskit/media-common';
+import { CardState } from '../..';
+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-ts4.0/root/card/getCardPreview/cache.d.ts

@@ -0,0 +1,19 @@
+import { ImageResizeMode } from '@atlaskit/media-client';
+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 {
+    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.0/root/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 | undefined) => FilePreviewStatus;
+export declare const isPreviewableStatus: (cardStatus: CardStatus, { isPreviewable, hasPreview, isSupportedByBrowser }: FilePreviewStatus) => boolean;

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

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

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

@@ -0,0 +1,57 @@
+import { MediaClient, FilePreview, FileState, MediaStoreGetFileImageParams, MediaBlobUrlAttrs, FileIdentifier } from '@atlaskit/media-client';
+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';
+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 declare 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;
+};
+/**
+ * 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, }: CardPreviewParams) => Promise<CardPreview>;
+export declare const shouldResolvePreview: ({ status, fileState, prevDimensions, dimensions, identifier, fileImageMode, hasCardPreview, isBannedLocalPreview, featureFlags, }: {
+    status: CardStatus;
+    fileState: FileState;
+    prevDimensions?: CardDimensions | undefined;
+    dimensions?: CardDimensions | undefined;
+    identifier: FileIdentifier;
+    fileImageMode?: ImageResizeMode | undefined;
+    hasCardPreview: boolean;
+    isBannedLocalPreview: boolean;
+    featureFlags?: MediaFeatureFlags | undefined;
+}) => boolean;
+export declare const getSSRCardPreview: (ssr: SSR, mediaClient: MediaClient, id: string, params: MediaStoreGetFileImageParams, mediaBlobUrlAttrs?: MediaBlobUrlAttrs | undefined) => 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 | undefined) => Promise<CardPreview>;

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

@@ -0,0 +1,4 @@
+import { FileStatus } from '@atlaskit/media-client';
+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/root/card/imageRefetchingAnalytics.d.ts

@@ -0,0 +1,10 @@
+import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { CardDimensions } from '../../utils';
+import { CardPreviewAttributes } from '../../utils/analytics';
+declare 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.0/root/card/index.d.ts

@@ -0,0 +1,58 @@
+import React, { Component } from 'react';
+import { UIAnalyticsEvent, WithAnalyticsEventsProps } from '@atlaskit/analytics-next';
+import { FileIdentifier, FileState, MediaSubscription } from '@atlaskit/media-client';
+import { WrappedComponentProps } from 'react-intl-next';
+import { CardAction, CardProps, CardState, CardStatus } from '../..';
+export declare type CardBaseProps = CardProps & WithAnalyticsEventsProps & Partial<WrappedComponentProps>;
+export declare class CardBase extends Component<CardBaseProps, CardState> {
+    private internalOccurrenceKey;
+    private hasBeenMounted;
+    private fileStateFlags;
+    private ssrReliability;
+    private timeElapsedTillCommenced;
+    subscription?: MediaSubscription;
+    private ssrData?;
+    static defaultProps: Partial<CardProps>;
+    constructor(props: CardBaseProps);
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: CardProps, prevState: CardState): void;
+    componentWillUnmount(): void;
+    updateStateForIdentifier(identifier: FileIdentifier): void;
+    private getImageURLParams;
+    private getMediaBlobUrlAttrs;
+    private getCardPreviewParams;
+    private setCacheSSRPreview;
+    private refetchSSRPreview;
+    private resolvePreview;
+    updateFileStateFlag(fileState?: FileState): void;
+    subscribeInternalFile(identifier: FileIdentifier): void;
+    private get requestedDimensions();
+    private get metadata();
+    private get fileAttributes();
+    private getPerformanceAttributes;
+    private logSSRImageError;
+    private onImageError;
+    private onImageLoad;
+    private fireOperationalEvent;
+    private fireCommencedEvent;
+    private fireCopiedEvent;
+    private fireScreenEvent;
+    private fireLocalPreviewErrorEvent;
+    private safeSetState;
+    unsubscribe: () => void;
+    get actions(): CardAction[];
+    onCardViewClick: (event: React.MouseEvent<HTMLDivElement>, analyticsEvent?: UIAnalyticsEvent | undefined) => void;
+    onInlinePlayerError: () => void;
+    setRef: (cardRef: HTMLDivElement | null) => void;
+    renderInlinePlayer: () => JSX.Element;
+    onMediaViewerClose: () => void;
+    private onDisplayImage;
+    renderMediaViewer: () => React.ReactPortal | undefined;
+    renderCard: (withCallbacks?: boolean, cardStatusOverride?: CardStatus | undefined, izLazyOverride?: boolean | undefined) => JSX.Element;
+    private storeSSRData;
+    render(): JSX.Element;
+    private onCardInViewport;
+    onClick: (event: React.MouseEvent<HTMLDivElement>, analyticsEvent?: UIAnalyticsEvent | undefined) => void;
+    onMouseEnter: (event: React.MouseEvent<HTMLDivElement>) => void;
+}
+export declare const Card: React.ComponentType<CardBaseProps>;

package/dist/types-ts4.0/root/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 '../index';
+import { MediaCardError } from '../errors';
+import { CardPreview } from '..';
+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 declare 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.0/root/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.0/root/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Card } from './card/cardLoader';
+export { default as MediaInlineCard } from './inline/loader';

package/dist/types-ts4.0/root/inline/loader.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import { WithMediaClientConfigProps } from '@atlaskit/media-client';
+import { MediaInlineCardProps } from './mediaInlineCard';
+export declare type MediaInlineCardWithMediaClientConfigProps = WithMediaClientConfigProps<MediaInlineCardProps>;
+declare type MediaInlineCardWithMediaClientConfigComponent = React.ComponentType<MediaInlineCardWithMediaClientConfigProps>;
+declare type ErrorBoundaryComponent = React.ComponentType<{
+    data?: {
+        [k: string]: any;
+    };
+}>;
+export interface MediaInlineCardLoaderState {
+    MediaInlineCard?: MediaInlineCardWithMediaClientConfigComponent;
+    ErrorBoundary?: ErrorBoundaryComponent;
+}
+export default class MediaInlineCardLoader extends React.PureComponent<MediaInlineCardWithMediaClientConfigProps & MediaInlineCardLoaderState, MediaInlineCardLoaderState> {
+    static displayName: string;
+    static MediaInlineCard?: MediaInlineCardWithMediaClientConfigComponent;
+    static ErrorBoundary?: ErrorBoundaryComponent;
+    isMounted: boolean;
+    state: MediaInlineCardLoaderState;
+    componentDidMount(): Promise<void>;
+    componentWillUnmount(): Promise<void>;
+    render(): JSX.Element;
+}
+export {};

package/dist/types-ts4.0/root/inline/mediaInlineCard.d.ts

@@ -0,0 +1,14 @@
+import React, { FC } from 'react';
+import { FileIdentifier, MediaClient } from '@atlaskit/media-client';
+import { WrappedComponentProps } from 'react-intl-next';
+import { MediaViewerDataSource } from '@atlaskit/media-viewer';
+export interface MediaInlineCardProps {
+    identifier: FileIdentifier;
+    mediaClient: MediaClient;
+    shouldOpenMediaViewer?: boolean;
+    isSelected?: boolean;
+    onClick?: React.EventHandler<React.MouseEvent | React.KeyboardEvent>;
+    mediaViewerDataSource?: MediaViewerDataSource;
+}
+export declare const MediaInlineCardInternal: FC<MediaInlineCardProps & WrappedComponentProps>;
+export declare const MediaInlineCard: React.FC<MediaInlineCardProps>;

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

@@ -0,0 +1,51 @@
+import React from 'react';
+import { Component } from 'react';
+import { MediaClient, FileIdentifier, FileState, MediaFileArtifacts, MediaSubscription } from '@atlaskit/media-client';
+import { CardDimensions, NumericalCardDimensions } from '..';
+import { WithAnalyticsEventsProps, UIAnalyticsEvent } from '@atlaskit/analytics-next';
+import type { CardPreview } from '..';
+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 declare 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.0/root/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.0/root/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.0/root/media-card-analytics-error-boundary.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+export declare type MediaCardAnalyticsErrorBoundaryProps = {
+    data?: {
+        [k: string]: any;
+    };
+};
+export default class MediaCardAnalyticsErrorBoundary extends React.Component<MediaCardAnalyticsErrorBoundaryProps> {
+    static displayName: string;
+    render(): JSX.Element;
+}

package/dist/types-ts4.0/root/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.0/root/types.d.ts

@@ -0,0 +1,24 @@
+import React, { MouseEvent, ReactElement, RefObject } from 'react';
+import { UIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { CardDimensions } from '../';
+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 declare 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.0/root/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.0/root/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.0/root/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 | undefined): import("@emotion/react").SerializedStyles;
+    displayName: string;
+};

package/dist/types-ts4.0/root/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 declare type ActionBarWrapperProps = {
+    isFixed?: boolean;
+    children?: ReactNode;
+};

package/dist/types-ts4.0/root/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.0/root/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 | undefined): import("@emotion/react").SerializedStyles;
+    displayName: string;
+};

package/dist/types-ts4.0/root/ui/common.d.ts

@@ -0,0 +1,23 @@
+export declare enum Breakpoint {
+    SMALL = "small",
+    LARGE = "large"
+}
+export declare const responsiveSettings: {
+    small: {
+        fontSize: number;
+        lineHeight: number;
+        titleBox: {
+            verticalPadding: number;
+            horizontalPadding: number;
+        };
+    };
+    large: {
+        fontSize: number;
+        lineHeight: number;
+        titleBox: {
+            verticalPadding: number;
+            horizontalPadding: number;
+        };
+    };
+};
+export declare const getTitleBoxHeight: (breakpoint: Breakpoint) => number;

package/dist/types-ts4.0/root/ui/iconMessage/iconMessageWrapper.d.ts

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