@atlaskit/media-client 24.0.1 → 24.0.3

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

@@ -0,0 +1,89 @@
+export { MediaStore, MediaStoreError, isMediaStoreError, getMediaEnvironment, getMediaRegion, } from './client/media-store';
+export type { ResponseFileItem, ItemsPayload, ImageMetadataArtifact, ImageMetadata, MediaStoreResponse, MediaStoreRequestOptions, MediaStoreCreateFileFromUploadParams, MediaStoreCreateFileParams, MediaStoreTouchFileParams, TouchFileDescriptor, MediaStoreTouchFileBody, MediaStoreCreateFileFromBinaryParams, MediaStoreCreateFileFromUploadConditions, MediaStoreCreateFileFromUploadBody, MediaStoreGetFileParams, MediaStoreGetFileImageParams, SourceFile, MediaStoreCopyFileWithTokenBody, MediaStoreCopyFileWithTokenParams, AppendChunksToUploadRequestBody, CreatedTouchedFile, TouchedFiles, EmptyFile, MediaStoreErrorReason, MediaStoreErrorAttributes, } from './client/media-store';
+export { UploadController } from './upload-controller';
+export type { AbortFunction } from './upload-controller';
+export type { MediaItemType, FileItem, FileProcessingStatus, MediaArtifact, Artifacts, FileDetails, } from './models/item';
+export { isPreviewableType } from './models/media';
+export type { MediaFileProcessingStatus, MediaType, MediaFile, MediaRepresentations, MediaItemDetails, MediaUpload, MediaChunksProbe, } from './models/media';
+export { getArtifactUrl } from './models/artifacts';
+export { isMediaClientError, getMediaClientErrorReason } from './models/errors';
+export type { MediaClientError, MediaClientErrorReason, MediaClientErrorAttributes, } from './models/errors';
+export { isUploadingFileState, isProcessingFileState, isProcessedFileState, isErrorFileState, isPreviewableFileState, isFinalFileState, isImageRepresentationReady, mapMediaFileToFileState, mapMediaItemToFileState, } from './models/file-state';
+export type { FileStatus, PreviewOptions, GetFileOptions, NonErrorFileState, PreviewableFileState, } from './models/file-state';
+export type { FileState, FilePreview, ErrorFileState, UploadingFileState, ProcessingFileState, ProcessedFileState, ProcessingFailedState, MediaFileArtifact, MediaFileArtifacts, } from '@atlaskit/media-state';
+export type { MobileUpload, MobileUploadStartEvent, MobileUploadProgressEvent, MobileUploadEndEvent, MobileUploadErrorEvent, } from './models/mobile-upload';
+export { uploadFile } from './uploader';
+export type { UploadableFile, UploadableFileUpfrontIds, UploadFileCallbacks, UploadFileResult, } from './uploader';
+export { request, RequestError, isRequestError, isRateLimitedError, createRequestErrorReason, } from './utils/request';
+export type { RequestErrorReason, RequestErrorMetadata, RequestErrorAttributes, } from './utils/request';
+export { isAbortedRequestError, mapResponseToJson, mapResponseToBlob, mapResponseToVoid, createUrl, } from './utils/request/helpers';
+export { PollingFunction } from './utils/polling';
+export { isPollingError, PollingError } from './utils/polling/errors';
+export type { Executor, PollingErrorAttributes, PollingErrorReason, } from './utils/polling/types';
+export type { RequestMethod, RequestParams, RequestHeaders, RetryOptions, ClientOptions, RequestMetadata, RequestOptions, CreateUrlOptions, } from './utils/request/types';
+export type { ImageResizeMode } from './utils/imageResizeModeToFileImageMode';
+export { imageResizeModeToFileImageMode } from './utils/imageResizeModeToFileImageMode';
+export { FileFetcherImpl, FileFetcherError, isFileFetcherError, } from './client/file-fetcher';
+export type { CopySourceFile, CopyDestination, CopyFileOptions, FileFetcher, FileFetcherErrorAttributes, FileFetcherErrorReason, } from './client/file-fetcher';
+export { MediaClient } from './client/media-client';
+export { StargateClient } from './client/stargate-client';
+export type { EdgeData } from './client/stargate-client';
+export { isImageRemote } from './utils/isImageRemote';
+export { checkWebpSupport } from './utils/checkWebpSupport';
+export { getDimensionsFromBlob } from './utils/getDimensionsFromBlob';
+export type { Dimensions } from './utils/getDimensionsFromBlob';
+export { createMediaSubject } from './utils/createMediaSubject';
+export { safeUnsubscribe } from './utils/safeUnsubscribe';
+export { isFileIdentifier, isExternalImageIdentifier, isDifferentIdentifier, } from './identifier';
+export type { Identifier, FileIdentifier, ExternalImageIdentifier, } from './identifier';
+export type { EventPayloadListener, UploadEventPayloadMap, MediaViewedEventPayload, } from './client/events';
+export { withMediaClient, getMediaClient } from './utils/with-media-client-hoc';
+export type { WithMediaClientConfig, WithMediaClientConfigProps, WithMediaClientFunction, WithMediaClient, } from './utils/with-media-client-hoc';
+export type { MediaClientConfig } from '@atlaskit/media-core';
+export { globalMediaEventEmitter } from './globalMediaEventEmitter';
+export { isMediaBlobUrl, getAttrsFromUrl, addFileAttrsToUrl, objectToQueryString, } from './utils/url';
+export type { MediaBlobUrlAttrs } from './utils/url';
+export { createMediaSubscribable, fromObservable, } from './utils/mediaSubscribable';
+export type { MediaSubscribable, MediaSubscription, MediaObserver, } from './utils/mediaSubscribable';
+export { RECENTS_COLLECTION, MAX_RESOLUTION } from './constants';
+export { getFileStreamsCache } from './file-streams-cache';
+/**
+ * @deprecated This export will be removed. Please use one from @atlaskit/media-common or @atlaskit/media-common/mediaTypeUtils
+ */
+export declare const getMediaTypeFromMimeType: (mimeType: string) => import("@atlaskit/media-common").MediaType;
+/**
+ * @deprecated This export will be removed. Please use one from @atlaskit/media-common or @atlaskit/media-common/mediaTypeUtils
+ */
+export declare const isImageMimeTypeSupportedByBrowser: (mimeType: string) => boolean;
+/**
+ * @deprecated This export will be removed. Please use one from @atlaskit/media-common or @atlaskit/media-common/mediaTypeUtils
+ */
+export declare const isDocumentMimeTypeSupportedByBrowser: (mimeType: string) => boolean;
+/**
+ * @deprecated This export will be removed. Please use one from @atlaskit/media-common or @atlaskit/media-common/mediaTypeUtils
+ */
+export declare const isMimeTypeSupportedByBrowser: (mimeType: string) => boolean;
+/**
+ * @deprecated This export will be removed. Please use one from @atlaskit/media-common or @atlaskit/media-common/mediaTypeUtils
+ */
+export declare const isImageMimeTypeSupportedByServer: (mimeType: string) => boolean;
+/**
+ * @deprecated This export will be removed. Please use one from @atlaskit/media-common or @atlaskit/media-common/mediaTypeUtils
+ */
+export declare const isDocumentMimeTypeSupportedByServer: (mimeType: string) => boolean;
+/**
+ * @deprecated This export will be removed. Please use one from @atlaskit/media-common or @atlaskit/media-common/mediaTypeUtils
+ */
+export declare const isAudioMimeTypeSupportedByServer: (mimeType: string) => boolean;
+/**
+ * @deprecated This export will be removed. Please use one from @atlaskit/media-common or @atlaskit/media-common/mediaTypeUtils
+ */
+export declare const isVideoMimeTypeSupportedByServer: (mimeType: string) => boolean;
+/**
+ * @deprecated This export will be removed. Please use one from @atlaskit/media-common or @atlaskit/media-common/mediaTypeUtils
+ */
+export declare const isUnknownMimeTypeSupportedByServer: (mimeType: string) => boolean;
+/**
+ * @deprecated This export will be removed. Please use one from @atlaskit/media-common or @atlaskit/media-common/mediaTypeUtils
+ */
+export declare const isMimeTypeSupportedByServer: (mimeType: string) => boolean;

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

