@atlaskit/media-client 17.1.2 → 18.0.0

package/dist/types-ts4.0/client/media-store/index.d.ts

@@ -0,0 +1,167 @@
+import { AsapBasedAuth, AuthContext, ClientAltBasedAuth, MediaApiConfig, Auth } from '@atlaskit/media-core';
+import { MediaFeatureFlags } from '@atlaskit/media-common';
+import { MediaFileArtifacts } from '../../models/artifacts';
+import { MediaChunksProbe, MediaCollectionItemFullDetails, MediaCollectionItems, MediaFile, MediaUpload } from '../../models/media';
+import { ClientOptions, RequestHeaders, RequestMethod, RequestParams, RequestMetadata } from '../../utils/request/types';
+export type { MediaStoreErrorReason, MediaStoreErrorAttributes } from './error';
+export { MediaStoreError, isMediaStoreError } from './error';
+export declare class MediaStore {
+    private readonly config;
+    readonly featureFlags?: MediaFeatureFlags | undefined;
+    constructor(config: MediaApiConfig, featureFlags?: MediaFeatureFlags | undefined);
+    getCollectionItems(collectionName: string, params?: MediaStoreGetCollectionItemsParams): Promise<MediaStoreResponse<MediaCollectionItems>>;
+    removeCollectionFile(id: string, collectionName: string, occurrenceKey?: string): Promise<void>;
+    createUpload(createUpTo?: number, collectionName?: string): Promise<MediaStoreResponse<MediaUpload[]>>;
+    uploadChunk(etag: string, blob: Blob, { collectionName, uploadId, partNumber, }?: {
+        collectionName?: string;
+        uploadId?: string;
+        partNumber?: number;
+    }): Promise<void>;
+    probeChunks(chunks: string[], { collectionName, uploadId, }?: {
+        collectionName?: string;
+        uploadId?: string;
+    }): Promise<MediaStoreResponse<MediaChunksProbe>>;
+    createFileFromUpload(body: MediaStoreCreateFileFromUploadBody, params?: MediaStoreCreateFileFromUploadParams): Promise<MediaStoreResponse<MediaFile>>;
+    touchFiles(body: MediaStoreTouchFileBody, params?: MediaStoreTouchFileParams): Promise<MediaStoreResponse<TouchedFiles>>;
+    getFile(fileId: string, params?: MediaStoreGetFileParams): Promise<MediaStoreResponse<MediaFile>>;
+    getFileImageURL(id: string, params?: MediaStoreGetFileImageParams): Promise<string>;
+    getFileImageURLSync(id: string, params?: MediaStoreGetFileImageParams): string;
+    private createFileImageURL;
+    getFileBinaryURL(id: string, collectionName?: string): Promise<string>;
+    getArtifactURL(artifacts: MediaFileArtifacts, artifactName: keyof MediaFileArtifacts, collectionName?: string): Promise<string>;
+    getImage(id: string, params?: MediaStoreGetFileImageParams, controller?: AbortController, fetchMaxRes?: boolean): Promise<Blob>;
+    getItems(ids: string[], collectionName?: string): Promise<MediaStoreResponse<ItemsPayload>>;
+    getImageMetadata(id: string, params?: MediaStoreGetFileImageParams): Promise<{
+        metadata: ImageMetadata;
+    }>;
+    appendChunksToUpload(uploadId: string, body: AppendChunksToUploadRequestBody, collectionName?: string): Promise<void>;
+    copyFileWithToken(body: MediaStoreCopyFileWithTokenBody, params: MediaStoreCopyFileWithTokenParams): Promise<MediaStoreResponse<MediaFile>>;
+    request(path: string, options?: MediaStoreRequestOptions, controller?: AbortController): Promise<Response>;
+    resolveAuth: (authContext?: AuthContext | undefined) => Promise<Auth>;
+    resolveInitialAuth: () => Auth;
+}
+export declare const getMediaEnvironment: () => string | undefined;
+export declare const getMediaRegion: () => string | undefined;
+export interface ResponseFileItem {
+    id: string;
+    type: 'file';
+    details: MediaCollectionItemFullDetails;
+    collection?: string;
+}
+export interface ItemsPayload {
+    items: ResponseFileItem[];
+}
+export declare type ImageMetadataArtifact = {
+    url?: string;
+    width?: number;
+    height?: number;
+    size?: number;
+};
+export interface ImageMetadata {
+    pending: boolean;
+    preview?: ImageMetadataArtifact;
+    original?: ImageMetadataArtifact;
+}
+export interface MediaStoreResponse<Data> {
+    readonly data: Data;
+}
+export declare type MediaStoreRequestOptions = RequestMetadata & {
+    readonly method?: RequestMethod;
+    readonly authContext?: AuthContext;
+    readonly params?: RequestParams;
+    readonly headers?: RequestHeaders;
+    readonly body?: any;
+    readonly clientOptions?: ClientOptions;
+};
+export declare type MediaStoreCreateFileFromUploadParams = {
+    readonly collection?: string;
+    readonly occurrenceKey?: string;
+    readonly expireAfter?: number;
+    readonly replaceFileId?: string;
+    readonly skipConversions?: boolean;
+};
+export declare type MediaStoreCreateFileParams = {
+    readonly occurrenceKey?: string;
+    readonly collection?: string;
+};
+export interface MediaStoreTouchFileParams {
+    readonly collection?: string;
+}
+export interface TouchFileDescriptor {
+    fileId: string;
+    collection?: string;
+    occurrenceKey?: string;
+    expireAfter?: number;
+    deletable?: boolean;
+}
+export interface MediaStoreTouchFileBody {
+    descriptors: TouchFileDescriptor[];
+}
+export declare type MediaStoreCreateFileFromBinaryParams = {
+    readonly replaceFileId?: string;
+    readonly collection?: string;
+    readonly occurrenceKey?: string;
+    readonly expireAfter?: number;
+    readonly skipConversions?: boolean;
+    readonly name?: string;
+};
+export declare type MediaStoreCreateFileFromUploadConditions = {
+    readonly hash: string;
+    readonly size: number;
+};
+export declare type MediaStoreCreateFileFromUploadBody = {
+    readonly uploadId: string;
+    readonly name?: string;
+    readonly mimeType?: string;
+    readonly conditions?: MediaStoreCreateFileFromUploadConditions;
+};
+export declare type MediaStoreGetFileParams = {
+    readonly version?: number;
+    readonly collection?: string;
+};
+export declare type MediaStoreGetFileImageParams = {
+    readonly allowAnimated?: boolean;
+    readonly version?: number;
+    readonly collection?: string;
+    readonly width?: number;
+    readonly height?: number;
+    readonly mode?: 'fit' | 'full-fit' | 'crop';
+    readonly upscale?: boolean;
+    readonly 'max-age'?: number;
+};
+export declare type MediaStoreGetCollectionItemsParams = {
+    readonly limit?: number;
+    readonly inclusiveStartKey?: string;
+    readonly sortDirection?: 'asc' | 'desc';
+    readonly details?: 'minimal' | 'full';
+};
+export interface SourceFile {
+    id: string;
+    owner: ClientAltBasedAuth | AsapBasedAuth;
+    collection?: string;
+    version?: number;
+}
+export declare type MediaStoreCopyFileWithTokenBody = {
+    sourceFile: SourceFile;
+};
+export declare type MediaStoreCopyFileWithTokenParams = {
+    readonly collection?: string;
+    readonly replaceFileId?: string;
+    readonly occurrenceKey?: string;
+};
+export declare type AppendChunksToUploadRequestBody = {
+    readonly chunks: string[];
+    readonly hash?: string;
+    readonly offset?: number;
+};
+export interface CreatedTouchedFile {
+    fileId: string;
+    uploadId: string;
+}
+export declare type TouchedFiles = {
+    created: CreatedTouchedFile[];
+};
+export interface EmptyFile {
+    readonly id: string;
+    readonly createdAt: number;
+}

