@atlaskit/media-card 74.8.1 → 75.0.1

package/dist/types-ts4.5/card/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.5/card/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;

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

@@ -0,0 +1,8 @@
+import React from 'react';
+import { InternalIconMessageProps, CreatingPreviewProps } from './types';
+export declare const IconMessage: React.FC<InternalIconMessageProps>;
+export declare const CreatingPreview: React.FC<CreatingPreviewProps>;
+export declare const PreviewUnavailable: React.FC;
+export declare const FailedToLoad: React.FC;
+export declare const FailedToUpload: React.FC;
+export declare const PreviewCurrentlyUnavailable: React.FC;

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

@@ -0,0 +1,5 @@
+import { StyledTextProps } from './types';
+export declare const iconMessageWrapperStyles: {
+    (props: StyledTextProps): import("@emotion/react").SerializedStyles;
+    displayName: string;
+};

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

@@ -0,0 +1,19 @@
+import { ReactNode } from 'react';
+import { MessageDescriptor } from 'react-intl-next';
+export type InternalIconMessageProps = {
+    messageDescriptor: MessageDescriptor;
+    animated?: boolean;
+    reducedFont?: boolean;
+};
+export type CreatingPreviewProps = {
+    disableAnimation?: boolean;
+};
+export type StyledTextProps = {
+    animated?: boolean;
+    reducedFont?: boolean;
+};
+export type IconMessageWrapperProps = {
+    animated?: boolean;
+    reducedFont?: boolean;
+    children?: ReactNode;
+};

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

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

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

@@ -0,0 +1,7 @@
+import { Breakpoint } from '../common';
+import { IconWrapperProps } from './types';
+export declare function titleBoxHeight(hasTitleBox: boolean, breakpoint: Breakpoint): string;
+export declare const iconWrapperStyles: {
+    ({ hasTitleBox, breakpoint, }: IconWrapperProps): import("@emotion/react").SerializedStyles;
+    displayName: string;
+};

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

@@ -0,0 +1,6 @@
+import { Breakpoint } from '../common';
+export type IconWrapperProps = {
+    hasTitleBox: boolean;
+    breakpoint: Breakpoint;
+    children?: any;
+};

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

@@ -0,0 +1,15 @@
+import React from 'react';
+import { MediaType, ImageResizeMode } from '@atlaskit/media-client';
+import { CardPreview } from '../../../types';
+export type ImageRendererProps = {
+    readonly cardPreview: CardPreview;
+    readonly mediaType: MediaType;
+    readonly alt?: string;
+    readonly resizeMode?: ImageResizeMode;
+    readonly onDisplayImage?: () => void;
+    readonly onImageError?: (cardPreview: CardPreview) => void;
+    readonly onImageLoad?: (cardPreview: CardPreview) => void;
+    readonly nativeLazyLoad?: boolean;
+    readonly forceSyncDisplay?: boolean;
+};
+export declare const ImageRenderer: React.FC<ImageRendererProps>;

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

@@ -0,0 +1,13 @@
+import { Breakpoint } from '../common';
+export declare const loadingRateLimitedContainerStyles: import("@emotion/react").SerializedStyles;
+export declare const warningIconWrapperStyles: import("@emotion/react").SerializedStyles;
+export type StyledTextProps = {
+    breakpoint: Breakpoint;
+    positionBottom: boolean;
+};
+export declare const loadingRateLimitedTextWrapperStyles: {
+    ({ breakpoint, positionBottom, }: StyledTextProps): import("@emotion/react").SerializedStyles;
+    displayName: string;
+};
+export declare const couldntLoadWrapperStyles: import("@emotion/react").SerializedStyles;
+export declare const errorWrapperStyles: import("@emotion/react").SerializedStyles;

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

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

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

@@ -0,0 +1,5 @@
+import { NewFileExperienceWrapperProps } from './types';
+export declare const newFileExperienceWrapperStyles: {
+    ({ breakpoint, dimensions, appearance, disableOverlay, displayBackground, selected, isPlayButtonClickable, isTickBoxSelectable, shouldDisplayTooltip, mediaCardCursor, theme, }: NewFileExperienceWrapperProps): import("@emotion/react").SerializedStyles;
+    displayName: string;
+};

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