@@ -0,0 +1,2 @@
+import { MediaFileArtifacts } from '@atlaskit/media-state';
+export declare const getArtifactUrl: (artifacts: MediaFileArtifacts, prop: keyof MediaFileArtifacts) => string | undefined;

package/dist/types-ts4.5/models/auth-headers.d.ts

@@ -0,0 +1,11 @@
+import { Auth } from '@atlaskit/media-core';
+export interface ClientBasedAuthHeaders {
+    readonly 'X-Client-Id': string;
+    readonly Authorization: string;
+}
+export interface AsapBasedAuthHeaders {
+    readonly 'X-Issuer': string;
+    readonly Authorization: string;
+}
+export type AuthHeaders = ClientBasedAuthHeaders | AsapBasedAuthHeaders;
+export declare function mapAuthToAuthHeaders(auth: Auth): AuthHeaders;

package/dist/types-ts4.5/models/auth-query-parameters.d.ts

@@ -0,0 +1,11 @@
+import { Auth } from '@atlaskit/media-core';
+export interface ClientBasedQueryParameters {
+    readonly client: string;
+    readonly token: string;
+}
+export interface AsapBasedQueryParameters {
+    readonly issuer: string;
+    readonly token: string;
+}
+export type AuthQueryParameters = ClientBasedQueryParameters | AsapBasedQueryParameters;
+export declare function mapAuthToQueryParameters(auth: Auth): AuthQueryParameters;

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

