@atlaskit/media-card 77.1.2 → 77.2.0

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,13 @@
+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;
+export declare const transition: (propertyName?: string) => string;
+export declare const rgba: (hex: any, opacity: any) => string;

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/card/ui/wrapper/index.d.ts

@@ -0,0 +1 @@
+export { Wrapper } from './wrapper';

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

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

package/dist/types-ts4.5/card/ui/wrapper/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 WrapperProps {
+    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/wrapper/wrapper.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/useBreakpoint.d.ts

@@ -0,0 +1,3 @@
+import { Breakpoint } from './ui/common';
+import { CardDimensionValue } from '../types';
+export declare const useBreakpoint: (dimensionWidth: CardDimensionValue | undefined, divRef: React.RefObject<HTMLDivElement>) => Breakpoint;

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

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

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

@@ -0,0 +1,4 @@
+import React from 'react';
+import { CardWithMediaClientConfigProps } from '../cardLoader';
+declare const CardLoader: React.FC<CardWithMediaClientConfigProps>;
+export default CardLoader;

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

@@ -0,0 +1,44 @@
+/** @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, CardPreview, MediaCardCursor } from '../../types';
+import { MediaCardError } from '../../errors';
+export interface CardViewV2OwnProps 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;
+    shouldHideTooltip?: boolean;
+}
+export type CardViewV2Props = CardViewV2OwnProps & WithAnalyticsEventsProps;
+export interface RenderConfigByStatusV2 {
+    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;
+}
+export declare const CardViewV2Base: ({ innerRef, onImageLoad, onImageError, dimensions, appearance, onClick, onMouseEnter, testId, metadata, status, selected, selectable, cardPreview, mediaCardCursor, shouldHideTooltip, progress, alt, resizeMode, onDisplayImage, nativeLazyLoad, forceSyncDisplay, actions, disableOverlay, titleBoxBgColor, titleBoxIcon, error, disableAnimation, }: CardViewV2Props) => jsx.JSX.Element;
+export declare const CardViewV2: React.ForwardRefExoticComponent<Omit<CardViewV2Props, keyof WithAnalyticsEventsProps> & React.RefAttributes<any>>;

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

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

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

@@ -0,0 +1,23 @@
+import React from 'react';
+import { FileIdentifier, FileState, MediaFileArtifacts } 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;
+    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 declare const getPreferredVideoArtifact: (fileState: FileState) => keyof MediaFileArtifacts | undefined;
+export declare const InlinePlayerBaseV2: ({ identifier, onError, onClick, dimensions, originalDimensions, selected, testId, forwardRef, autoplay, cardPreview, onFullscreenChange, }: InlinePlayerProps) => JSX.Element;
+export declare const InlinePlayerV2: React.ForwardRefExoticComponent<Pick<InlinePlayerProps, "createAnalyticsEvent" | keyof InlinePlayerOwnProps> & React.RefAttributes<HTMLDivElement>>;

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

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

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

@@ -0,0 +1,53 @@
+import { MediaClientErrorReason } from '@atlaskit/media-client';
+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 MediaFileStateError extends Error {
+    readonly id: string;
+    readonly reason?: string | undefined;
+    readonly message: string;
+    readonly details?: Record<string, any> | undefined;
+    constructor(id: string, reason?: string | undefined, message?: string, details?: Record<string, any> | undefined);
+}
+export declare function isMediaFileStateError(err: Error): err is MediaFileStateError;
+export declare function getFileStateErrorReason(err: MediaFileStateError): MediaClientErrorReason | 'unknown';
+export declare function isPollingError(err?: Error): boolean;
+export declare function isRateLimitedError(error?: Error): boolean;
+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 } from './card/classnames';
+export { inlinePlayerClassName } from './card/inlinePlayerWrapperStyles';
+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;
+    mounted: 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/inline/mediaInlineCardAnalytics.d.ts

@@ -0,0 +1,6 @@
+import { FileState } from '@atlaskit/media-client';
+import { RenderInlineCardFailedEventPayload, RenderInlineCardSucceededEventPayload } from '../utils/analytics';
+import { MediaCardError } from '../errors';
+export declare const getSucceededStatusPayload: (fileState?: FileState) => RenderInlineCardSucceededEventPayload;
+export declare const getErrorStatusPayload: (error: MediaCardError, fileState?: FileState) => RenderInlineCardFailedEventPayload;
+export declare const getFailedProcessingStatusPayload: (fileState?: FileState) => RenderInlineCardFailedEventPayload;

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

@@ -0,0 +1,105 @@
+/**
+ * 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;
+    readonly shouldHideTooltip?: boolean;
+}
+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;
+    shouldUpdateStateForIdentifier?: boolean;
+}