package/dist/types-ts4.0/client/media-store/resolveAuth.d.ts

@@ -0,0 +1,4 @@
+import { Auth, AuthContext, AuthProvider } from '@atlaskit/media-core';
+export declare const DEFAULT_AUTH_PROVIDER_TIMEOUT = 10000;
+export declare const resolveAuth: (authProvider: AuthProvider, authContext?: AuthContext | undefined, authProviderTimeout?: number) => Promise<Auth>;
+export declare const resolveInitialAuth: (auth?: Auth | undefined) => Auth;

package/dist/types-ts4.0/client/mobile-upload.d.ts

@@ -0,0 +1,11 @@
+import { MobileUpload, MobileUploadStartEvent, MobileUploadProgressEvent, MobileUploadEndEvent, MobileUploadErrorEvent } from '../models/mobile-upload';
+import { MediaStore } from './media-store';
+export declare class MobileUploadImpl implements MobileUpload {
+    private readonly dataloader;
+    private readonly servicesCache;
+    constructor(mediaStore: MediaStore);
+    notifyUploadStart(event: MobileUploadStartEvent): void;
+    notifyUploadProgress(event: MobileUploadProgressEvent): void;
+    notifyUploadEnd(event: MobileUploadEndEvent): void;
+    notifyUploadError(event: MobileUploadErrorEvent): void;
+}