@@ -0,0 +1,6 @@
+export type { MediaClientError, MediaClientErrorReason } from './types';
+import { MediaClientError, MediaClientErrorReason } from './types';
+export declare function isMediaClientError(error: any): error is MediaClientError<{
+    reason: MediaClientErrorReason;
+}>;
+export declare function getMediaClientErrorReason(err: Error): MediaClientErrorReason | 'unknown';

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

@@ -0,0 +1,11 @@
+import { MediaClientError, MediaClientErrorAttributes } from './types';
+export type { MediaClientError, MediaClientErrorReason, MediaClientErrorAttributes, } from './types';
+export { isMediaClientError, getMediaClientErrorReason } from './helpers';
+/**
+ * Base class for media errors
+ */
+export declare abstract class BaseMediaClientError<Attributes extends MediaClientErrorAttributes> extends Error implements MediaClientError<Attributes> {
+    readonly message: string;
+    constructor(message: string);
+    abstract get attributes(): Attributes;
+}

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

@@ -0,0 +1,15 @@
+export type MediaClientErrorReason = 'clientOffline' | 'clientAbortedRequest' | 'clientTimeoutRequest' | 'serverInvalidBody' | 'serverBadRequest' | 'serverUnauthorized' | 'serverForbidden' | 'serverNotFound' | 'serverRateLimited' | 'serverInternalError' | 'serverBadGateway' | 'serverUnexpectedError' | 'failedAuthProvider' | 'tokenExpired' | 'missingInitialAuth' | 'emptyAuth' | 'authProviderTimedOut' | 'invalidFileId' | 'emptyItems' | 'zeroVersionFile' | 'emptyFileName' | 'pollingMaxAttemptsExceeded' | 'fileSizeExceedsLimit' | 'deprecatedEndpoint';
+export interface MediaClientErrorAttributes {
+    reason: MediaClientErrorReason;
+}
+/**
+ * MediaClientError is the main interface which all the errors
+ * in Media Client must implement.
+ * MediaClientErrorReason is a dictionary that restricts all the possible
+ * reasons that the erros can define. Its values are private to this file.
+ * Any new error has to define its own Error Reasons locally, and also declare them
+ * here to comply with the interface restrictions
+ */
+export interface MediaClientError<Attributes extends MediaClientErrorAttributes> extends Error {
+    readonly attributes: Attributes;
+}

package/dist/types-ts4.5/models/file-state.d.ts

@@ -0,0 +1,25 @@
+import { FileStatus as CommonFileStatus } from '@atlaskit/media-common';
+import { MediaStoreResponse } from '../client/media-store';
+import { MediaItemDetails, MediaFile } from './media';
+import { FilePreview, FileState, ErrorFileState, UploadingFileState, ProcessingFileState, ProcessedFileState, ProcessingFailedState } from '@atlaskit/media-state';
+export type FileStatus = CommonFileStatus;
+export interface PreviewOptions {
+}
+export interface GetFileOptions {
+    preview?: PreviewOptions;
+    collectionName?: string;
+    occurrenceKey?: string;
+}
+export interface PreviewableFileState {
+    preview: FilePreview | Promise<FilePreview>;
+}
+export type NonErrorFileState = Exclude<FileState, ErrorFileState>;
+export declare const isUploadingFileState: (fileState: FileState) => fileState is UploadingFileState;
+export declare const isProcessingFileState: (fileState: FileState) => fileState is ProcessingFileState;
+export declare const isProcessedFileState: (fileState: FileState) => fileState is ProcessedFileState;
+export declare const isErrorFileState: (fileState: FileState) => fileState is ErrorFileState;
+export declare const isPreviewableFileState: (fileState: FileState) => fileState is (UploadingFileState | ProcessingFileState | ProcessedFileState | ProcessingFailedState) & PreviewableFileState;
+export declare const isFinalFileState: (fileState: FileState) => fileState is ProcessedFileState | ErrorFileState | ProcessingFailedState;
+export declare const isImageRepresentationReady: (fileState: FileState) => boolean;
+export declare const mapMediaFileToFileState: (mediaFile: MediaStoreResponse<MediaFile>) => FileState;
+export declare const mapMediaItemToFileState: (id: string, item: MediaItemDetails) => FileState;

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