@@ -0,0 +1,25 @@
+import React, { MouseEvent, RefObject } from 'react';
+import { UIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { CardDimensions, CardAppearance } from '../../../types';
+import { Breakpoint } from '../common';
+import { MediaCardCursor } from '../../../types';
+import { GlobalThemeTokens } from '@atlaskit/theme/components';
+export interface NewFileExperienceWrapperProps {
+    testId?: string;
+    breakpoint: Breakpoint;
+    mediaCardCursor?: MediaCardCursor;
+    dimensions?: CardDimensions;
+    appearance?: CardAppearance;
+    onClick?: (event: React.MouseEvent<HTMLDivElement>, analyticsEvent?: UIAnalyticsEvent) => void;
+    onMouseEnter?: (event: MouseEvent<HTMLDivElement>) => void;
+    mediaType?: string;
+    disableOverlay: boolean;
+    displayBackground: boolean;
+    selected: boolean;
+    isPlayButtonClickable: boolean;
+    isTickBoxSelectable: boolean;
+    shouldDisplayTooltip: boolean;
+    innerRef?: RefObject<HTMLDivElement>;
+    children?: JSX.Element;
+    theme?: GlobalThemeTokens;
+}

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

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const PlayButton: () => JSX.Element;

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

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

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

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

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

@@ -0,0 +1,5 @@
+export declare const playButtonClassName = "media-card-play-button";
+export declare const bkgClassName = "play-icon-background";
+export declare const fixedPlayButtonStyles: string;
+export declare const playButtonWrapperStyles: import("@emotion/react").SerializedStyles;
+export declare const backgroundStyles: import("@emotion/react").SerializedStyles;

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

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { Breakpoint } from '../common';
+export type ProgressBarProps = {
+    progress?: number;
+    breakpoint?: Breakpoint;
+    positionBottom?: boolean;
+    showOnTop?: boolean;
+};
+export declare const getNormalizedProgress: (progress?: number) => number;
+export declare const ProgressBar: ({ progress, breakpoint, positionBottom, showOnTop, }: ProgressBarProps) => JSX.Element;

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

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

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

@@ -0,0 +1,7 @@
+import { Breakpoint } from '../common';
+import { StyledBarProps } from './types';
+export declare function generateResponsiveStyles(breakpoint: Breakpoint, positionBottom: boolean, showOnTop: boolean, multiplier?: number): string;
+export declare const styledBarStyles: {
+    (props: StyledBarProps): import("@emotion/react").SerializedStyles;
+    displayName: string;
+};

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

@@ -0,0 +1,7 @@
+import { Breakpoint } from '../common';
+export type StyledBarProps = {
+    progress?: number;
+    breakpoint: Breakpoint;
+    positionBottom: boolean;
+    showOnTop: boolean;
+};

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

@@ -0,0 +1,11 @@
+import { CardDimensions, CardAppearance } from '../../types';
+import { Breakpoint } from './common';
+import { MediaCardCursor } from '../../types';
+export declare const calcBreakpointSize: (wrapperWidth?: number) => Breakpoint;
+export declare const generateResponsiveStyles: (breakpoint?: Breakpoint) => string;
+export declare const getWrapperDimensions: (dimensions?: CardDimensions, appearance?: CardAppearance) => string;
+export declare const getWrapperShadow: (disableOverlay: boolean, selected: boolean) => string;
+export declare const getCursorStyle: (cursor: MediaCardCursor | undefined) => string;
+export declare const getClickablePlayButtonStyles: (isPlayButtonClickable: boolean) => string;
+export declare const getSelectableTickBoxStyles: (isTickBoxSelectable: boolean) => string;
+export declare const cardImageContainerStyles: import("@emotion/react").SerializedStyles;

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

@@ -0,0 +1,7 @@
+export declare const tickBoxClassName = "media-card-tickbox";
+export declare const tickboxFixedStyles: string;
+export declare const getSelectedStyles: (selected?: boolean) => string;
+export declare const wrapperStyles: {
+    (selected?: boolean): import("@emotion/react").SerializedStyles;
+    displayName: string;
+};

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

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { TickBoxProps } from './types';
+export declare const TickBox: ({ selected }: TickBoxProps) => JSX.Element;

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

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

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

@@ -0,0 +1,4 @@
+export type TickBoxProps = {
+    selected?: boolean;
+    children?: any;
+};

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

@@ -0,0 +1,3 @@
+import React from 'react';
+import { FailedTitleBoxProps } from './types';
+export declare const FailedTitleBox: React.FC<FailedTitleBoxProps>;

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

@@ -0,0 +1,15 @@
+import { TitleBoxFooterProps, TitleBoxHeaderProps, TitleBoxWrapperProps } from './types';
+export declare const titleBoxWrapperStyles: {
+    ({ breakpoint, titleBoxBgColor, theme, }: TitleBoxWrapperProps): import("@emotion/react").SerializedStyles;
+    displayName: string;
+};
+export declare const titleBoxHeaderStyles: {
+    ({ hasIconOverlap, }: TitleBoxHeaderProps): import("@emotion/react").SerializedStyles;
+    displayName: string;
+};
+export declare const titleBoxFooterStyles: {
+    ({ hasIconOverlap, }: TitleBoxFooterProps): import("@emotion/react").SerializedStyles;
+    displayName: string;
+};
+export declare const titleBoxIconStyles: import("@emotion/react").SerializedStyles;
+export declare const errorMessageWrapperStyles: import("@emotion/react").SerializedStyles;

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

@@ -0,0 +1,4 @@
+import React from 'react';
+import { FormattedDateProps, TitleBoxProps } from './types';
+export declare const FormattedDate: React.ComponentType<FormattedDateProps>;
+export declare const TitleBox: ({ name, createdAt, breakpoint, titleBoxBgColor, titleBoxIcon, }: TitleBoxProps) => JSX.Element;

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

@@ -0,0 +1,8 @@
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+import { TitleBoxFooterProps, TitleBoxHeaderProps, TitleBoxWrapperProps } from './types';
+export declare const TitleBoxWrapper: (props: TitleBoxWrapperProps) => jsx.JSX.Element;
+export declare const TitleBoxHeader: (props: TitleBoxHeaderProps) => jsx.JSX.Element;
+export declare const TitleBoxFooter: (props: TitleBoxFooterProps) => jsx.JSX.Element;
+export declare const TitleBoxIcon: (props: any) => jsx.JSX.Element;
+export declare const ErrorMessageWrapper: (props: any) => jsx.JSX.Element;

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

@@ -0,0 +1,34 @@
+/// <reference types="react" />
+import { MessageDescriptor } from 'react-intl-next';
+import { Breakpoint } from '../common';
+import { TitleBoxIcon as TitleBoxIconType } from '../../../types';
+import { GlobalThemeTokens } from '@atlaskit/theme/components';
+export type TitleBoxProps = {
+    name: string;
+    breakpoint: Breakpoint;
+    createdAt?: number;
+    titleBoxBgColor?: string;
+    titleBoxIcon?: TitleBoxIconType;
+};
+export type FormattedDateProps = {
+    timestamp: number;
+};
+export type TitleBoxWrapperProps = {
+    breakpoint: Breakpoint;
+    titleBoxBgColor?: string;
+    children?: JSX.Element | JSX.Element[] | any;
+    theme?: GlobalThemeTokens;
+};
+export type TitleBoxFooterProps = {
+    hasIconOverlap: boolean;
+    children?: JSX.Element;
+};
+export type TitleBoxHeaderProps = {
+    hasIconOverlap: boolean;
+    children?: JSX.Element;
+};
+export type OnRetryFunction = () => void;
+export type FailedTitleBoxProps = {
+    breakpoint: Breakpoint;
+    customMessage?: MessageDescriptor;
+};

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

@@ -0,0 +1,7 @@
+/** @jsx jsx */
+import { Component } from 'react';
+import { jsx } from '@emotion/react';
+import { UnhandledErrorCardProps } from './types';
+export declare class UnhandledErrorCard extends Component<UnhandledErrorCardProps, {}> {
+    render(): jsx.JSX.Element;
+}

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

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import { CardDimensions } from '../../../types';
+export interface UnhandledErrorCardProps {
+    dimensions?: CardDimensions;
+    onClick?: (event: React.MouseEvent<HTMLElement>) => void;
+}

package/dist/types-ts4.5/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.5/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 type MediaCardErrorPrimaryReason = 'upload' | 'metadata-fetch' | 'error-file-state' | RemotePreviewPrimaryReason | LocalPreviewPrimaryReason | ImageLoadPrimaryReason | SsrPreviewPrimaryReason | 'missing-error-data' | 'preview-fetch';
+export type ImageLoadPrimaryReason = 'cache-remote-uri' | 'cache-local-uri' | 'local-uri' | 'remote-uri' | 'external-uri' | 'unknown-uri';
+export type RemotePreviewPrimaryReason = 'remote-preview-fetch' | 'remote-preview-not-ready' | 'remote-preview-fetch-ssr';
+export type LocalPreviewPrimaryReason = 'local-preview-get' | 'local-preview-unsupported' | 'local-preview-rejected' | 'local-preview-image' | 'local-preview-video';
+export 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?: CardPreview['source']) => 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, updatePrimaryReason?: boolean) => MediaCardError;
+export declare const isUploadError: (error?: MediaCardError) => boolean | undefined;