package/dist/types-ts4.0/client/stargate-client.d.ts

@@ -0,0 +1,15 @@
+export interface EdgeData {
+    data: {
+        clientId: string;
+        token: string;
+        baseUrl: string;
+        expiresIn: number;
+        iat: number;
+    };
+}
+export declare class StargateClient {
+    private baseUrl;
+    constructor(baseUrl: string | undefined);
+    fetchToken(clientId: string): Promise<EdgeData>;
+    isTokenExpired(token: EdgeData): boolean;
+}

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

@@ -0,0 +1,6 @@
+export declare const RECENTS_COLLECTION = "recents";
+export declare const FILE_CACHE_MAX_AGE: number;
+export declare const MAX_RESOLUTION = 4096;
+export declare const CHUNK_SIZE: number;
+export declare const PROCESSING_BATCH_SIZE = 1000;
+export declare const MAX_UPLOAD_FILE_SIZE: number;

package/dist/types-ts4.0/file-streams-cache.d.ts

@@ -0,0 +1,15 @@
+import { LRUMap } from 'lru_map';
+import { ReplaySubject } from 'rxjs/ReplaySubject';
+import { FileState } from './models/file-state';
+export declare class StreamsCache<T> {
+    private readonly streams;
+    constructor(streams: LRUMap<string, ReplaySubject<T>>);
+    has(id: string): boolean;
+    set(id: string, stream: ReplaySubject<T>): void;
+    get(id: string): ReplaySubject<T> | undefined;
+    getOrInsert(id: string, callback: () => ReplaySubject<T>): ReplaySubject<T>;
+    removeAll(): void;
+    remove(id: string): void;
+    get size(): number;
+}
+export declare const getFileStreamsCache: () => StreamsCache<FileState>;

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

@@ -0,0 +1,6 @@
+import { UploadEventPayloadMap, EventPayloadListener } from './client/events';
+export declare const globalMediaEventEmitter: {
+    on<E extends keyof UploadEventPayloadMap>(event: E, listener: EventPayloadListener<UploadEventPayloadMap, E, any>): void;
+    off<E_1 extends keyof UploadEventPayloadMap>(event: E_1, listener: EventPayloadListener<UploadEventPayloadMap, E_1, any>): void;
+    emit<E_2 extends keyof UploadEventPayloadMap>(event: E_2, payload: UploadEventPayloadMap[E_2]): boolean | undefined;
+};

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

@@ -0,0 +1,15 @@
+export declare type Identifier = FileIdentifier | ExternalImageIdentifier;
+export interface FileIdentifier {
+    readonly mediaItemType: 'file';
+    readonly id: string;
+    readonly occurrenceKey?: string;
+    readonly collectionName?: string;
+}
+export interface ExternalImageIdentifier {
+    readonly mediaItemType: 'external-image';
+    readonly dataURI: string;
+    readonly name?: string;
+}
+export declare const isFileIdentifier: (identifier: Identifier) => identifier is FileIdentifier;
+export declare const isExternalImageIdentifier: (identifier: Identifier) => identifier is ExternalImageIdentifier;
+export declare const isDifferentIdentifier: (a: Identifier, b: Identifier) => boolean;