@@ -0,0 +1,25 @@
+import { MediaType } from './media';
+export type MediaItemType = 'file' | 'external-image';
+export interface FileItem {
+    type: 'file';
+    details: FileDetails;
+}
+export type FileProcessingStatus = 'pending' | 'running' | 'succeeded' | 'failed';
+export interface MediaArtifact {
+    processingStatus?: FileProcessingStatus;
+    url?: string;
+}
+export type Artifacts = {
+    [name: string]: MediaArtifact;
+};
+export interface FileDetails {
+    id: string;
+    name?: string;
+    size?: number;
+    mimeType?: string;
+    mediaType?: MediaType;
+    creationDate?: number;
+    processingStatus?: FileProcessingStatus;
+    artifacts?: Artifacts;
+    createdAt?: number;
+}

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

@@ -0,0 +1,48 @@
+import { MediaTraceContext, MediaType } from '@atlaskit/media-common';
+import { MediaFileArtifacts } from '@atlaskit/media-state';
+export type MediaFileProcessingStatus = 'pending' | 'succeeded' | 'failed';
+export type { MediaType } from '@atlaskit/media-common';
+export declare const isPreviewableType: (type: MediaType) => boolean;
+export type MediaFile = {
+    readonly id: string;
+    readonly mediaType: MediaType;
+    readonly mimeType: string;
+    readonly name: string;
+    readonly processingStatus?: MediaFileProcessingStatus;
+    readonly size: number;
+    readonly artifacts: MediaFileArtifacts;
+    readonly representations: MediaRepresentations;
+    readonly createdAt?: number;
+    readonly metadataTraceContext?: MediaTraceContext;
+};
+export type MediaItemDetails = {
+    readonly mediaType: MediaType;
+    readonly mimeType: string;
+    readonly name: string;
+    readonly processingStatus: MediaFileProcessingStatus;
+    readonly size: number;
+    readonly artifacts: MediaFileArtifacts;
+    readonly representations: MediaRepresentations;
+    readonly createdAt?: number;
+    readonly metadataTraceContext?: MediaTraceContext;
+};
+export type MediaRepresentations = {
+    image?: Object;
+};
+export type MediaUpload = {
+    readonly id: string;
+    readonly created: number;
+    readonly expires: number;
+};
+export type MediaChunksProbe = {
+    readonly results: {
+        readonly [etag: string]: {
+            readonly exists: boolean;
+        };
+    };
+};
+export declare enum DATA_UNIT {
+    MB = 1048576,
+    GB = 1073741824,
+    TB = 1099511627776
+}

package/dist/types-ts4.5/models/mobile-upload.d.ts

@@ -0,0 +1,28 @@
+import { FilePreview } from '@atlaskit/media-state';
+export type MobileUploadStartEvent = {
+    fileId: string;
+    collectionName?: string;
+    occurrenceKey?: string;
+    fileName: string;
+    fileSize: number;
+    fileMimetype: string;
+    preview?: FilePreview;
+    createdAt?: number;
+};
+export type MobileUploadProgressEvent = {
+    fileId: string;
+    progress: number;
+};
+export type MobileUploadEndEvent = {
+    fileId: string;
+};
+export type MobileUploadErrorEvent = {
+    fileId: string;
+    message: string;
+};
+export interface MobileUpload {
+    notifyUploadStart(event: MobileUploadStartEvent): void;
+    notifyUploadProgress(event: MobileUploadProgressEvent): void;
+    notifyUploadEnd(event: MobileUploadEndEvent): void;
+    notifyUploadError(event: MobileUploadErrorEvent): void;
+}

package/dist/types-ts4.5/test-helpers/_numbers.d.ts

@@ -0,0 +1 @@
+export declare function numbers(count: number): Array<number>;

package/dist/types-ts4.5/test-helpers/authProvider.d.ts

@@ -0,0 +1,6 @@
+import { AuthProvider } from '@atlaskit/media-core';
+export declare class StoryBookAuthProvider {
+    static create(isAsapEnvironment: boolean, access?: {
+        [resourceUrn: string]: string[];
+    }): AuthProvider;
+}

package/dist/types-ts4.5/test-helpers/collectionNames.d.ts

@@ -0,0 +1,5 @@
+export declare const defaultCollectionName = "MediaServicesSample";
+export declare const onlyAnimatedGifsCollectionName = "only-animated-gifs";
+export declare const fileCollectionName: string;
+export declare const defaultMediaPickerCollectionName = "mediapicker-test";
+export declare const collectionNames: string[];

package/dist/types-ts4.5/test-helpers/exampleMediaItems.d.ts