package/dist/types-ts4.5/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, InlineCardEvent, SharedCardProps, CardOnClickCallback, InlineCardOnClickCallback, 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.5/inline/index.d.ts

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

package/dist/types-ts4.5/inline/loader.d.ts

@@ -0,0 +1,26 @@
+import React from 'react';
+import { WithMediaClientConfigProps } from '@atlaskit/media-client';
+import { MediaInlineCardProps } from './mediaInlineCard';
+export type MediaInlineCardWithMediaClientConfigProps = WithMediaClientConfigProps<MediaInlineCardProps>;
+type MediaInlineCardWithMediaClientConfigComponent = React.ComponentType<MediaInlineCardWithMediaClientConfigProps>;
+type ErrorBoundaryComponent = React.ComponentType<{
+    data?: {
+        [k: string]: any;
+    };
+    isSelected?: boolean;
+}>;
+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.5/inline/mediaInlineAnalyticsErrorBoundary.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { MediaFeatureFlags } from '@atlaskit/media-common';
+import { WithAnalyticsEventsProps } from '@atlaskit/analytics-next';
+export type MediaInlineAnalyticsErrorBoundaryProps = {
+    isSelected?: boolean;
+    data?: {
+        [k: string]: any;
+    };
+    featureFlags?: MediaFeatureFlags;
+} & WithAnalyticsEventsProps;
+declare const MediaInlineAnalyticsErrorBoundary: React.ComponentType<MediaInlineAnalyticsErrorBoundaryProps & WithAnalyticsEventsProps>;
+export default MediaInlineAnalyticsErrorBoundary;