package/dist/types-ts4.0/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, MediaStoreGetCollectionItemsParams, 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, isMediaCollectionItemFullDetails, } from './models/media';
+export type { MediaFileProcessingStatus, MediaType, MediaFile, MediaCollection, MediaCollectionItems, MediaCollectionItem, MediaCollectionItemMinimalDetails, MediaCollectionItemFullDetails, MediaRepresentations, MediaCollectionItemDetails, MediaUpload, MediaChunksProbe, } from './models/media';
+export type { MediaSubscribableItem } from './models/media-subscribable';
+export { getArtifactUrl } from './models/artifacts';
+export type { MediaFileArtifact, MediaFileArtifacts } 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, FilePreview, PreviewOptions, GetFileOptions, UploadingFileState, ProcessingFileState, ProcessedFileState, ProcessingFailedState, ErrorFileState, NonErrorFileState, PreviewableFileState, FileState, } from './models/file-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, } 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 { CollectionFetcher } from './client/collection-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 { globalMediaEventEmitter } from './globalMediaEventEmitter';
+export { isMediaBlobUrl, getAttrsFromUrl, addFileAttrsToUrl, objectToQueryString, } from './utils/url';
+export type { MediaBlobUrlAttrs } from './utils/url';
+export { createMediaSubscribable } from './utils/mediaSubscribable';
+export type { MediaSubscribable, MediaSubscription, MediaObserver, } from './utils/mediaSubscribable';
+export { RECENTS_COLLECTION, MAX_RESOLUTION } from './constants';
+/**
+ * @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.0/models/artifacts.d.ts

@@ -0,0 +1,12 @@
+import type { MediaFileProcessingStatus } from './media';
+export declare type MediaFileArtifact = {
+    readonly url: string;
+    readonly processingStatus: MediaFileProcessingStatus;
+};
+export interface MediaFileArtifacts {
+    'video_1280.mp4'?: MediaFileArtifact;
+    'video_640.mp4'?: MediaFileArtifact;
+    'document.pdf'?: MediaFileArtifact;
+    'audio.mp3'?: MediaFileArtifact;
+}
+export declare const getArtifactUrl: (artifacts: MediaFileArtifacts, prop: keyof MediaFileArtifacts) => string | undefined;

package/dist/types-ts4.0/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 declare type AuthHeaders = ClientBasedAuthHeaders | AsapBasedAuthHeaders;
+export declare function mapAuthToAuthHeaders(auth: Auth): AuthHeaders;

package/dist/types-ts4.0/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 declare type AuthQueryParameters = ClientBasedQueryParameters | AsapBasedQueryParameters;
+export declare function mapAuthToQueryParameters(auth: Auth): AuthQueryParameters;

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

@@ -0,0 +1,15 @@
+export declare type MediaClientErrorReason = 'clientOffline' | 'clientAbortedRequest' | 'clientTimeoutRequest' | 'serverInvalidBody' | 'serverBadRequest' | 'serverUnauthorized' | 'serverForbidden' | 'serverNotFound' | 'serverRateLimited' | 'serverInternalError' | 'serverBadGateway' | 'serverUnexpectedError' | 'failedAuthProvider' | 'tokenExpired' | 'missingInitialAuth' | 'emptyAuth' | 'authProviderTimedOut' | 'invalidFileId' | 'emptyItems' | 'zeroVersionFile' | 'pollingMaxAttemptsExceeded' | 'fileSizeExceedsLimit';
+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.0/models/file-state.d.ts

@@ -0,0 +1,91 @@
+import { FileStatus as CommonFileStatus } from '@atlaskit/media-common';
+import { MediaStoreResponse } from '../client/media-store';
+import { MediaFileArtifacts } from './artifacts';
+import { MediaCollectionItemFullDetails, MediaFile, MediaRepresentations, MediaType } from './media';
+export declare type FileStatus = CommonFileStatus;
+export interface FilePreview {
+    value: Blob | string;
+    origin?: 'local' | 'remote';
+    originalDimensions?: {
+        width: number;
+        height: number;
+    };
+}
+export interface PreviewOptions {
+}
+export interface GetFileOptions {
+    preview?: PreviewOptions;
+    collectionName?: string;
+    occurrenceKey?: string;
+}
+export interface UploadingFileState {
+    status: 'uploading';
+    id: string;
+    occurrenceKey?: string;
+    name: string;
+    size: number;
+    progress: number;
+    mediaType: MediaType;
+    mimeType: string;
+    preview?: FilePreview | Promise<FilePreview>;
+    createdAt?: number;
+}
+export interface PreviewableFileState {
+    preview: FilePreview | Promise<FilePreview>;
+}
+export interface ProcessingFileState {
+    status: 'processing';
+    id: string;
+    occurrenceKey?: string;
+    name: string;
+    size: number;
+    artifacts?: MediaFileArtifacts;
+    mediaType: MediaType;
+    mimeType: string;
+    preview?: FilePreview | Promise<FilePreview>;
+    representations?: MediaRepresentations;
+    createdAt?: number;
+}
+export interface ProcessedFileState {
+    status: 'processed';
+    id: string;
+    occurrenceKey?: string;
+    name: string;
+    size: number;
+    artifacts: MediaFileArtifacts;
+    mediaType: MediaType;
+    mimeType: string;
+    preview?: FilePreview | Promise<FilePreview>;
+    representations?: MediaRepresentations;
+    createdAt?: number;
+}
+export interface ProcessingFailedState {
+    status: 'failed-processing';
+    id: string;
+    occurrenceKey?: string;
+    name: string;
+    size: number;
+    artifacts: Object;
+    mediaType: MediaType;
+    mimeType: string;
+    preview?: FilePreview | Promise<FilePreview>;
+    representations?: MediaRepresentations;
+    createdAt?: number;
+}
+export interface ErrorFileState {
+    status: 'error';
+    id: string;
+    occurrenceKey?: string;
+    message?: string;
+}
+export declare type FileState = UploadingFileState | ProcessingFileState | ProcessedFileState | ErrorFileState | ProcessingFailedState;
+export declare 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 | ProcessingFailedState | ErrorFileState;
+export declare const isImageRepresentationReady: (fileState: FileState) => boolean;
+export declare const mapMediaFileToFileState: (mediaFile: MediaStoreResponse<MediaFile>) => FileState;
+export declare const mapMediaItemToFileState: (id: string, item: MediaCollectionItemFullDetails) => FileState;

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

@@ -0,0 +1,25 @@
+import { MediaType } from './media';
+export declare type MediaItemType = 'file' | 'external-image';
+export interface FileItem {
+    type: 'file';
+    details: FileDetails;
+}
+export declare type FileProcessingStatus = 'pending' | 'running' | 'succeeded' | 'failed';
+export interface MediaArtifact {
+    processingStatus?: FileProcessingStatus;
+    url?: string;
+}
+export declare 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.0/models/media-subscribable.d.ts

@@ -0,0 +1,3 @@
+import { FileState } from './file-state';
+import { MediaCollectionItem } from './media';
+export declare type MediaSubscribableItem = FileState | MediaCollectionItem[];

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

@@ -0,0 +1,66 @@
+import { MediaFeatureFlags, MediaType } from '@atlaskit/media-common';
+import type { MediaFileArtifacts } from './artifacts';
+export declare type MediaFileProcessingStatus = 'pending' | 'succeeded' | 'failed';
+export type { MediaType } from '@atlaskit/media-common';
+export declare const isPreviewableType: (type: MediaType, featureFlags?: MediaFeatureFlags | undefined) => boolean;
+export declare 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;
+};
+export declare type MediaCollection = {
+    readonly name: string;
+    readonly createdAt: number;
+};
+export declare type MediaCollectionItems = {
+    readonly contents: MediaCollectionItem[];
+    readonly nextInclusiveStartKey?: string;
+};
+export declare type MediaCollectionItem = {
+    readonly id: string;
+    readonly insertedAt: number;
+    readonly occurrenceKey: string;
+    readonly details: MediaCollectionItemDetails;
+};
+export declare type MediaCollectionItemMinimalDetails = {
+    readonly name: string;
+    readonly size: number;
+};
+export declare type MediaCollectionItemFullDetails = {
+    readonly mediaType: MediaType;
+    readonly mimeType: string;
+    readonly name: string;
+    readonly processingStatus: MediaFileProcessingStatus;
+    readonly size: number;
+    readonly artifacts: MediaFileArtifacts;
+    readonly representations: MediaRepresentations;
+    readonly createdAt?: number;
+};
+export declare type MediaRepresentations = {
+    image?: Object;
+};
+export declare type MediaCollectionItemDetails = MediaCollectionItemMinimalDetails | MediaCollectionItemFullDetails;
+export declare const isMediaCollectionItemFullDetails: (mediaCollectionItem: MediaCollectionItemDetails) => mediaCollectionItem is MediaCollectionItemFullDetails;
+export declare type MediaUpload = {
+    readonly id: string;
+    readonly created: number;
+    readonly expires: number;
+};
+export declare 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.0/models/mobile-upload.d.ts

@@ -0,0 +1,28 @@
+import { FilePreview } from './file-state';
+export declare type MobileUploadStartEvent = {
+    fileId: string;
+    collectionName?: string;
+    occurrenceKey?: string;
+    fileName: string;
+    fileSize: number;
+    fileMimetype: string;
+    preview?: FilePreview;
+    createdAt?: number;
+};
+export declare type MobileUploadProgressEvent = {
+    fileId: string;
+    progress: number;
+};
+export declare type MobileUploadEndEvent = {
+    fileId: string;
+};
+export declare 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.0/upload-controller.d.ts

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

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