@@ -0,0 +1,53 @@
+import { FileIdentifier, FileDetails, ExternalImageIdentifier, MediaType } from '../';
+export declare const genericFileId: FileIdentifier;
+export declare const audioFileId: FileIdentifier;
+export declare const audioNoCoverFileId: FileIdentifier;
+export declare const videoFileId: FileIdentifier;
+export declare const videoHorizontalFileId: FileIdentifier;
+export declare const videoLargeFileId: FileIdentifier;
+export declare const videoSquareFileId: FileIdentifier;
+export declare const videoProcessingFailedId: FileIdentifier;
+export declare const imageFileId: FileIdentifier;
+export declare const emptyImageFileId: FileIdentifier;
+export declare const smallImageFileId: FileIdentifier;
+export declare const wideImageFileId: FileIdentifier;
+export declare const largeImageFileId: FileIdentifier;
+export declare const verticalImageFileId: FileIdentifier;
+export declare const docFileId: FileIdentifier;
+export declare const bigDocFileId: FileIdentifier;
+export declare const largePdfFileId: FileIdentifier;
+export declare const passwordProtectedPdfFileId: FileIdentifier;
+export declare const codeFileId: FileIdentifier;
+export declare const emailFileId: FileIdentifier;
+export declare const emailUnsupportedFileId: FileIdentifier;
+export declare const archiveFileId: FileIdentifier;
+export declare const zipJiraArchiveFileId: FileIdentifier;
+export declare const zipFileWithNestedFolderId: FileIdentifier;
+export declare const zipFileId: FileIdentifier;
+export declare const zipItemMultipleFoldersAtRootId: FileIdentifier;
+export declare const zipItemLargeInnerFileId: FileIdentifier;
+export declare const zipEncryptedFileId: FileIdentifier;
+export declare const unknownFileId: FileIdentifier;
+export declare const errorFileId: FileIdentifier;
+export declare const gifFileId: FileIdentifier;
+export declare const noMetadataFileId: FileIdentifier;
+export declare const animatedFileId: FileIdentifier;
+export declare const atlassianLogoUrl = "https://wac-cdn.atlassian.com/assets/img/favicons/atlassian/apple-touch-icon-152x152.png";
+export declare const externalImageIdentifier: ExternalImageIdentifier;
+export declare const externalSmallImageIdentifier: ExternalImageIdentifier;
+export declare const externaBrokenlIdentifier: ExternalImageIdentifier;
+export declare const genericFileDetails: FileDetails;
+export declare const imageFileDetails: FileDetails;
+export declare const videoFileDetails: FileDetails;
+export declare const audioFileDetails: FileDetails;
+export declare const docFileDetails: FileDetails;
+export declare const unknownFileDetails: FileDetails;
+export declare const genericDataURI = "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAZABkAAD/4QCMRXhpZgAATU0AKgAAAAgABQESAAMAAAABAAEAAAEaAAUAAAABAAAASgEbAAUAAAABAAAAUgEoAAMAAAABAAIAAIdpAAQAAAABAAAAWgAAAAAAAABkAAAAAQAAAGQAAAABAAOgAQADAAAAAQABAACgAgAEAAAAAQAAAAKgAwAEAAAAAQAAAAIAAAAA/+0AOFBob3Rvc2hvcCAzLjAAOEJJTQQEAAAAAAAAOEJJTQQlAAAAAAAQ1B2M2Y8AsgTpgAmY7PhCfv/AABEIAAIAAgMBEQACEQEDEQH/xAAfAAABBQEBAQEBAQAAAAAAAAAAAQIDBAUGBwgJCgv/xAC1EAACAQMDAgQDBQUEBAAAAX0BAgMABBEFEiExQQYTUWEHInEUMoGRoQgjQrHBFVLR8CQzYnKCCQoWFxgZGiUmJygpKjQ1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4eLj5OXm5+jp6vHy8/T19vf4+fr/xAAfAQADAQEBAQEBAQEBAAAAAAAAAQIDBAUGBwgJCgv/xAC1EQACAQIEBAMEBwUEBAABAncAAQIDEQQFITEGEkFRB2FxEyIygQgUQpGhscEJIzNS8BVictEKFiQ04SXxFxgZGiYnKCkqNTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqCg4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2dri4+Tl5ufo6ery8/T19vf4+fr/2wBDAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQICAQECAQEBAgICAgICAgICAQICAgICAgICAgL/2wBDAQEBAQEBAQEBAQECAQEBAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgL/3QAEAAH/2gAMAwEAAhEDEQA/AP0U8M2NmPDfh8C0tgBomkgAW8OAPsFvwK/lh7s+5u+/4n//2Q==";
+export declare const vrVideoDetails: {
+    id: string;
+    name: string;
+    dataUri: string;
+    previewDataUri: string;
+    mediaType: MediaType;
+    mimeType: string;
+};