package/dist/types-ts4.5/inline/mediaInlineCard.d.ts

@@ -0,0 +1,15 @@
+import React, { FC } from 'react';
+import { FileIdentifier, Identifier, MediaClient } from '@atlaskit/media-client';
+import { WrappedComponentProps } from 'react-intl-next';
+import { InlineCardOnClickCallback } from '../types';
+export interface MediaInlineCardProps {
+    identifier: FileIdentifier;
+    mediaClient: MediaClient;
+    shouldOpenMediaViewer?: boolean;
+    shouldDisplayToolTip?: boolean;
+    isSelected?: boolean;
+    onClick?: InlineCardOnClickCallback;
+    mediaViewerItems?: Identifier[];
+}
+export declare const MediaInlineCardInternal: FC<MediaInlineCardProps & WrappedComponentProps>;
+export declare const MediaInlineCard: React.FC<MediaInlineCardProps>;

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

@@ -0,0 +1,103 @@
+/**
+ * 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 { MediaCardError } from './errors';
+export type CardStatus = 'uploading' | 'loading' | 'processing' | 'loading-preview' | 'complete' | 'error' | 'failed-processing';
+export type FilePreviewStatus = {
+    hasFilesize: boolean;
+    isPreviewable: boolean;
+    hasPreview: boolean;
+    isSupportedByBrowser: boolean;
+};
+export type FileStateFlags = {
+    wasStatusProcessing: boolean;
+    wasStatusUploading: boolean;
+};
+export type CardAppearance = 'auto' | 'image' | 'square' | 'horizontal';
+export declare type CardDimensionValue = number | string;
+export 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 type TitleBoxIcon = 'LockFilledIcon';
+export interface CardEvent {
+    event: MouseEvent<HTMLElement>;
+    mediaItemDetails?: FileDetails;
+}
+export interface InlineCardEvent {
+    event: MouseEvent<HTMLElement> | React.KeyboardEvent;
+    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 InlineCardOnClickCallback {
+    (result: InlineCardEvent, 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 mediaViewerItems?: Identifier[];
+    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;
+    wasResolvedUpfrontPreview: boolean;
+}