@atlaskit/media-client 24.0.1 → 24.0.3

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @atlaskit/media-client
 
+## 24.0.3
+
+### Patch Changes
+
+- [#41932](https://bitbucket.org/atlassian/atlassian-frontend/pull-requests/41932) [`756dd90f1a3`](https://bitbucket.org/atlassian/atlassian-frontend/commits/756dd90f1a3) - 1. Deprecate withMediaClient HOC in media-client and migrated it to media-client-react 2. clean up deprecated imports from media-client
+
+## 24.0.2
+
+### Patch Changes
+
+- [#41501](https://bitbucket.org/atlassian/atlassian-frontend/pull-requests/41501) [`b3cb749dc67`](https://bitbucket.org/atlassian/atlassian-frontend/commits/b3cb749dc67) - Fix TS errors in AFM
+
 ## 24.0.1
 
 ### Patch Changes

package/dist/cjs/utils/with-media-client-hoc.js

@@ -17,7 +17,19 @@ var _mediaClient = require("../client/media-client");
 var _excluded = ["mediaClientConfig"];
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+/**
+ * @deprecated This export will be removed. Please use one from `@atlaskit/media-client-react`
+ */
+
+/**
+ * @deprecated This export will be removed. Please use one from `@atlaskit/media-client-react`
+ */
+
 var mediaClientsMap = new Map();
+
+/**
+ * @deprecated This export will be removed. Please use one from `@atlaskit/media-client-react`
+ */
 var getMediaClient = exports.getMediaClient = function getMediaClient(mediaClientConfig) {
   var mediaClient = mediaClientsMap.get(mediaClientConfig);
   if (!mediaClient) {
@@ -38,6 +50,18 @@ var createEmptyMediaClient = function createEmptyMediaClient() {
   };
   return new _mediaClient.MediaClient(emptyConfig);
 };
+
+/**
+ * @deprecated This export will be removed. Please use one from `@atlaskit/media-client-react`
+ */
+
+/**
+ * @deprecated This export will be removed. Please use one from `@atlaskit/media-client-react`
+ */
+
+/**
+ * @deprecated This export will be removed. Please use one from `@atlaskit/media-client-react`
+ */
 var withMediaClient = exports.withMediaClient = function withMediaClient(Component) {
   return /*#__PURE__*/function (_React$Component) {
     (0, _inherits2.default)(_class, _React$Component);

package/dist/es2019/utils/with-media-client-hoc.js

@@ -1,7 +1,20 @@
 import _extends from "@babel/runtime/helpers/extends";
 import React from 'react';
 import { MediaClient } from '../client/media-client';
+
+/**
+ * @deprecated This export will be removed. Please use one from `@atlaskit/media-client-react`
+ */
+
+/**
+ * @deprecated This export will be removed. Please use one from `@atlaskit/media-client-react`
+ */
+
 const mediaClientsMap = new Map();
+
+/**
+ * @deprecated This export will be removed. Please use one from `@atlaskit/media-client-react`
+ */
 export const getMediaClient = mediaClientConfig => {
   let mediaClient = mediaClientsMap.get(mediaClientConfig);
   if (!mediaClient) {
@@ -20,6 +33,18 @@ const createEmptyMediaClient = () => {
   };
   return new MediaClient(emptyConfig);
 };
+
+/**
+ * @deprecated This export will be removed. Please use one from `@atlaskit/media-client-react`
+ */
+
+/**
+ * @deprecated This export will be removed. Please use one from `@atlaskit/media-client-react`
+ */
+
+/**
+ * @deprecated This export will be removed. Please use one from `@atlaskit/media-client-react`
+ */
 export const withMediaClient = Component => {
   return class extends React.Component {
     render() {

package/dist/esm/utils/with-media-client-hoc.js

@@ -10,7 +10,20 @@ function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflec
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 import React from 'react';
 import { MediaClient } from '../client/media-client';
+
+/**
+ * @deprecated This export will be removed. Please use one from `@atlaskit/media-client-react`
+ */
+
+/**
+ * @deprecated This export will be removed. Please use one from `@atlaskit/media-client-react`
+ */
+
 var mediaClientsMap = new Map();
+
+/**
+ * @deprecated This export will be removed. Please use one from `@atlaskit/media-client-react`
+ */
 export var getMediaClient = function getMediaClient(mediaClientConfig) {
   var mediaClient = mediaClientsMap.get(mediaClientConfig);
   if (!mediaClient) {
@@ -31,6 +44,18 @@ var createEmptyMediaClient = function createEmptyMediaClient() {
   };
   return new MediaClient(emptyConfig);
 };
+
+/**
+ * @deprecated This export will be removed. Please use one from `@atlaskit/media-client-react`
+ */
+
+/**
+ * @deprecated This export will be removed. Please use one from `@atlaskit/media-client-react`
+ */
+
+/**
+ * @deprecated This export will be removed. Please use one from `@atlaskit/media-client-react`
+ */
 export var withMediaClient = function withMediaClient(Component) {
   return /*#__PURE__*/function (_React$Component) {
     _inherits(_class, _React$Component);

package/dist/types/utils/with-media-client-hoc.d.ts

@@ -2,14 +2,32 @@ import React from 'react';
 import { MediaClientConfig } from '@atlaskit/media-core';
 import { MediaClient } from '../client/media-client';
 import { Identifier } from '../identifier';
+/**
+ * @deprecated This export will be removed. Please use one from `@atlaskit/media-client-react`
+ */
 export interface WithMediaClientConfig {
     mediaClientConfig: MediaClientConfig;
 }
+/**
+ * @deprecated This export will be removed. Please use one from `@atlaskit/media-client-react`
+ */
 export interface WithMediaClient {
     mediaClient: MediaClient;
     identifier?: Identifier;
 }
+/**
+ * @deprecated This export will be removed. Please use one from `@atlaskit/media-client-react`
+ */
 export declare const getMediaClient: (mediaClientConfig: MediaClientConfig) => MediaClient;
+/**
+ * @deprecated This export will be removed. Please use one from `@atlaskit/media-client-react`
+ */
 export type WithMediaClientConfigProps<P extends WithMediaClient> = Omit<P, 'mediaClient'> & WithMediaClientConfig;
+/**
+ * @deprecated This export will be removed. Please use one from `@atlaskit/media-client-react`
+ */
 export type WithMediaClientFunction = <P extends WithMediaClient>(Component: React.ComponentType<P>) => React.ComponentType<WithMediaClientConfigProps<P>>;
+/**
+ * @deprecated This export will be removed. Please use one from `@atlaskit/media-client-react`
+ */
 export declare const withMediaClient: WithMediaClientFunction;

package/dist/types-ts4.5/client/__mocks__/collection-fetcher.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+export declare const collectionCache: {};
+export declare class CollectionFetcher {
+    constructor();
+    getItems: jest.Mock<any, any>;
+    removeFile: jest.Mock<any, any>;
+    loadNextPage: jest.Mock<any, any>;
+}

package/dist/types-ts4.5/client/__mocks__/file-fetcher.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="jest" />
+export declare class FileFetcher {
+    constructor();
+    getFileState: jest.Mock<any, any>;
+    getCurrentState: jest.Mock<any, any>;
+    getArtifactURL: jest.Mock<any, any>;
+    touchFiles: jest.Mock<any, any>;
+    upload: jest.Mock<any, any>;
+    downloadBinary: jest.Mock<any, any>;
+}

package/dist/types-ts4.5/client/__mocks__/media-client.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="jest" />
+import { MediaClientConfig } from '@atlaskit/media-core';
+import { FileFetcher } from '../file-fetcher';
+export declare class MediaClient {
+    readonly config: MediaClientConfig;
+    readonly file: FileFetcher;
+    constructor(config: MediaClientConfig);
+    getImage: jest.Mock<any, any>;
+    getImageUrl: jest.Mock<any, any>;
+    getImageMetadata: jest.Mock<any, any>;
+}

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

@@ -0,0 +1,14 @@
+import { FileState } from '@atlaskit/media-state';
+export type EventPayloadMap<P> = {
+    readonly [event: string]: P;
+};
+export type EventPayloadListener<M extends EventPayloadMap<P>, E extends keyof M, P = any> = (payload: M[E]) => void;
+export interface MediaViewedEventPayload {
+    fileId: string;
+    viewingLevel: 'minimal' | 'full' | 'download';
+    isUserCollection?: boolean;
+}
+export type UploadEventPayloadMap = {
+    'file-added': FileState;
+    'media-viewed': MediaViewedEventPayload;
+};

package/dist/types-ts4.5/client/file-fetcher/error.d.ts

@@ -0,0 +1,29 @@
+import { BaseMediaClientError } from '../../models/errors';
+export type FileFetcherErrorReason = 'invalidFileId' | 'emptyItems' | 'zeroVersionFile' | 'emptyFileName';
+export type FileFetcherErrorAttributes = {
+    readonly reason: FileFetcherErrorReason;
+    readonly id: string;
+    readonly metadata?: {
+        readonly collectionName?: string;
+        readonly occurrenceKey?: string;
+    };
+};
+export declare class FileFetcherError extends BaseMediaClientError<FileFetcherErrorAttributes> {
+    readonly reason: FileFetcherErrorReason;
+    readonly id: string;
+    readonly metadata?: {
+        readonly collectionName?: string | undefined;
+        readonly occurrenceKey?: string | undefined;
+    } | undefined;
+    constructor(reason: FileFetcherErrorReason, id: string, metadata?: {
+        readonly collectionName?: string | undefined;
+        readonly occurrenceKey?: string | undefined;
+    } | undefined);
+    get attributes(): {
+        reason: FileFetcherErrorReason;
+        id: string;
+        collectionName: string | undefined;
+        occurrenceKey: string | undefined;
+    };
+}
+export declare function isFileFetcherError(err: Error): err is FileFetcherError;

package/dist/types-ts4.5/client/file-fetcher/index.d.ts

@@ -0,0 +1,62 @@
+import 'setimmediate';
+import { AuthProvider } from '@atlaskit/media-core';
+import { MediaFileArtifacts } from '@atlaskit/media-state';
+import { MediaStore as MediaApi, MediaStoreCopyFileWithTokenParams, TouchedFiles, TouchFileDescriptor } from '../media-store';
+import { GetFileOptions } from '../../models/file-state';
+import { MediaFile } from '../../models/media';
+import { UploadableFile, UploadableFileUpfrontIds } from '../../uploader';
+import { UploadController } from '../../upload-controller';
+import { MediaSubscribable } from '../../utils/mediaSubscribable';
+import { Dimensions } from '../../utils/getDimensionsFromBlob';
+import { MediaTraceContext } from '@atlaskit/media-common';
+import { FilePreview, FileState, MediaStore } from '@atlaskit/media-state';
+export type { FileFetcherErrorAttributes, FileFetcherErrorReason, } from './error';
+export { isFileFetcherError, FileFetcherError } from './error';
+export interface CopySourceFile {
+    id: string;
+    collection?: string;
+    authProvider: AuthProvider;
+}
+export interface CopyDestination extends MediaStoreCopyFileWithTokenParams {
+    authProvider: AuthProvider;
+    mediaStore?: MediaApi;
+}
+export interface CopyFileOptions {
+    preview?: FilePreview | Promise<FilePreview>;
+    mimeType?: string;
+}
+export type ExternalUploadPayload = {
+    uploadableFileUpfrontIds: UploadableFileUpfrontIds;
+    dimensions: Dimensions;
+};
+export interface FileFetcher {
+    getFileState(id: string, options?: GetFileOptions): MediaSubscribable;
+    getArtifactURL(artifacts: MediaFileArtifacts, artifactName: keyof MediaFileArtifacts, collectionName?: string): Promise<string>;
+    touchFiles(descriptors: TouchFileDescriptor[], collection?: string, traceContext?: MediaTraceContext): Promise<TouchedFiles>;
+    upload(file: UploadableFile, controller?: UploadController, uploadableFileUpfrontIds?: UploadableFileUpfrontIds, traceContext?: MediaTraceContext): MediaSubscribable;
+    uploadExternal(url: string, collection?: string, traceContext?: MediaTraceContext): Promise<ExternalUploadPayload>;
+    downloadBinary(id: string, name?: string, collectionName?: string): Promise<void>;
+    getCurrentState(id: string, options?: GetFileOptions): Promise<FileState>;
+    copyFile(source: CopySourceFile, destination: CopyDestination, options?: CopyFileOptions, traceContext?: MediaTraceContext): Promise<MediaFile>;
+    getFileBinaryURL(id: string, collectionName?: string): Promise<string>;
+}
+export declare class FileFetcherImpl implements FileFetcher {
+    private readonly mediaApi;
+    private readonly store;
+    private readonly dataloader;
+    constructor(mediaApi: MediaApi, store?: MediaStore);
+    private getErrorFileState;
+    private setFileState;
+    getFileState(id: string, options?: GetFileOptions): MediaSubscribable;
+    getCurrentState(id: string, options?: GetFileOptions): Promise<FileState>;
+    getArtifactURL(artifacts: MediaFileArtifacts, artifactName: keyof MediaFileArtifacts, collectionName?: string): Promise<string>;
+    getFileBinaryURL(id: string, collectionName?: string): Promise<string>;
+    private createDownloadFileStream;
+    touchFiles(descriptors: TouchFileDescriptor[], collection?: string, traceContext?: MediaTraceContext): Promise<TouchedFiles>;
+    private generateUploadableFileUpfrontIds;
+    uploadExternal(url: string, collection?: string, traceContext?: MediaTraceContext): Promise<ExternalUploadPayload>;
+    private getUploadingFileStateBase;
+    upload(file: UploadableFile, controller?: UploadController, uploadableFileUpfrontIds?: UploadableFileUpfrontIds, traceContext?: MediaTraceContext): MediaSubscribable;
+    downloadBinary(id: string, name?: string, collectionName?: string): Promise<void>;
+    copyFile(source: CopySourceFile, destination: CopyDestination, options?: CopyFileOptions, traceContext?: MediaTraceContext): Promise<MediaFile>;
+}

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

@@ -0,0 +1,32 @@
+import { MediaClientConfig } from '@atlaskit/media-core';
+import { MediaTraceContext } from '@atlaskit/media-common';
+import { MediaStore as MediaApi, MediaStoreGetFileImageParams, ImageMetadata } from './media-store';
+import { FileFetcher } from './file-fetcher';
+import { UploadEventPayloadMap, EventPayloadListener } from './events';
+import { StargateClient } from './stargate-client';
+import { MobileUpload } from '../models/mobile-upload';
+import { MediaStore } from '@atlaskit/media-state';
+export declare class MediaClient {
+    readonly mediaClientConfig: MediaClientConfig;
+    private readonly store;
+    readonly mediaStore: MediaApi;
+    readonly file: FileFetcher;
+    readonly stargate: StargateClient;
+    private readonly eventEmitter;
+    private mobileUpload?;
+    readonly config: MediaClientConfig;
+    constructor(mediaClientConfig: MediaClientConfig, store?: MediaStore, mediaApi?: MediaApi);
+    /**
+     * @internal
+     */
+    __DO_NOT_USE__getMediaStore(): MediaStore;
+    getImage(id: string, params?: MediaStoreGetFileImageParams, controller?: AbortController, fetchMaxRes?: boolean, traceContext?: MediaTraceContext): Promise<Blob>;
+    getImageUrl(id: string, params?: MediaStoreGetFileImageParams): Promise<string>;
+    getImageUrlSync(id: string, params?: MediaStoreGetFileImageParams): string;
+    getImageMetadata(id: string, params?: MediaStoreGetFileImageParams): Promise<ImageMetadata>;
+    mobileUploadPromise(): Promise<MobileUpload>;
+    removeFileFromCollection(id: string, collectionName: string, occurrenceKey?: string, traceContext?: MediaTraceContext): Promise<void>;
+    on<E extends keyof UploadEventPayloadMap>(event: E, listener: EventPayloadListener<UploadEventPayloadMap, E>): void;
+    off<E extends keyof UploadEventPayloadMap>(event: E, listener: EventPayloadListener<UploadEventPayloadMap, E>): void;
+    emit<E extends keyof UploadEventPayloadMap>(event: E, payload: UploadEventPayloadMap[E]): boolean;
+}

package/dist/types-ts4.5/client/media-store/error.d.ts

@@ -0,0 +1,16 @@
+import { BaseMediaClientError } from '../../models/errors';
+export type MediaStoreErrorReason = 'failedAuthProvider' | 'tokenExpired' | 'missingInitialAuth' | 'emptyAuth' | 'authProviderTimedOut';
+export type MediaStoreErrorAttributes = {
+    readonly reason: MediaStoreErrorReason;
+    readonly innerError?: Error;
+};
+export declare class MediaStoreError extends BaseMediaClientError<MediaStoreErrorAttributes> {
+    readonly reason: MediaStoreErrorReason;
+    readonly innerError?: Error | undefined;
+    constructor(reason: MediaStoreErrorReason, innerError?: Error | undefined);
+    get attributes(): {
+        reason: MediaStoreErrorReason;
+        innerError: Error | undefined;
+    };
+}
+export declare function isMediaStoreError(err: Error): err is MediaStoreError;

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

@@ -0,0 +1,168 @@
+import { AsapBasedAuth, AuthContext, ClientAltBasedAuth, MediaApiConfig, Auth } from '@atlaskit/media-core';
+import { MediaTraceContext } from '@atlaskit/media-common';
+import { MediaFileArtifacts } from '@atlaskit/media-state';
+import { MediaChunksProbe, MediaItemDetails, 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;
+    constructor(config: MediaApiConfig);
+    removeCollectionFile(id: string, collectionName: string, occurrenceKey?: string, traceContext?: MediaTraceContext): Promise<void>;
+    createUpload(createUpTo?: number, collectionName?: string, traceContext?: MediaTraceContext): Promise<MediaStoreResponse<MediaUpload[]>>;
+    uploadChunk(etag: string, blob: Blob, uploadId: string, partNumber: number, collectionName?: string, traceContext?: MediaTraceContext): Promise<void>;
+    probeChunks(chunks: string[], uploadId: string, collectionName?: string, traceContext?: MediaTraceContext): Promise<MediaStoreResponse<MediaChunksProbe>>;
+    createFileFromUpload(body: MediaStoreCreateFileFromUploadBody, params?: MediaStoreCreateFileFromUploadParams, traceContext?: MediaTraceContext): Promise<MediaStoreResponse<MediaFile>>;
+    getRejectedResponseFromDescriptor(descriptor: TouchFileDescriptor, limit: number): RejectedTouchFile;
+    touchFiles(body: MediaStoreTouchFileBody, params?: MediaStoreTouchFileParams, traceContext?: MediaTraceContext): Promise<MediaStoreResponse<TouchedFiles>>;
+    getFile(fileId: string, params?: MediaStoreGetFileParams, traceContext?: MediaTraceContext): 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, traceContext?: MediaTraceContext): Promise<Blob>;
+    getItems(ids: string[], collectionName?: string, traceContext?: MediaTraceContext): Promise<MediaStoreResponse<ItemsPayload>>;
+    getImageMetadata(id: string, params?: MediaStoreGetFileImageParams, traceContext?: MediaTraceContext): Promise<{
+        metadata: ImageMetadata;
+    }>;
+    appendChunksToUpload(uploadId: string, body: AppendChunksToUploadRequestBody, collectionName?: string, traceContext?: MediaTraceContext): Promise<void>;
+    copyFileWithToken(body: MediaStoreCopyFileWithTokenBody, params: MediaStoreCopyFileWithTokenParams, traceContext?: MediaTraceContext): Promise<MediaStoreResponse<MediaFile>>;
+    request(path: string, options?: MediaStoreRequestOptions, controller?: AbortController): Promise<Response>;
+    resolveAuth: (authContext?: AuthContext) => Promise<Auth>;
+    resolveInitialAuth: () => Auth;
+}
+export declare const getMediaEnvironment: () => string | undefined;
+export declare const getMediaRegion: () => string | undefined;
+export interface ResponseFileItem {
+    id: string;
+    type: 'file';
+    details: MediaItemDetails;
+    collection?: string;
+    metadataTraceContext?: MediaTraceContext;
+}
+export interface ItemsPayload {
+    items: ResponseFileItem[];
+}
+export 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 type MediaStoreRequestOptions = RequestMetadata & {
+    readonly method?: RequestMethod;
+    readonly authContext?: AuthContext;
+    readonly params?: RequestParams;
+    readonly headers?: RequestHeaders;
+    readonly body?: any;
+    readonly clientOptions?: ClientOptions;
+    readonly traceContext?: MediaTraceContext;
+};
+export type MediaStoreCreateFileFromUploadParams = {
+    readonly collection?: string;
+    readonly occurrenceKey?: string;
+    readonly expireAfter?: number;
+    readonly replaceFileId?: string;
+    readonly skipConversions?: boolean;
+};
+export 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;
+    size?: number;
+}
+export interface MediaStoreTouchFileBody {
+    descriptors: TouchFileDescriptor[];
+}
+export type MediaStoreCreateFileFromBinaryParams = {
+    readonly replaceFileId?: string;
+    readonly collection?: string;
+    readonly occurrenceKey?: string;
+    readonly expireAfter?: number;
+    readonly skipConversions?: boolean;
+    readonly name?: string;
+};
+export type MediaStoreCreateFileFromUploadConditions = {
+    readonly hash?: string;
+    readonly size?: number;
+};
+export type MediaStoreCreateFileFromUploadBody = {
+    readonly uploadId: string;
+    readonly name?: string;
+    readonly mimeType?: string;
+    readonly conditions?: MediaStoreCreateFileFromUploadConditions;
+};
+export type MediaStoreGetFileParams = {
+    readonly version?: number;
+    readonly collection?: string;
+};
+export 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 interface SourceFile {
+    id: string;
+    owner: ClientAltBasedAuth | AsapBasedAuth;
+    collection?: string;
+    version?: number;
+}
+export type MediaStoreCopyFileWithTokenBody = {
+    sourceFile: SourceFile;
+};
+export type MediaStoreCopyFileWithTokenParams = {
+    readonly collection?: string;
+    readonly replaceFileId?: string;
+    readonly occurrenceKey?: string;
+};
+export type AppendChunksToUploadRequestBody = {
+    readonly chunks: string[];
+    readonly hash?: string;
+    readonly offset?: number;
+};
+export interface CreatedTouchedFile {
+    fileId: string;
+    uploadId: string;
+}
+export interface RejectedTouchFile {
+    fileId: string;
+    error: RejectionError;
+}
+export type RejectionError = {
+    code: 'ExceedMaxFileSizeLimit';
+    title: string;
+    href: string;
+    limit: number;
+    size: number;
+};
+export type TouchedFiles = {
+    created: CreatedTouchedFile[];
+    rejected?: RejectedTouchFile[];
+};
+export interface EmptyFile {
+    readonly id: string;
+    readonly createdAt: number;
+}

package/dist/types-ts4.5/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, authProviderTimeout?: number) => Promise<Auth>;
+export declare const resolveInitialAuth: (auth?: Auth) => Auth;

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

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

package/dist/types-ts4.5/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.5/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.5/file-streams-cache.d.ts

@@ -0,0 +1,15 @@
+import { LRUMap } from 'lru_map';
+import { ReplaySubject } from 'rxjs/ReplaySubject';
+import { FileState } from '@atlaskit/media-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.5/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.5/identifier.d.ts

@@ -0,0 +1,15 @@
+export 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;