package/dist/types-ts4.5/test-helpers/fakeMediaClient.d.ts

@@ -0,0 +1,4 @@
+import { MediaClientConfig } from '@atlaskit/media-core';
+import { MediaClient } from '../';
+export declare const getDefaultMediaClientConfig: () => MediaClientConfig;
+export declare const fakeMediaClient: (config?: MediaClientConfig) => MediaClient;

package/dist/types-ts4.5/test-helpers/index.d.ts

@@ -0,0 +1,7 @@
+export { StoryBookAuthProvider } from './authProvider';
+export { createStorybookMediaClient, createStorybookMediaClientConfig, createUploadMediaClient, createUploadMediaClientConfig, defaultBaseUrl, defaultParams, } from './mediaClientProvider';
+export { collectionNames, defaultCollectionName, defaultMediaPickerCollectionName, fileCollectionName, onlyAnimatedGifsCollectionName, } from './collectionNames';
+export { animatedFileId, archiveFileId, atlassianLogoUrl, audioFileDetails, audioFileId, audioNoCoverFileId, bigDocFileId, docFileDetails, docFileId, emptyImageFileId, errorFileId, externalImageIdentifier, externalSmallImageIdentifier, externaBrokenlIdentifier, genericDataURI, genericFileDetails, genericFileId, gifFileId, imageFileDetails, imageFileId, largeImageFileId, largePdfFileId, noMetadataFileId, passwordProtectedPdfFileId, smallImageFileId, unknownFileDetails, unknownFileId, verticalImageFileId, videoFileDetails, videoFileId, videoHorizontalFileId, videoLargeFileId, videoProcessingFailedId, videoSquareFileId, wideImageFileId, zipFileId, zipFileWithNestedFolderId, zipItemLargeInnerFileId, zipItemMultipleFoldersAtRootId, zipJiraArchiveFileId, zipEncryptedFileId, codeFileId, emailFileId, emailUnsupportedFileId, vrVideoDetails, } from './exampleMediaItems';
+export declare const authProviderBaseURL = "https://media.dev.atl-paas.net";
+export { mediaPickerAuthProvider, defaultMediaPickerAuthProvider, } from './mediaPickerAuthProvider';
+export { fakeMediaClient } from './fakeMediaClient';

package/dist/types-ts4.5/test-helpers/mediaClientProvider.d.ts

@@ -0,0 +1,23 @@
+import { MediaClient } from '../';
+import { MediaClientConfig } from '@atlaskit/media-core';
+import { MediaEnv } from './mediaPickerAuthProvider';
+export declare const defaultBaseUrl = "https://media.dev.atl-paas.net";
+export declare const defaultParams: {
+    clientId: string;
+    asapIssuer: string;
+    baseUrl: string;
+};
+interface AuthParameter {
+    authType: 'client' | 'asap';
+}
+/**
+ * Creates and returns `MediaClient` (from `media-client`) based on the data provided in parameter object.
+ *
+ * @param {AuthParameter} authParameter specifies serviceName and whatever auth should be done with clientId or asapIssuer
+ * @returns {Context}
+ */
+export declare const createStorybookMediaClient: (authParameter?: AuthParameter) => MediaClient;
+export declare const createStorybookMediaClientConfig: (authParameter?: AuthParameter) => MediaClientConfig;
+export declare const createUploadMediaClient: () => MediaClient;
+export declare const createUploadMediaClientConfig: (stargateBaseUrl?: string, env?: MediaEnv) => MediaClientConfig;
+export {};

package/dist/types-ts4.5/test-helpers/mediaPickerAuthProvider.d.ts

@@ -0,0 +1,5 @@
+import { Auth, AuthContext } from '@atlaskit/media-core';
+export declare const authProviderBaseURL = "https://media.dev.atl-paas.net";
+export type MediaEnv = 'dev' | 'staging';
+export declare const mediaPickerAuthProvider: (authEnvironment?: string, env?: MediaEnv) => (context?: AuthContext) => Promise<Auth>;
+export declare const defaultMediaPickerAuthProvider: () => () => Promise<Auth>;

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

@@ -0,0 +1,7 @@
+export type AbortFunction = () => void;
+export declare class UploadController {
+    abortFunction?: AbortFunction;
+    constructor();
+    setAbort(abortFunction: AbortFunction): void;
+    abort(): void;
+}

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

@@ -0,0 +1,11 @@
+export declare const fileSizeError = "fileSizeExceedsLimit";
+/**
+ * This is a helper to dynamically calculate the chunk size for a given file size.
+ *
+ * @param fileSize The size of a file to calculate the chunk size for.
+ * @returns A number of bytes per chunk or Throws an Error if the file size exceeds 2TB
+ *
+ * @see {@link https://product-fabric.atlassian.net/wiki/spaces/FIL/pages/3221881143/Rule+of+thumb+for+chunk+sizes#Given-the-following-conditions}
+ *
+ */
+export declare const calculateChunkSize: (fileSize: number) => number;

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

@@ -0,0 +1,29 @@
+import { BaseMediaClientError } from '../models/errors';
+export type UploaderErrorReason = 'fileSizeExceedsLimit';
+export type UploaderErrorAttributes = {
+    readonly reason: UploaderErrorReason;
+    readonly id: string;
+    readonly metadata?: {
+        readonly collectionName?: string;
+        readonly occurrenceKey?: string;
+    };
+};
+export declare class UploaderError extends BaseMediaClientError<UploaderErrorAttributes> {
+    readonly reason: UploaderErrorReason;
+    readonly id: string;
+    readonly metadata?: {
+        readonly collectionName?: string | undefined;
+        readonly occurrenceKey?: string | undefined;
+    } | undefined;
+    constructor(reason: UploaderErrorReason, id: string, metadata?: {
+        readonly collectionName?: string | undefined;
+        readonly occurrenceKey?: string | undefined;
+    } | undefined);
+    get attributes(): {
+        reason: "fileSizeExceedsLimit";
+        id: string;
+        collectionName: string | undefined;
+        occurrenceKey: string | undefined;
+    };
+}
+export declare function isUploaderError(err: Error): err is UploaderError;

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

@@ -0,0 +1,23 @@
+import { ChunkinatorFile } from '@atlaskit/chunkinator';
+import { MediaStore } from '../client/media-store';
+import { MediaTraceContext } from '@atlaskit/media-common';
+export type UploadableFile = {
+    content: ChunkinatorFile;
+    name?: string;
+    mimeType?: string;
+    collection?: string;
+    size?: number;
+};
+export type UploadableFileUpfrontIds = {
+    id: string;
+    deferredUploadId: Promise<string>;
+    occurrenceKey?: string;
+};
+export type UploadFileCallbacks = {
+    onProgress: (progress: number) => void;
+    onUploadFinish: (error?: any) => void;
+};
+export interface UploadFileResult {
+    cancel: () => void;
+}
+export declare const uploadFile: (file: UploadableFile, store: MediaStore, uploadableFileUpfrontIds: UploadableFileUpfrontIds, callbacks?: UploadFileCallbacks, traceContext?: MediaTraceContext) => UploadFileResult;

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

@@ -0,0 +1 @@
+export declare const checkWebpSupport: () => Promise<boolean>;

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

@@ -0,0 +1 @@
+export declare const convertBase64ToBlob: (base64: string) => Blob;

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

@@ -0,0 +1,30 @@
+import 'setimmediate';
+import Dataloader from 'dataloader';
+import { MediaStore, ResponseFileItem } from '../client/media-store';
+import { MediaItemDetails } from '../models/media';
+export declare const MAX_BATCH_SIZE = 100;
+export type DataloaderKey = {
+    readonly id: string;
+    readonly collectionName?: string;
+};
+export type DataloaderResult = MediaItemDetails | null;
+export type BatchLoadingErrorResult = {
+    readonly id: string;
+    readonly collection?: string;
+    readonly error: Error;
+};
+export declare const getItemsFromKeys: (dataloaderKeys: ReadonlyArray<DataloaderKey>, fileItems: Array<ResponseFileItem | BatchLoadingErrorResult>) => Array<DataloaderResult | Error>;
+export type FileIdsByCollection = {
+    [collectionName: string]: string[];
+};
+/**
+ * Returns a function that, given Array<DataloaderKey>, resolves to an array of same length containing either DataloaderResult or Error.
+ * Such contract is formalised by Dataloader 1.0, @see https://github.com/graphql/dataloader
+ *
+ * If an Error is resolved in the results, it must be at same position then their corresponding key:
+ * - Dataloader will re-throw that Error when accessing/loading that particular key
+ *
+ * @param mediaStore instance of MediaStore
+ */
+export declare function createBatchLoadingFunc(mediaStore: MediaStore): (keys: ReadonlyArray<DataloaderKey>) => Promise<Array<DataloaderResult | Error>>;
+export declare function createFileDataloader(mediaStore: MediaStore): Dataloader<DataloaderKey, DataloaderResult, DataloaderKey>;

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

@@ -0,0 +1,3 @@
+import { ReplaySubject } from 'rxjs/ReplaySubject';
+import { FileState } from '@atlaskit/media-state';
+export declare function createMediaSubject<T extends FileState>(initialState?: T | Error): ReplaySubject<T>;

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

@@ -0,0 +1,16 @@
+import { MediaItemDetails } from '../models/media';
+/**
+ * EMPTY_FILE_HOURS_ELAPSED_TOLERANCE - how many hours since this file was
+ * created until we give up on expecting metadata?
+ *
+ * Yes, this is not an exact science. Any value under this tolerance will
+ * go undetected, however this is still suitable to catch the majority of
+ * cases where empty (files which never finished upload) are being reloaded.
+ *
+ * Continuous bad renders of empty files will eat our card render SLIs, so until
+ * there is a better response from backend we use this technique.
+ *
+ * Being encapsulated in this function, we can always improve the detection transparently.
+ */
+export declare const EMPTY_FILE_HOURS_ELAPSED_TOLERANCE_MS: number;
+export declare function isEmptyFile(fileDetails: MediaItemDetails, now?: number): Boolean;

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

@@ -0,0 +1,6 @@
+import { MediaType } from '@atlaskit/media-common';
+export type Dimensions = {
+    width: number;
+    height: number;
+};
+export declare const getDimensionsFromBlob: (mediaType: MediaType, blob: Blob) => Promise<Dimensions>;

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

@@ -0,0 +1,5 @@
+export type Dimensions = {
+    width: number;
+    height: number;
+};
+export declare const getImageDimensionsFromBlob: (url: string) => Promise<Dimensions>;

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

@@ -0,0 +1,3 @@
+import { MediaType } from '../models/media';
+import { UploadableFile } from '../uploader';
+export declare const getMediaTypeFromUploadableFile: (file: UploadableFile) => MediaType;

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

@@ -0,0 +1,5 @@
+export interface Dimensions {
+    width: number;
+    height: number;
+}
+export declare const getVideoDimensionsFromBlob: (blob: Blob) => Promise<Dimensions>;

package/dist/types-ts4.5/utils/hashing/hasher.d.ts

@@ -0,0 +1,3 @@
+export interface Hasher {
+    hash(blob: Blob): Promise<string>;
+}

package/dist/types-ts4.5/utils/hashing/hasherCreator.d.ts

@@ -0,0 +1,3 @@
+import { Hasher } from './hasher';
+export declare const destroyHasher: () => null;
+export declare const createHasher: () => Promise<Hasher>;

package/dist/types-ts4.5/utils/hashing/simpleHasher.d.ts

@@ -0,0 +1,4 @@
+import { Hasher } from './hasher';
+export declare class SimpleHasher implements Hasher {
+    hash(blob: Blob): Promise<string>;
+}

package/dist/types-ts4.5/utils/hashing/workerHasher.d.ts

@@ -0,0 +1,16 @@
+import { Hasher } from './hasher';
+export interface Deferred {
+    resolve: (hash: string) => void;
+    reject: (error: any) => void;
+}
+export declare class WorkerHasher implements Hasher {
+    private workers;
+    private jobs;
+    constructor(numOfWorkers: number);
+    hash(chunk: Blob): Promise<string>;
+    private createWorker;
+    private handleWorkerMessage;
+    private calculateHashInWorker;
+    private dispatch;
+    private getMostRelaxedWorker;
+}

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

@@ -0,0 +1,3 @@
+import { MediaStoreGetFileImageParams } from '../client/media-store';
+export type ImageResizeMode = 'crop' | 'fit' | 'full-fit' | 'stretchy-fit';
+export declare const imageResizeModeToFileImageMode: (resizeMode?: ImageResizeMode) => MediaStoreGetFileImageParams['mode'];

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

@@ -0,0 +1 @@
+export declare const isImageRemote: (imageUrl: string, windowOrigin?: string) => boolean;

package/dist/types-ts4.5/utils/mediaSubscribable/fromObservable.d.ts

@@ -0,0 +1,5 @@
+import { ReplaySubject } from 'rxjs/ReplaySubject';
+import { FileState } from '@atlaskit/media-state';
+import { MediaSubscribable } from './types';
+export declare function fromObservable(observable: ReplaySubject<FileState>): MediaSubscribable;
+export declare function createMediaSubscribable(item?: FileState | Error): MediaSubscribable;

package/dist/types-ts4.5/utils/mediaSubscribable/index.d.ts

@@ -0,0 +1,3 @@
+export type { MediaSubscribable, MediaObserver, MediaSubscription, } from './types';
+export { toPromise } from './toPromise';
+export { createMediaSubscribable, fromObservable } from './fromObservable';