@atlaskit/media-client 18.0.0 → 19.0.0

package/report.api.md

@@ -1,8 +1,17 @@
-## API Report File for "@atlaskit/media-client".
+<!-- API Report Version: 2.2 -->
 
-> Do not edit this file. This report is auto-generated by [API Extractor](https://api-extractor.com/).
+## API Report File for "@atlaskit/media-client"
 
-[Learn more about API reports](https://hello.atlassian.net/wiki/spaces/UR/pages/1825484529/Package+API+Reports)
+> Do not edit this file. This report is auto-generated using [API Extractor](https://api-extractor.com/).
+> [Learn more about API reports](https://hello.atlassian.net/wiki/spaces/UR/pages/1825484529/Package+API+Reports)
+
+### Table of contents
+
+- [Main Entry Types](#main-entry-types)
+
+### Main Entry Types
+
+<!--SECTION START: Main Entry Types-->
 
 ```ts
 import { AsapBasedAuth } from '@atlaskit/media-core';
@@ -15,117 +24,150 @@ import { FileStatus as FileStatus_2 } from '@atlaskit/media-common';
 import { MediaApiConfig } from '@atlaskit/media-core';
 import { MediaClientConfig } from '@atlaskit/media-core';
 import { MediaFeatureFlags } from '@atlaskit/media-common';
+import { MediaTraceContext } from '@atlaskit/media-common';
 import { MediaType } from '@atlaskit/media-common';
 import { default as React_2 } from 'react';
 import { ReplaySubject } from 'rxjs/ReplaySubject';
 
-export declare type AbortFunction = () => void;
+// @public (undocumented)
+export type AbortFunction = () => void;
 
-export declare const addFileAttrsToUrl: (
+// @public (undocumented)
+export const addFileAttrsToUrl: (
   url: string,
   fileAttrs: MediaBlobUrlAttrs,
 ) => string;
 
-export declare type AppendChunksToUploadRequestBody = {
+// @public (undocumented)
+export type AppendChunksToUploadRequestBody = {
   readonly chunks: string[];
   readonly hash?: string;
   readonly offset?: number;
 };
 
-export declare type Artifacts = {
+// @public (undocumented)
+export type Artifacts = {
   [name: string]: MediaArtifact;
 };
 
-/**
- * Base class for media errors
- */
-declare abstract class BaseMediaClientError<
-    Attributes extends MediaClientErrorAttributes
+// @public
+abstract class BaseMediaClientError<
+    Attributes extends MediaClientErrorAttributes,
   >
   extends Error
-  implements MediaClientError<Attributes> {
-  readonly message: string;
+  implements MediaClientError<Attributes>
+{
   constructor(message: string);
+  // (undocumented)
   abstract get attributes(): Attributes;
+  // (undocumented)
+  readonly message: string;
 }
 
-export declare const checkWebpSupport: () => Promise<boolean>;
+// @public (undocumented)
+export const checkWebpSupport: () => Promise<boolean>;
 
-export declare type ClientOptions = {
+// @public (undocumented)
+export type ClientOptions = {
   readonly retryOptions?: Partial<RetryOptions>;
   readonly clientTimeout?: number;
 };
 
-export declare class CollectionFetcher {
-  readonly mediaStore: MediaStore;
+// @public (undocumented)
+export class CollectionFetcher {
   constructor(mediaStore: MediaStore);
-  private createFileStateObserver;
-  private populateCache;
-  private removeFromCache;
+  // (undocumented)
   getItems(
     collectionName: string,
     params?: MediaStoreGetCollectionItemsParams,
+    traceContext?: MediaTraceContext,
   ): MediaSubscribable<MediaCollectionItem[]>;
+  // (undocumented)
+  loadNextPage(
+    collectionName: string,
+    params?: MediaStoreGetCollectionItemsParams,
+    traceContext?: MediaTraceContext,
+  ): Promise<void>;
+  // (undocumented)
+  readonly mediaStore: MediaStore;
+  // (undocumented)
   removeFile(
     id: string,
     collectionName: string,
     occurrenceKey?: string,
-  ): Promise<void>;
-  loadNextPage(
-    collectionName: string,
-    params?: MediaStoreGetCollectionItemsParams,
+    traceContext?: MediaTraceContext,
   ): Promise<void>;
 }
 
-declare type CompletionObserver<T> = PartialObserver<T> &
+// @public (undocumented)
+type CompletionObserver<T> = PartialObserver<T> &
   Required<Pick<PartialObserver<T>, 'complete'>>;
 
-export declare interface CopyDestination
-  extends MediaStoreCopyFileWithTokenParams {
+// @public (undocumented)
+export interface CopyDestination extends MediaStoreCopyFileWithTokenParams {
+  // (undocumented)
   authProvider: AuthProvider;
+  // (undocumented)
   mediaStore?: MediaStore;
 }
 
-export declare interface CopyFileOptions {
-  preview?: FilePreview | Promise<FilePreview>;
+// @public (undocumented)
+export interface CopyFileOptions {
+  // (undocumented)
   mimeType?: string;
+  // (undocumented)
+  preview?: FilePreview | Promise<FilePreview>;
 }
 
-export declare interface CopySourceFile {
-  id: string;
-  collection?: string;
+// @public (undocumented)
+export interface CopySourceFile {
+  // (undocumented)
   authProvider: AuthProvider;
+  // (undocumented)
+  collection?: string;
+  // (undocumented)
+  id: string;
 }
 
-export declare interface CreatedTouchedFile {
+// @public (undocumented)
+export interface CreatedTouchedFile {
+  // (undocumented)
   fileId: string;
+  // (undocumented)
   uploadId: string;
 }
 
-export declare function createMediaSubject<T extends MediaSubscribableItem>(
-  initialState?: T | Error,
+// @public (undocumented)
+export function createMediaSubject<T extends MediaSubscribableItem>(
+  initialState?: Error | T,
 ): ReplaySubject<T>;
 
-export declare function createMediaSubscribable<
-  T extends MediaSubscribableItem
->(mediaSubscribableItem?: T | Error): MediaSubscribable<T>;
+// @public (undocumented)
+export function createMediaSubscribable<T extends MediaSubscribableItem>(
+  mediaSubscribableItem?: Error | T,
+): MediaSubscribable<T>;
 
-export declare function createUrl(
+// @public (undocumented)
+export function createUrl(
   url: string,
   { params, auth }: CreateUrlOptions,
 ): string;
 
-export declare type CreateUrlOptions = {
+// @public (undocumented)
+export type CreateUrlOptions = {
   readonly params?: RequestParams;
   readonly auth?: Auth;
 };
 
-export declare type Dimensions = {
+// @public (undocumented)
+export type Dimensions = {
   width: number;
   height: number;
 };
 
-export declare interface EdgeData {
+// @public (undocumented)
+export interface EdgeData {
+  // (undocumented)
   data: {
     clientId: string;
     token: string;
@@ -135,123 +177,168 @@ export declare interface EdgeData {
   };
 }
 
-export declare interface EmptyFile {
-  readonly id: string;
+// @public (undocumented)
+export interface EmptyFile {
+  // (undocumented)
   readonly createdAt: number;
+  // (undocumented)
+  readonly id: string;
 }
 
-export declare interface ErrorFileState {
-  status: 'error';
+// @public (undocumented)
+export interface ErrorFileState {
+  // (undocumented)
   id: string;
-  occurrenceKey?: string;
+  // (undocumented)
   message?: string;
+  // (undocumented)
+  occurrenceKey?: string;
+  // (undocumented)
+  status: 'error';
 }
 
-declare type ErrorObserver<T> = PartialObserver<T> &
+// @public (undocumented)
+type ErrorObserver<T> = PartialObserver<T> &
   Required<Pick<PartialObserver<T>, 'error'>>;
 
-export declare type EventPayloadListener<
+// @public (undocumented)
+export type EventPayloadListener<
   M extends EventPayloadMap<P>,
   E extends keyof M,
-  P = any
+  P = any,
 > = (payload: M[E]) => void;
 
-declare type EventPayloadMap<P> = {
+// @public (undocumented)
+type EventPayloadMap<P> = {
   readonly [event: string]: P;
 };
 
-export declare type Executor = () => Promise<void>;
+// @public (undocumented)
+export type Executor = () => Promise<void>;
 
-export declare interface ExternalImageIdentifier {
-  readonly mediaItemType: 'external-image';
+// @public (undocumented)
+export interface ExternalImageIdentifier {
+  // (undocumented)
   readonly dataURI: string;
+  // (undocumented)
+  readonly mediaItemType: 'external-image';
+  // (undocumented)
   readonly name?: string;
 }
 
-declare type ExternalUploadPayload = {
+// @public (undocumented)
+type ExternalUploadPayload = {
   uploadableFileUpfrontIds: UploadableFileUpfrontIds;
   dimensions: Dimensions;
 };
 
-export declare interface FileDetails {
+// @public (undocumented)
+export interface FileDetails {
+  // (undocumented)
+  artifacts?: Artifacts;
+  // (undocumented)
+  createdAt?: number;
+  // (undocumented)
+  creationDate?: number;
+  // (undocumented)
   id: string;
-  name?: string;
-  size?: number;
-  mimeType?: string;
+  // (undocumented)
   mediaType?: MediaType;
-  creationDate?: number;
+  // (undocumented)
+  mimeType?: string;
+  // (undocumented)
+  name?: string;
+  // (undocumented)
   processingStatus?: FileProcessingStatus;
-  artifacts?: Artifacts;
-  createdAt?: number;
+  // (undocumented)
+  size?: number;
 }
 
-export declare interface FileFetcher {
-  getFileState(
+// @public (undocumented)
+export interface FileFetcher {
+  // (undocumented)
+  copyFile(
+    source: CopySourceFile,
+    destination: CopyDestination,
+    options?: CopyFileOptions,
+    traceContext?: MediaTraceContext,
+  ): Promise<MediaFile>;
+  // (undocumented)
+  downloadBinary(
     id: string,
-    options?: GetFileOptions,
-  ): MediaSubscribable<FileState>;
+    name?: string,
+    collectionName?: string,
+  ): Promise<void>;
+  // (undocumented)
   getArtifactURL(
     artifacts: MediaFileArtifacts,
     artifactName: keyof MediaFileArtifacts,
     collectionName?: string,
   ): Promise<string>;
+  // (undocumented)
+  getCurrentState(id: string, options?: GetFileOptions): Promise<FileState>;
+  // (undocumented)
+  getFileBinaryURL(id: string, collectionName?: string): Promise<string>;
+  // (undocumented)
+  getFileState(
+    id: string,
+    options?: GetFileOptions,
+  ): MediaSubscribable<FileState>;
+  // (undocumented)
   touchFiles(
     descriptors: TouchFileDescriptor[],
     collection?: string,
+    traceContext?: MediaTraceContext,
   ): Promise<TouchedFiles>;
+  // (undocumented)
   upload(
     file: UploadableFile,
     controller?: UploadController,
     uploadableFileUpfrontIds?: UploadableFileUpfrontIds,
+    traceContext?: MediaTraceContext,
   ): MediaSubscribable<FileState>;
+  // (undocumented)
   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,
-  ): Promise<MediaFile>;
-  getFileBinaryURL(id: string, collectionName?: string): Promise<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;
+// @public (undocumented)
+export class FileFetcherError extends BaseMediaClientError<FileFetcherErrorAttributes> {
   constructor(
     reason: FileFetcherErrorReason,
     id: string,
     metadata?:
+      | undefined
       | {
           readonly collectionName?: string | undefined;
           readonly occurrenceKey?: string | undefined;
-        }
-      | undefined,
+        },
   );
+  // (undocumented)
   get attributes(): {
     reason: FileFetcherErrorReason;
     id: string;
     collectionName: string | undefined;
     occurrenceKey: string | undefined;
   };
+  // (undocumented)
+  readonly id: string;
+  // (undocumented)
+  readonly metadata?:
+    | undefined
+    | {
+        readonly collectionName?: string | undefined;
+        readonly occurrenceKey?: string | undefined;
+      };
+  // (undocumented)
+  readonly reason: FileFetcherErrorReason;
 }
 
-export declare type FileFetcherErrorAttributes = {
+// @public (undocumented)
+export type FileFetcherErrorAttributes = {
   readonly reason: FileFetcherErrorReason;
   readonly id: string;
   readonly metadata?: {
@@ -260,128 +347,164 @@ export declare type FileFetcherErrorAttributes = {
   };
 };
 
-export declare type FileFetcherErrorReason =
-  | 'invalidFileId'
+// @public (undocumented)
+export type FileFetcherErrorReason =
   | 'emptyItems'
+  | 'invalidFileId'
   | 'zeroVersionFile';
 
-export declare class FileFetcherImpl implements FileFetcher {
-  private readonly mediaStore;
-  private readonly dataloader;
+// @public (undocumented)
+export class FileFetcherImpl implements FileFetcher {
   constructor(mediaStore: MediaStore);
-  getFileState(
+  // (undocumented)
+  copyFile(
+    source: CopySourceFile,
+    destination: CopyDestination,
+    options?: CopyFileOptions,
+    traceContext?: MediaTraceContext,
+  ): Promise<MediaFile>;
+  // (undocumented)
+  downloadBinary(
     id: string,
-    options?: GetFileOptions,
-  ): MediaSubscribable<FileState>;
-  getCurrentState(id: string, options?: GetFileOptions): Promise<FileState>;
+    name?: string,
+    collectionName?: string,
+  ): Promise<void>;
+  // (undocumented)
   getArtifactURL(
     artifacts: MediaFileArtifacts,
     artifactName: keyof MediaFileArtifacts,
     collectionName?: string,
   ): Promise<string>;
+  // (undocumented)
+  getCurrentState(id: string, options?: GetFileOptions): Promise<FileState>;
+  // (undocumented)
   getFileBinaryURL(id: string, collectionName?: string): Promise<string>;
-  private createDownloadFileStream;
+  // (undocumented)
+  getFileState(
+    id: string,
+    options?: GetFileOptions,
+  ): MediaSubscribable<FileState>;
+  // (undocumented)
   touchFiles(
     descriptors: TouchFileDescriptor[],
     collection?: string,
+    traceContext?: MediaTraceContext,
   ): Promise<TouchedFiles>;
-  private generateUploadableFileUpfrontIds;
-  uploadExternal(
-    url: string,
-    collection?: string,
-  ): Promise<ExternalUploadPayload>;
+  // (undocumented)
   upload(
     file: UploadableFile,
     controller?: UploadController,
     uploadableFileUpfrontIds?: UploadableFileUpfrontIds,
+    traceContext?: MediaTraceContext,
   ): MediaSubscribable<FileState>;
-  downloadBinary(
-    id: string,
-    name?: string,
-    collectionName?: string,
-  ): Promise<void>;
-  copyFile(
-    source: CopySourceFile,
-    destination: CopyDestination,
-    options?: CopyFileOptions,
-  ): Promise<MediaFile>;
+  // (undocumented)
+  uploadExternal(
+    url: string,
+    collection?: string,
+    traceContext?: MediaTraceContext,
+  ): Promise<ExternalUploadPayload>;
 }
 
-export declare interface FileIdentifier {
-  readonly mediaItemType: 'file';
+// @public (undocumented)
+export interface FileIdentifier {
+  // (undocumented)
+  readonly collectionName?: string;
+  // (undocumented)
   readonly id: string;
+  // (undocumented)
+  readonly mediaItemType: 'file';
+  // (undocumented)
   readonly occurrenceKey?: string;
-  readonly collectionName?: string;
 }
 
-export declare interface FileItem {
-  type: 'file';
+// @public (undocumented)
+export interface FileItem {
+  // (undocumented)
   details: FileDetails;
+  // (undocumented)
+  type: 'file';
 }
 
-export declare interface FilePreview {
-  value: Blob | string;
+// @public (undocumented)
+export interface FilePreview {
+  // (undocumented)
   origin?: 'local' | 'remote';
+  // (undocumented)
   originalDimensions?: {
     width: number;
     height: number;
   };
+  // (undocumented)
+  value: Blob | string;
 }
 
-export declare type FileProcessingStatus =
+// @public (undocumented)
+export type FileProcessingStatus =
+  | 'failed'
   | 'pending'
   | 'running'
-  | 'succeeded'
-  | 'failed';
+  | 'succeeded';
 
-export declare type FileState =
-  | UploadingFileState
-  | ProcessingFileState
-  | ProcessedFileState
+// @public (undocumented)
+export type FileState =
   | ErrorFileState
-  | ProcessingFailedState;
+  | ProcessedFileState
+  | ProcessingFailedState
+  | ProcessingFileState
+  | UploadingFileState;
 
-export declare type FileStatus = FileStatus_2;
+// @public (undocumented)
+export type FileStatus = FileStatus_2;
 
-export declare const getArtifactUrl: (
+// @public (undocumented)
+export const getArtifactUrl: (
   artifacts: MediaFileArtifacts,
   prop: keyof MediaFileArtifacts,
 ) => string | undefined;
 
-export declare const getAttrsFromUrl: (
+// @public (undocumented)
+export const getAttrsFromUrl: (
   blobUrl: string,
 ) => MediaBlobUrlAttrs | undefined;
 
-export declare const getDimensionsFromBlob: (
+// @public (undocumented)
+export const getDimensionsFromBlob: (
   mediaType: MediaType,
   blob: Blob,
 ) => Promise<Dimensions>;
 
-export declare interface GetFileOptions {
-  preview?: PreviewOptions;
+// @public (undocumented)
+export interface GetFileOptions {
+  // (undocumented)
   collectionName?: string;
+  // (undocumented)
   occurrenceKey?: string;
+  // (undocumented)
+  preview?: PreviewOptions;
 }
 
-export declare const getMediaClient: (
+// @public (undocumented)
+export const getMediaClient: (
   mediaClientConfig: MediaClientConfig,
   featureFlags?: MediaFeatureFlags | undefined,
 ) => MediaClient;
 
-export declare function getMediaClientErrorReason(
+// @public (undocumented)
+export function getMediaClientErrorReason(
   err: Error,
-): MediaClientErrorReason | 'unknown';
+): 'unknown' | MediaClientErrorReason;
 
-export declare const getMediaEnvironment: () => string | undefined;
+// @public (undocumented)
+export const getMediaEnvironment: () => string | undefined;
 
-export declare const getMediaRegion: () => string | undefined;
+// @public (undocumented)
+export const getMediaRegion: () => string | undefined;
 
-/**
- * @deprecated This export will be removed. Please use one from @atlaskit/media-common or @atlaskit/media-common/mediaTypeUtils
- */
-export declare const getMediaTypeFromMimeType: (mimeType: string) => MediaType;
+// @public @deprecated (undocumented)
+export const getMediaTypeFromMimeType: (mimeType: string) => MediaType;
 
-export declare const globalMediaEventEmitter: {
+// @public (undocumented)
+export const globalMediaEventEmitter: {
   on<E extends keyof UploadEventPayloadMap>(
     event: E,
     listener: EventPayloadListener<UploadEventPayloadMap, E, any>,
@@ -396,224 +519,220 @@ export declare const globalMediaEventEmitter: {
   ): boolean | undefined;
 };
 
-export declare type Identifier = FileIdentifier | ExternalImageIdentifier;
+// @public (undocumented)
+export type Identifier = ExternalImageIdentifier | FileIdentifier;
 
-export declare interface ImageMetadata {
+// @public (undocumented)
+export interface ImageMetadata {
+  // (undocumented)
+  original?: ImageMetadataArtifact;
+  // (undocumented)
   pending: boolean;
+  // (undocumented)
   preview?: ImageMetadataArtifact;
-  original?: ImageMetadataArtifact;
 }
 
-export declare type ImageMetadataArtifact = {
+// @public (undocumented)
+export type ImageMetadataArtifact = {
   url?: string;
   width?: number;
   height?: number;
   size?: number;
 };
 
-export declare type ImageResizeMode =
-  | 'crop'
-  | 'fit'
-  | 'full-fit'
-  | 'stretchy-fit';
+// @public (undocumented)
+export type ImageResizeMode = 'crop' | 'fit' | 'full-fit' | 'stretchy-fit';
 
-export declare const imageResizeModeToFileImageMode: (
+// @public (undocumented)
+export const imageResizeModeToFileImageMode: (
   resizeMode?: ImageResizeMode | undefined,
 ) => MediaStoreGetFileImageParams['mode'];
 
-export declare function isAbortedRequestError(err: any): boolean;
+// @public (undocumented)
+export function isAbortedRequestError(err: any): 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;
+// @public @deprecated (undocumented)
+export const isAudioMimeTypeSupportedByServer: (mimeType: string) => boolean;
 
-export declare const isDifferentIdentifier: (
-  a: Identifier,
-  b: Identifier,
-) => boolean;
+// @public (undocumented)
+export const isDifferentIdentifier: (a: Identifier, b: Identifier) => boolean;
 
-/**
- * @deprecated This export will be removed. Please use one from @atlaskit/media-common or @atlaskit/media-common/mediaTypeUtils
- */
-export declare const isDocumentMimeTypeSupportedByBrowser: (
+// @public @deprecated (undocumented)
+export 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 isDocumentMimeTypeSupportedByServer: (
-  mimeType: string,
-) => boolean;
+// @public @deprecated (undocumented)
+export const isDocumentMimeTypeSupportedByServer: (mimeType: string) => boolean;
 
-export declare const isErrorFileState: (
+// @public (undocumented)
+export const isErrorFileState: (
   fileState: FileState,
 ) => fileState is ErrorFileState;
 
-export declare const isExternalImageIdentifier: (
+// @public (undocumented)
+export const isExternalImageIdentifier: (
   identifier: Identifier,
 ) => identifier is ExternalImageIdentifier;
 
-export declare function isFileFetcherError(err: Error): err is FileFetcherError;
+// @public (undocumented)
+export function isFileFetcherError(err: Error): err is FileFetcherError;
 
-export declare const isFileIdentifier: (
+// @public (undocumented)
+export const isFileIdentifier: (
   identifier: Identifier,
 ) => identifier is FileIdentifier;
 
-export declare const isFinalFileState: (
+// @public (undocumented)
+export const isFinalFileState: (
   fileState: FileState,
-) => fileState is ProcessedFileState | ProcessingFailedState | ErrorFileState;
+) => fileState is ErrorFileState | ProcessedFileState | ProcessingFailedState;
 
-/**
- * @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;
+// @public @deprecated (undocumented)
+export 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 isImageMimeTypeSupportedByServer: (
-  mimeType: string,
-) => boolean;
+// @public @deprecated (undocumented)
+export const isImageMimeTypeSupportedByServer: (mimeType: string) => boolean;
 
-export declare const isImageRemote: (
+// @public (undocumented)
+export const isImageRemote: (
   imageUrl: string,
   windowOrigin?: string,
 ) => boolean;
 
-export declare const isImageRepresentationReady: (
-  fileState: FileState,
-) => boolean;
+// @public (undocumented)
+export const isImageRepresentationReady: (fileState: FileState) => boolean;
 
-export declare const isMediaBlobUrl: (url: string) => boolean;
+// @public (undocumented)
+export const isMediaBlobUrl: (url: string) => boolean;
 
-export declare function isMediaClientError(
-  error: any,
-): error is MediaClientError<{
+// @public (undocumented)
+export function isMediaClientError(error: any): error is MediaClientError<{
   reason: MediaClientErrorReason;
 }>;
 
-export declare const isMediaCollectionItemFullDetails: (
+// @public (undocumented)
+export const isMediaCollectionItemFullDetails: (
   mediaCollectionItem: MediaCollectionItemDetails,
 ) => mediaCollectionItem is MediaCollectionItemFullDetails;
 
-export declare function isMediaStoreError(err: Error): err is MediaStoreError;
+// @public (undocumented)
+export function isMediaStoreError(err: Error): err is MediaStoreError;
 
-/**
- * @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;
+// @public @deprecated (undocumented)
+export 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 isMimeTypeSupportedByServer: (mimeType: string) => boolean;
+// @public @deprecated (undocumented)
+export const isMimeTypeSupportedByServer: (mimeType: string) => boolean;
 
-export declare function isPollingError(err?: Error): err is PollingError;
+// @public (undocumented)
+export function isPollingError(err?: Error): err is PollingError;
 
-export declare const isPreviewableFileState: (
+// @public (undocumented)
+export const isPreviewableFileState: (
   fileState: FileState,
 ) => fileState is (
-  | UploadingFileState
-  | ProcessingFileState
   | ProcessedFileState
   | ProcessingFailedState
+  | ProcessingFileState
+  | UploadingFileState
 ) &
   PreviewableFileState;
 
-export declare const isPreviewableType: (
+// @public (undocumented)
+export const isPreviewableType: (
   type: MediaType,
   featureFlags?: MediaFeatureFlags | undefined,
 ) => boolean;
 
-export declare const isProcessedFileState: (
+// @public (undocumented)
+export const isProcessedFileState: (
   fileState: FileState,
 ) => fileState is ProcessedFileState;
 
-export declare const isProcessingFileState: (
+// @public (undocumented)
+export const isProcessingFileState: (
   fileState: FileState,
 ) => fileState is ProcessingFileState;
 
-export declare function isRateLimitedError(error: Error | undefined): boolean;
+// @public (undocumented)
+export function isRateLimitedError(error: Error | undefined): boolean;
 
-export declare function isRequestError(err: Error): err is RequestError;
+// @public (undocumented)
+export function isRequestError(err: Error): err is RequestError;
 
-/**
- * @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;
+// @public @deprecated (undocumented)
+export const isUnknownMimeTypeSupportedByServer: (mimeType: string) => boolean;
 
-export declare const isUploadingFileState: (
+// @public (undocumented)
+export const isUploadingFileState: (
   fileState: FileState,
 ) => fileState is UploadingFileState;
 
-/**
- * @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;
+// @public @deprecated (undocumented)
+export const isVideoMimeTypeSupportedByServer: (mimeType: string) => boolean;
 
-export declare interface ItemsPayload {
+// @public (undocumented)
+export interface ItemsPayload {
+  // (undocumented)
   items: ResponseFileItem[];
 }
 
-export declare const mapMediaFileToFileState: (
+// @public (undocumented)
+export const mapMediaFileToFileState: (
   mediaFile: MediaStoreResponse<MediaFile>,
 ) => FileState;
 
-export declare const mapMediaItemToFileState: (
+// @public (undocumented)
+export const mapMediaItemToFileState: (
   id: string,
   item: MediaCollectionItemFullDetails,
 ) => FileState;
 
-/**
- * @deprecated Helper is deprecated and will be removed in the next major version.
- * TODO: https://product-fabric.atlassian.net/browse/BMPT-1354
- */
-export declare function mapResponseToBlob(response: Response): Promise<Blob>;
+// @public @deprecated (undocumented)
+export function mapResponseToBlob(response: Response): Promise<Blob>;
 
-/**
- * @deprecated Helper is deprecated and will be removed in the next major version.
- * TODO: https://product-fabric.atlassian.net/browse/BMPT-1354
- */
-export declare function mapResponseToJson(response: Response): Promise<any>;
+// @public @deprecated (undocumented)
+export function mapResponseToJson(response: Response): Promise<any>;
 
-/**
- * @deprecated Helper is deprecated and will be removed in the next major version.
- * TODO: https://product-fabric.atlassian.net/browse/BMPT-1354
- */
-export declare function mapResponseToVoid(): Promise<void>;
+// @public @deprecated (undocumented)
+export function mapResponseToVoid(): Promise<void>;
 
-export declare const MAX_RESOLUTION = 4096;
+// @public (undocumented)
+export const MAX_RESOLUTION = 4096;
 
-export declare interface MediaArtifact {
+// @public (undocumented)
+export interface MediaArtifact {
+  // (undocumented)
   processingStatus?: FileProcessingStatus;
+  // (undocumented)
   url?: string;
 }
 
-export declare interface MediaBlobUrlAttrs {
-  id: string;
-  contextId: string;
+// @public (undocumented)
+export interface MediaBlobUrlAttrs {
+  // (undocumented)
+  alt?: string;
+  // (undocumented)
   collection?: string;
-  size?: number;
-  name?: string;
+  // (undocumented)
+  contextId: string;
+  // (undocumented)
+  height?: number;
+  // (undocumented)
+  id: string;
+  // (undocumented)
   mimeType?: string;
+  // (undocumented)
+  name?: string;
+  // (undocumented)
+  size?: number;
+  // (undocumented)
   width?: number;
-  height?: number;
-  alt?: string;
 }
 
-export declare type MediaChunksProbe = {
+// @public (undocumented)
+export type MediaChunksProbe = {
   readonly results: {
     readonly [etag: string]: {
       readonly exists: boolean;
@@ -621,109 +740,124 @@ export declare type MediaChunksProbe = {
   };
 };
 
-export declare class MediaClient {
-  readonly mediaClientConfig: MediaClientConfig;
-  readonly featureFlags?: MediaFeatureFlags | undefined;
-  readonly mediaStore: MediaStore;
-  readonly collection: CollectionFetcher;
-  readonly file: FileFetcher;
-  readonly stargate: StargateClient;
-  private readonly eventEmitter;
-  private mobileUpload?;
-  readonly config: MediaClientConfig;
+// @public (undocumented)
+export class MediaClient {
   constructor(
     mediaClientConfig: MediaClientConfig,
     featureFlags?: MediaFeatureFlags | undefined,
   );
+  // (undocumented)
+  readonly collection: CollectionFetcher;
+  // (undocumented)
+  readonly config: MediaClientConfig;
+  // (undocumented)
+  emit<E extends keyof UploadEventPayloadMap>(
+    event: E,
+    payload: UploadEventPayloadMap[E],
+  ): boolean;
+  // (undocumented)
+  readonly featureFlags?: MediaFeatureFlags | undefined;
+  // (undocumented)
+  readonly file: FileFetcher;
+  // (undocumented)
   getImage(
     id: string,
     params?: MediaStoreGetFileImageParams,
     controller?: AbortController,
     fetchMaxRes?: boolean,
+    traceContext?: MediaTraceContext,
   ): Promise<Blob>;
+  // (undocumented)
+  getImageMetadata(
+    id: string,
+    params?: MediaStoreGetFileImageParams,
+  ): Promise<ImageMetadata>;
+  // (undocumented)
   getImageUrl(
     id: string,
     params?: MediaStoreGetFileImageParams,
   ): Promise<string>;
+  // (undocumented)
   getImageUrlSync(id: string, params?: MediaStoreGetFileImageParams): string;
-  getImageMetadata(
-    id: string,
-    params?: MediaStoreGetFileImageParams,
-  ): Promise<ImageMetadata>;
+  // (undocumented)
+  readonly mediaClientConfig: MediaClientConfig;
+  // (undocumented)
+  readonly mediaStore: MediaStore;
+  // (undocumented)
   mobileUploadPromise(): Promise<MobileUpload>;
-  on<E extends keyof UploadEventPayloadMap>(
+  // (undocumented)
+  off<E extends keyof UploadEventPayloadMap>(
     event: E,
     listener: EventPayloadListener<UploadEventPayloadMap, E>,
   ): void;
-  off<E extends keyof UploadEventPayloadMap>(
+  // (undocumented)
+  on<E extends keyof UploadEventPayloadMap>(
     event: E,
     listener: EventPayloadListener<UploadEventPayloadMap, E>,
   ): void;
-  emit<E extends keyof UploadEventPayloadMap>(
-    event: E,
-    payload: UploadEventPayloadMap[E],
-  ): boolean;
+  // (undocumented)
+  readonly stargate: StargateClient;
 }
 
-/**
- * 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 declare interface MediaClientError<
-  Attributes extends MediaClientErrorAttributes
-> extends Error {
+// @public
+export interface MediaClientError<Attributes extends MediaClientErrorAttributes>
+  extends Error {
+  // (undocumented)
   readonly attributes: Attributes;
 }
 
-export declare interface MediaClientErrorAttributes {
+// @public (undocumented)
+export interface MediaClientErrorAttributes {
+  // (undocumented)
   reason: MediaClientErrorReason;
 }
 
-export declare type MediaClientErrorReason =
-  | 'clientOffline'
+// @public (undocumented)
+export type MediaClientErrorReason =
+  | 'authProviderTimedOut'
   | 'clientAbortedRequest'
+  | 'clientOffline'
   | 'clientTimeoutRequest'
-  | 'serverInvalidBody'
+  | 'emptyAuth'
+  | 'emptyItems'
+  | 'failedAuthProvider'
+  | 'fileSizeExceedsLimit'
+  | 'invalidFileId'
+  | 'missingInitialAuth'
+  | 'pollingMaxAttemptsExceeded'
+  | 'serverBadGateway'
   | 'serverBadRequest'
-  | 'serverUnauthorized'
   | 'serverForbidden'
+  | 'serverInternalError'
+  | 'serverInvalidBody'
   | 'serverNotFound'
   | 'serverRateLimited'
-  | 'serverInternalError'
-  | 'serverBadGateway'
+  | 'serverUnauthorized'
   | 'serverUnexpectedError'
-  | 'failedAuthProvider'
   | 'tokenExpired'
-  | 'missingInitialAuth'
-  | 'emptyAuth'
-  | 'authProviderTimedOut'
-  | 'invalidFileId'
-  | 'emptyItems'
-  | 'zeroVersionFile'
-  | 'pollingMaxAttemptsExceeded'
-  | 'fileSizeExceedsLimit';
+  | 'zeroVersionFile';
 
-export declare type MediaCollection = {
+// @public (undocumented)
+export type MediaCollection = {
   readonly name: string;
   readonly createdAt: number;
 };
 
-export declare type MediaCollectionItem = {
+// @public (undocumented)
+export type MediaCollectionItem = {
   readonly id: string;
   readonly insertedAt: number;
   readonly occurrenceKey: string;
   readonly details: MediaCollectionItemDetails;
 };
 
-export declare type MediaCollectionItemDetails =
-  | MediaCollectionItemMinimalDetails
-  | MediaCollectionItemFullDetails;
+// @public (undocumented)
+export type MediaCollectionItemDetails =
+  | MediaCollectionItemFullDetails
+  | MediaCollectionItemMinimalDetails;
 
-export declare type MediaCollectionItemFullDetails = {
+// @public (undocumented)
+export type MediaCollectionItemFullDetails = {
   readonly mediaType: MediaType;
   readonly mimeType: string;
   readonly name: string;
@@ -734,17 +868,20 @@ export declare type MediaCollectionItemFullDetails = {
   readonly createdAt?: number;
 };
 
-export declare type MediaCollectionItemMinimalDetails = {
+// @public (undocumented)
+export type MediaCollectionItemMinimalDetails = {
   readonly name: string;
   readonly size: number;
 };
 
-export declare type MediaCollectionItems = {
+// @public (undocumented)
+export type MediaCollectionItems = {
   readonly contents: MediaCollectionItem[];
   readonly nextInclusiveStartKey?: string;
 };
 
-export declare type MediaFile = {
+// @public (undocumented)
+export type MediaFile = {
   readonly id: string;
   readonly mediaType: MediaType;
   readonly mimeType: string;
@@ -756,150 +893,193 @@ export declare type MediaFile = {
   readonly createdAt?: number;
 };
 
-export declare type MediaFileArtifact = {
+// @public (undocumented)
+export type MediaFileArtifact = {
   readonly url: string;
   readonly processingStatus: MediaFileProcessingStatus;
 };
 
-export declare interface MediaFileArtifacts {
+// @public (undocumented)
+export interface MediaFileArtifacts {
+  // (undocumented)
+  'audio.mp3'?: MediaFileArtifact;
+  // (undocumented)
+  'document.pdf'?: MediaFileArtifact;
+  // (undocumented)
   'video_1280.mp4'?: MediaFileArtifact;
+  // (undocumented)
   'video_640.mp4'?: MediaFileArtifact;
-  'document.pdf'?: MediaFileArtifact;
-  'audio.mp3'?: MediaFileArtifact;
 }
 
-export declare type MediaFileProcessingStatus =
-  | 'pending'
-  | 'succeeded'
-  | 'failed';
+// @public (undocumented)
+export type MediaFileProcessingStatus = 'failed' | 'pending' | 'succeeded';
 
-export declare type MediaItemType = 'file' | 'external-image';
+// @public (undocumented)
+export type MediaItemType = 'external-image' | 'file';
 
-export declare type MediaObserver<T> =
-  | NextObserver<T>
-  | ErrorObserver<T>
+// @public (undocumented)
+export type MediaObserver<T> =
+  | ((value: T) => void)
   | CompletionObserver<T>
-  | ((value: T) => void);
+  | ErrorObserver<T>
+  | NextObserver<T>;
 
-export declare type MediaRepresentations = {
+// @public (undocumented)
+export type MediaRepresentations = {
   image?: Object;
 };
 
-export declare class MediaStore {
-  private readonly config;
-  readonly featureFlags?: MediaFeatureFlags | undefined;
+// @public (undocumented)
+export class MediaStore {
   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,
+  // (undocumented)
+  appendChunksToUpload(
+    uploadId: string,
+    body: AppendChunksToUploadRequestBody,
     collectionName?: string,
-  ): Promise<MediaStoreResponse<MediaUpload[]>>;
-  uploadChunk(
-    etag: string,
-    blob: Blob,
-    {
-      collectionName,
-      uploadId,
-      partNumber,
-    }?: {
-      collectionName?: string;
-      uploadId?: string;
-      partNumber?: number;
-    },
+    traceContext?: MediaTraceContext,
   ): Promise<void>;
-  probeChunks(
-    chunks: string[],
-    {
-      collectionName,
-      uploadId,
-    }?: {
-      collectionName?: string;
-      uploadId?: string;
-    },
-  ): Promise<MediaStoreResponse<MediaChunksProbe>>;
+  // (undocumented)
+  copyFileWithToken(
+    body: MediaStoreCopyFileWithTokenBody,
+    params: MediaStoreCopyFileWithTokenParams,
+    traceContext?: MediaTraceContext,
+  ): Promise<MediaStoreResponse<MediaFile>>;
+  // (undocumented)
   createFileFromUpload(
     body: MediaStoreCreateFileFromUploadBody,
     params?: MediaStoreCreateFileFromUploadParams,
+    traceContext?: MediaTraceContext,
   ): Promise<MediaStoreResponse<MediaFile>>;
-  touchFiles(
-    body: MediaStoreTouchFileBody,
-    params?: MediaStoreTouchFileParams,
-  ): Promise<MediaStoreResponse<TouchedFiles>>;
+  // (undocumented)
+  createUpload(
+    createUpTo?: number,
+    collectionName?: string,
+    traceContext?: MediaTraceContext,
+  ): Promise<MediaStoreResponse<MediaUpload[]>>;
+  // (undocumented)
+  readonly featureFlags?: MediaFeatureFlags | undefined;
+  // (undocumented)
+  getArtifactURL(
+    artifacts: MediaFileArtifacts,
+    artifactName: keyof MediaFileArtifacts,
+    collectionName?: string,
+  ): Promise<string>;
+  // (undocumented)
+  getCollectionItems(
+    collectionName: string,
+    params?: MediaStoreGetCollectionItemsParams,
+    traceContext?: MediaTraceContext,
+  ): Promise<MediaStoreResponse<MediaCollectionItems>>;
+  // (undocumented)
   getFile(
     fileId: string,
     params?: MediaStoreGetFileParams,
+    traceContext?: MediaTraceContext,
   ): Promise<MediaStoreResponse<MediaFile>>;
+  // (undocumented)
+  getFileBinaryURL(id: string, collectionName?: string): Promise<string>;
+  // (undocumented)
   getFileImageURL(
     id: string,
     params?: MediaStoreGetFileImageParams,
   ): Promise<string>;
+  // (undocumented)
   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>;
+  // (undocumented)
   getImage(
     id: string,
     params?: MediaStoreGetFileImageParams,
     controller?: AbortController,
     fetchMaxRes?: boolean,
+    traceContext?: MediaTraceContext,
   ): Promise<Blob>;
-  getItems(
-    ids: string[],
-    collectionName?: string,
-  ): Promise<MediaStoreResponse<ItemsPayload>>;
+  // (undocumented)
   getImageMetadata(
     id: string,
     params?: MediaStoreGetFileImageParams,
+    traceContext?: MediaTraceContext,
   ): Promise<{
     metadata: ImageMetadata;
   }>;
-  appendChunksToUpload(
-    uploadId: string,
-    body: AppendChunksToUploadRequestBody,
+  // (undocumented)
+  getItems(
+    ids: string[],
     collectionName?: string,
+    traceContext?: MediaTraceContext,
+  ): Promise<MediaStoreResponse<ItemsPayload>>;
+  // (undocumented)
+  probeChunks(
+    chunks: string[],
+    {
+      collectionName,
+      uploadId,
+    }?: {
+      collectionName?: string;
+      uploadId?: string;
+    },
+    traceContext?: MediaTraceContext,
+  ): Promise<MediaStoreResponse<MediaChunksProbe>>;
+  // (undocumented)
+  removeCollectionFile(
+    id: string,
+    collectionName: string,
+    occurrenceKey?: string,
+    traceContext?: MediaTraceContext,
   ): Promise<void>;
-  copyFileWithToken(
-    body: MediaStoreCopyFileWithTokenBody,
-    params: MediaStoreCopyFileWithTokenParams,
-  ): Promise<MediaStoreResponse<MediaFile>>;
+  // (undocumented)
   request(
     path: string,
     options?: MediaStoreRequestOptions,
     controller?: AbortController,
   ): Promise<Response>;
+  // (undocumented)
   resolveAuth: (authContext?: AuthContext | undefined) => Promise<Auth>;
+  // (undocumented)
   resolveInitialAuth: () => Auth;
+  // (undocumented)
+  touchFiles(
+    body: MediaStoreTouchFileBody,
+    params?: MediaStoreTouchFileParams,
+    traceContext?: MediaTraceContext,
+  ): Promise<MediaStoreResponse<TouchedFiles>>;
+  // (undocumented)
+  uploadChunk(
+    etag: string,
+    blob: Blob,
+    {
+      collectionName,
+      uploadId,
+      partNumber,
+    }?: {
+      collectionName?: string;
+      uploadId?: string;
+      partNumber?: number;
+    },
+    traceContext?: MediaTraceContext,
+  ): Promise<void>;
 }
 
-export declare type MediaStoreCopyFileWithTokenBody = {
+// @public (undocumented)
+export type MediaStoreCopyFileWithTokenBody = {
   sourceFile: SourceFile;
 };
 
-export declare type MediaStoreCopyFileWithTokenParams = {
+// @public (undocumented)
+export type MediaStoreCopyFileWithTokenParams = {
   readonly collection?: string;
   readonly replaceFileId?: string;
   readonly occurrenceKey?: string;
 };
 
-export declare type MediaStoreCreateFileFromBinaryParams = {
+// @public (undocumented)
+export type MediaStoreCreateFileFromBinaryParams = {
   readonly replaceFileId?: string;
   readonly collection?: string;
   readonly occurrenceKey?: string;
@@ -908,19 +1088,22 @@ export declare type MediaStoreCreateFileFromBinaryParams = {
   readonly name?: string;
 };
 
-export declare type MediaStoreCreateFileFromUploadBody = {
+// @public (undocumented)
+export type MediaStoreCreateFileFromUploadBody = {
   readonly uploadId: string;
   readonly name?: string;
   readonly mimeType?: string;
   readonly conditions?: MediaStoreCreateFileFromUploadConditions;
 };
 
-export declare type MediaStoreCreateFileFromUploadConditions = {
+// @public (undocumented)
+export type MediaStoreCreateFileFromUploadConditions = {
   readonly hash: string;
   readonly size: number;
 };
 
-export declare type MediaStoreCreateFileFromUploadParams = {
+// @public (undocumented)
+export type MediaStoreCreateFileFromUploadParams = {
   readonly collection?: string;
   readonly occurrenceKey?: string;
   readonly expireAfter?: number;
@@ -928,125 +1111,158 @@ export declare type MediaStoreCreateFileFromUploadParams = {
   readonly skipConversions?: boolean;
 };
 
-export declare type MediaStoreCreateFileParams = {
+// @public (undocumented)
+export type MediaStoreCreateFileParams = {
   readonly occurrenceKey?: string;
   readonly collection?: string;
 };
 
-export declare class MediaStoreError extends BaseMediaClientError<
-  MediaStoreErrorAttributes
-> {
-  readonly reason: MediaStoreErrorReason;
-  readonly innerError?: Error | undefined;
+// @public (undocumented)
+export class MediaStoreError extends BaseMediaClientError<MediaStoreErrorAttributes> {
   constructor(reason: MediaStoreErrorReason, innerError?: Error | undefined);
+  // (undocumented)
   get attributes(): {
     reason: MediaStoreErrorReason;
     innerError: Error | undefined;
   };
+  // (undocumented)
+  readonly innerError?: Error | undefined;
+  // (undocumented)
+  readonly reason: MediaStoreErrorReason;
 }
 
-export declare type MediaStoreErrorAttributes = {
+// @public (undocumented)
+export type MediaStoreErrorAttributes = {
   readonly reason: MediaStoreErrorReason;
   readonly innerError?: Error;
 };
 
-export declare type MediaStoreErrorReason =
+// @public (undocumented)
+export type MediaStoreErrorReason =
+  | 'authProviderTimedOut'
+  | 'emptyAuth'
   | 'failedAuthProvider'
-  | 'tokenExpired'
   | 'missingInitialAuth'
-  | 'emptyAuth'
-  | 'authProviderTimedOut';
+  | 'tokenExpired';
 
-export declare type MediaStoreGetCollectionItemsParams = {
+// @public (undocumented)
+export type MediaStoreGetCollectionItemsParams = {
   readonly limit?: number;
   readonly inclusiveStartKey?: string;
   readonly sortDirection?: 'asc' | 'desc';
-  readonly details?: 'minimal' | 'full';
+  readonly details?: 'full' | 'minimal';
 };
 
-export declare type MediaStoreGetFileImageParams = {
+// @public (undocumented)
+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 mode?: 'crop' | 'fit' | 'full-fit';
   readonly upscale?: boolean;
   readonly 'max-age'?: number;
 };
 
-export declare type MediaStoreGetFileParams = {
+// @public (undocumented)
+export type MediaStoreGetFileParams = {
   readonly version?: number;
   readonly collection?: string;
 };
 
-export declare type MediaStoreRequestOptions = RequestMetadata & {
+// @public (undocumented)
+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 declare interface MediaStoreResponse<Data> {
+// @public (undocumented)
+export interface MediaStoreResponse<Data> {
+  // (undocumented)
   readonly data: Data;
 }
 
-export declare interface MediaStoreTouchFileBody {
+// @public (undocumented)
+export interface MediaStoreTouchFileBody {
+  // (undocumented)
   descriptors: TouchFileDescriptor[];
 }
 
-export declare interface MediaStoreTouchFileParams {
+// @public (undocumented)
+export interface MediaStoreTouchFileParams {
+  // (undocumented)
   readonly collection?: string;
 }
 
-export declare type MediaSubscribable<T> = {
+// @public (undocumented)
+export type MediaSubscribable<T> = {
   subscribe(observer?: MediaObserver<T>): MediaSubscription;
 };
 
-export declare type MediaSubscribableItem = FileState | MediaCollectionItem[];
+// @public (undocumented)
+export type MediaSubscribableItem = FileState | MediaCollectionItem[];
 
-export declare type MediaSubscription = {
+// @public (undocumented)
+export type MediaSubscription = {
   unsubscribe: () => void;
 };
 
 export { MediaType };
 
-export declare type MediaUpload = {
+// @public (undocumented)
+export type MediaUpload = {
   readonly id: string;
   readonly created: number;
   readonly expires: number;
 };
 
-export declare interface MediaViewedEventPayload {
+// @public (undocumented)
+export interface MediaViewedEventPayload {
+  // (undocumented)
   fileId: string;
-  viewingLevel: 'minimal' | 'full' | 'download';
+  // (undocumented)
   isUserCollection?: boolean;
+  // (undocumented)
+  viewingLevel: 'download' | 'full' | 'minimal';
 }
 
-export declare interface MobileUpload {
-  notifyUploadStart(event: MobileUploadStartEvent): void;
-  notifyUploadProgress(event: MobileUploadProgressEvent): void;
+// @public (undocumented)
+export interface MobileUpload {
+  // (undocumented)
   notifyUploadEnd(event: MobileUploadEndEvent): void;
+  // (undocumented)
   notifyUploadError(event: MobileUploadErrorEvent): void;
+  // (undocumented)
+  notifyUploadProgress(event: MobileUploadProgressEvent): void;
+  // (undocumented)
+  notifyUploadStart(event: MobileUploadStartEvent): void;
 }
 
-export declare type MobileUploadEndEvent = {
+// @public (undocumented)
+export type MobileUploadEndEvent = {
   fileId: string;
 };
 
-export declare type MobileUploadErrorEvent = {
+// @public (undocumented)
+export type MobileUploadErrorEvent = {
   fileId: string;
   message: string;
 };
 
-export declare type MobileUploadProgressEvent = {
+// @public (undocumented)
+export type MobileUploadProgressEvent = {
   fileId: string;
   progress: number;
 };
 
-export declare type MobileUploadStartEvent = {
+// @public (undocumented)
+export type MobileUploadStartEvent = {
   fileId: string;
   collectionName?: string;
   occurrenceKey?: string;
@@ -1057,141 +1273,191 @@ export declare type MobileUploadStartEvent = {
   createdAt?: number;
 };
 
-declare type NextObserver<T> = PartialObserver<T> &
+// @public (undocumented)
+type NextObserver<T> = PartialObserver<T> &
   Required<Pick<PartialObserver<T>, 'next'>>;
 
-export declare type NonErrorFileState = Exclude<FileState, ErrorFileState>;
+// @public (undocumented)
+export type NonErrorFileState = Exclude<FileState, ErrorFileState>;
 
-export declare const objectToQueryString: (json: {
-  [key: string]: string | number | boolean | null | undefined;
+// @public (undocumented)
+export const objectToQueryString: (json: {
+  [key: string]: boolean | null | number | string | undefined;
 }) => string;
 
-declare type PartialObserver<T> = {
+// @public (undocumented)
+type PartialObserver<T> = {
   next?: (value: T) => void;
   error?: (err: any) => void;
   complete?: () => void;
 };
 
-export declare class PollingError extends BaseMediaClientError<
-  PollingErrorAttributes
-> {
-  readonly reason: PollingErrorReason;
-  readonly attempts: number;
+// @public (undocumented)
+export class PollingError extends BaseMediaClientError<PollingErrorAttributes> {
   constructor(reason: PollingErrorReason, attempts: number);
+  // (undocumented)
+  readonly attempts: number;
+  // (undocumented)
   get attributes(): {
     reason: 'pollingMaxAttemptsExceeded';
     attempts: number;
   };
+  // (undocumented)
+  readonly reason: PollingErrorReason;
 }
 
-export declare type PollingErrorAttributes = {
+// @public (undocumented)
+export type PollingErrorAttributes = {
   readonly reason: PollingErrorReason;
   readonly attempts: number;
   readonly innerError?: Error;
 };
 
-export declare type PollingErrorReason = 'pollingMaxAttemptsExceeded';
-
-/**
- * This class encapsulates polling functionality with the following features:
- *
- *  - async executor function provides each attempt
- *  - executor will only repeat defined max amount of times (options)
- *  - each attempt uses a timeout to the next attempt by an interval (ms)
- *  - each attempt increases the timeout interval by a "poll_backoffFactor"
- *  - if max attempts are exceeded or executor has exception then onError handler is called
- *
- * IMPORTANT! the executor function must explicitly call ".next()" for the next iteration to run
- */
-export declare class PollingFunction {
-  options: PollingOptions;
-  poll_intervalMs: number;
-  attempt: number;
-  shouldIterate: boolean;
-  onError?: (error: Error) => void;
-  timeoutId: number;
+// @public (undocumented)
+export type PollingErrorReason = 'pollingMaxAttemptsExceeded';
+
+// @public
+export class PollingFunction {
   constructor(options?: Partial<PollingOptions>);
+  // (undocumented)
+  attempt: number;
+  // (undocumented)
+  cancel(): void;
+  // (undocumented)
   execute(executor: Executor): Promise<void>;
-  private fail;
+  // (undocumented)
   getIntervalMsForIteration(iteration: number): number;
+  // (undocumented)
   next(): void;
-  cancel(): void;
+  // (undocumented)
+  onError?: (error: Error) => void;
+  // (undocumented)
+  options: PollingOptions;
+  // (undocumented)
+  poll_intervalMs: number;
+  // (undocumented)
+  shouldIterate: boolean;
+  // (undocumented)
+  timeoutId: number;
 }
 
-declare interface PollingOptions {
+// @public (undocumented)
+interface PollingOptions {
+  // (undocumented)
+  poll_backoffFactor: number;
+  // (undocumented)
   poll_intervalMs: number;
+  // (undocumented)
   poll_maxAttempts: number;
-  poll_backoffFactor: number;
+  // (undocumented)
   poll_maxIntervalMs: number;
 }
 
-export declare interface PreviewableFileState {
+// @public (undocumented)
+export interface PreviewableFileState {
+  // (undocumented)
   preview: FilePreview | Promise<FilePreview>;
 }
 
-export declare interface PreviewOptions {}
+// @public (undocumented)
+export interface PreviewOptions {}
 
-export declare interface ProcessedFileState {
-  status: 'processed';
-  id: string;
-  occurrenceKey?: string;
-  name: string;
-  size: number;
+// @public (undocumented)
+export interface ProcessedFileState {
+  // (undocumented)
   artifacts: MediaFileArtifacts;
+  // (undocumented)
+  createdAt?: number;
+  // (undocumented)
+  id: string;
+  // (undocumented)
   mediaType: MediaType;
+  // (undocumented)
   mimeType: string;
+  // (undocumented)
+  name: string;
+  // (undocumented)
+  occurrenceKey?: string;
+  // (undocumented)
   preview?: FilePreview | Promise<FilePreview>;
+  // (undocumented)
   representations?: MediaRepresentations;
-  createdAt?: number;
+  // (undocumented)
+  size: number;
+  // (undocumented)
+  status: 'processed';
 }
 
-export declare interface ProcessingFailedState {
-  status: 'failed-processing';
-  id: string;
-  occurrenceKey?: string;
-  name: string;
-  size: number;
+// @public (undocumented)
+export interface ProcessingFailedState {
+  // (undocumented)
   artifacts: Object;
+  // (undocumented)
+  createdAt?: number;
+  // (undocumented)
+  id: string;
+  // (undocumented)
   mediaType: MediaType;
+  // (undocumented)
   mimeType: string;
+  // (undocumented)
+  name: string;
+  // (undocumented)
+  occurrenceKey?: string;
+  // (undocumented)
   preview?: FilePreview | Promise<FilePreview>;
+  // (undocumented)
   representations?: MediaRepresentations;
-  createdAt?: number;
+  // (undocumented)
+  size: number;
+  // (undocumented)
+  status: 'failed-processing';
 }
 
-export declare interface ProcessingFileState {
-  status: 'processing';
-  id: string;
-  occurrenceKey?: string;
-  name: string;
-  size: number;
+// @public (undocumented)
+export interface ProcessingFileState {
+  // (undocumented)
   artifacts?: MediaFileArtifacts;
+  // (undocumented)
+  createdAt?: number;
+  // (undocumented)
+  id: string;
+  // (undocumented)
   mediaType: MediaType;
+  // (undocumented)
   mimeType: string;
+  // (undocumented)
+  name: string;
+  // (undocumented)
+  occurrenceKey?: string;
+  // (undocumented)
   preview?: FilePreview | Promise<FilePreview>;
+  // (undocumented)
   representations?: MediaRepresentations;
-  createdAt?: number;
+  // (undocumented)
+  size: number;
+  // (undocumented)
+  status: 'processing';
 }
 
-export declare const RECENTS_COLLECTION = 'recents';
+// @public (undocumented)
+export const RECENTS_COLLECTION = 'recents';
 
-export declare function request(
+// @public (undocumented)
+export function request(
   url: string,
   options?: RequestOptions,
   controller?: AbortController,
 ): Promise<Response>;
 
-export declare class RequestError extends BaseMediaClientError<
-  RequestErrorAttributes
-> {
-  readonly reason: RequestErrorReason;
-  readonly metadata?: RequestErrorMetadata | undefined;
-  readonly innerError?: Error | undefined;
+// @public (undocumented)
+export class RequestError extends BaseMediaClientError<RequestErrorAttributes> {
   constructor(
     reason: RequestErrorReason,
     metadata?: RequestErrorMetadata | undefined,
     innerError?: Error | undefined,
   );
+  // (undocumented)
   get attributes(): {
     reason: RequestErrorReason;
     method: RequestMethod | undefined;
@@ -1203,171 +1469,242 @@ export declare class RequestError extends BaseMediaClientError<
     statusCode: number | undefined;
     innerError: Error | undefined;
   };
+  // (undocumented)
+  readonly innerError?: Error | undefined;
+  // (undocumented)
+  readonly metadata?: RequestErrorMetadata | undefined;
+  // (undocumented)
+  readonly reason: RequestErrorReason;
 }
 
-export declare type RequestErrorAttributes = RequestErrorMetadata & {
+// @public (undocumented)
+export type RequestErrorAttributes = RequestErrorMetadata & {
   readonly reason: RequestErrorReason;
 };
 
-export declare type RequestErrorMetadata = RequestMetadata & {
+// @public (undocumented)
+export type RequestErrorMetadata = RequestMetadata & {
   readonly attempts?: number;
   readonly clientExhaustedRetries?: boolean;
   readonly statusCode?: number;
 };
 
-export declare type RequestErrorReason =
-  | 'clientOffline'
+// @public (undocumented)
+export type RequestErrorReason =
   | 'clientAbortedRequest'
+  | 'clientOffline'
   | 'clientTimeoutRequest'
-  | 'serverInvalidBody'
+  | 'serverBadGateway'
   | 'serverBadRequest'
-  | 'serverUnauthorized'
   | 'serverForbidden'
+  | 'serverInternalError'
+  | 'serverInvalidBody'
   | 'serverNotFound'
   | 'serverRateLimited'
-  | 'serverInternalError'
-  | 'serverBadGateway'
+  | 'serverUnauthorized'
   | 'serverUnexpectedError';
 
-export declare type RequestHeaders = {
+// @public (undocumented)
+export type RequestHeaders = {
   [key: string]: string;
 };
 
-export declare type RequestMetadata = {
+// @public (undocumented)
+export type RequestMetadata = {
   readonly method?: RequestMethod;
   readonly endpoint?: string;
   readonly mediaRegion?: string;
   readonly mediaEnv?: string;
 };
 
-export declare type RequestMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
+// @public (undocumented)
+export type RequestMethod = 'DELETE' | 'GET' | 'POST' | 'PUT';
 
-export declare type RequestOptions = RequestMetadata & {
+// @public (undocumented)
+export type RequestOptions = RequestMetadata & {
   readonly auth?: Auth;
+  readonly traceContext?: Required<MediaTraceContext>;
   readonly params?: RequestParams;
   readonly headers?: RequestHeaders;
   readonly body?: any;
   readonly clientOptions?: ClientOptions;
 };
 
-export declare type RequestParams = {
+// @public (undocumented)
+export type RequestParams = {
   [key: string]: any;
 };
 
-export declare interface ResponseFileItem {
+// @public (undocumented)
+export interface ResponseFileItem {
+  // (undocumented)
+  collection?: string;
+  // (undocumented)
+  details: MediaCollectionItemFullDetails;
+  // (undocumented)
   id: string;
+  // (undocumented)
   type: 'file';
-  details: MediaCollectionItemFullDetails;
-  collection?: string;
 }
 
-export declare type RetryOptions = {
+// @public (undocumented)
+export type RetryOptions = {
   readonly startTimeoutInMs: number;
   readonly maxAttempts: number;
   readonly factor: number;
 };
 
-export declare const safeUnsubscribe: (subscription: MediaSubscription) => void;
+// @public (undocumented)
+export const safeUnsubscribe: (subscription: MediaSubscription) => void;
 
-export declare interface SourceFile {
-  id: string;
-  owner: ClientAltBasedAuth | AsapBasedAuth;
+// @public (undocumented)
+export interface SourceFile {
+  // (undocumented)
   collection?: string;
+  // (undocumented)
+  id: string;
+  // (undocumented)
+  owner: AsapBasedAuth | ClientAltBasedAuth;
+  // (undocumented)
   version?: number;
 }
 
-export declare class StargateClient {
-  private baseUrl;
+// @public (undocumented)
+export class StargateClient {
   constructor(baseUrl: string | undefined);
+  // (undocumented)
   fetchToken(clientId: string): Promise<EdgeData>;
+  // (undocumented)
   isTokenExpired(token: EdgeData): boolean;
 }
 
-export declare type TouchedFiles = {
+// @public (undocumented)
+export type TouchedFiles = {
   created: CreatedTouchedFile[];
 };
 
-export declare interface TouchFileDescriptor {
-  fileId: string;
+// @public (undocumented)
+export interface TouchFileDescriptor {
+  // (undocumented)
   collection?: string;
-  occurrenceKey?: string;
-  expireAfter?: number;
+  // (undocumented)
   deletable?: boolean;
+  // (undocumented)
+  expireAfter?: number;
+  // (undocumented)
+  fileId: string;
+  // (undocumented)
+  occurrenceKey?: string;
 }
 
-export declare type UploadableFile = {
+// @public (undocumented)
+export type UploadableFile = {
   content: ChunkinatorFile;
   name?: string;
   mimeType?: string;
   collection?: string;
 };
 
-export declare type UploadableFileUpfrontIds = {
+// @public (undocumented)
+export type UploadableFileUpfrontIds = {
   id: string;
   deferredUploadId: Promise<string>;
   occurrenceKey?: string;
 };
 
-export declare class UploadController {
-  abortFunction?: AbortFunction;
+// @public (undocumented)
+export class UploadController {
   constructor();
-  setAbort(abortFunction: AbortFunction): void;
+  // (undocumented)
   abort(): void;
+  // (undocumented)
+  abortFunction?: AbortFunction;
+  // (undocumented)
+  setAbort(abortFunction: AbortFunction): void;
 }
 
-export declare type UploadEventPayloadMap = {
+// @public (undocumented)
+export type UploadEventPayloadMap = {
   'file-added': FileState;
   'media-viewed': MediaViewedEventPayload;
 };
 
-export declare const uploadFile: (
+// @public (undocumented)
+export const uploadFile: (
   file: UploadableFile,
   store: MediaStore,
   uploadableFileUpfrontIds: UploadableFileUpfrontIds,
   callbacks?: UploadFileCallbacks | undefined,
+  traceContext?: MediaTraceContext | undefined,
 ) => UploadFileResult;
 
-export declare type UploadFileCallbacks = {
+// @public (undocumented)
+export type UploadFileCallbacks = {
   onProgress: (progress: number) => void;
   onUploadFinish: (error?: any) => void;
 };
 
-export declare interface UploadFileResult {
+// @public (undocumented)
+export interface UploadFileResult {
+  // (undocumented)
   cancel: () => void;
 }
 
-export declare interface UploadingFileState {
-  status: 'uploading';
+// @public (undocumented)
+export interface UploadingFileState {
+  // (undocumented)
+  createdAt?: number;
+  // (undocumented)
   id: string;
-  occurrenceKey?: string;
-  name: string;
-  size: number;
-  progress: number;
+  // (undocumented)
   mediaType: MediaType;
+  // (undocumented)
   mimeType: string;
+  // (undocumented)
+  name: string;
+  // (undocumented)
+  occurrenceKey?: string;
+  // (undocumented)
   preview?: FilePreview | Promise<FilePreview>;
-  createdAt?: number;
+  // (undocumented)
+  progress: number;
+  // (undocumented)
+  size: number;
+  // (undocumented)
+  status: 'uploading';
 }
 
-export declare interface WithMediaClient {
-  mediaClient: MediaClient;
+// @public (undocumented)
+export interface WithMediaClient {
+  // (undocumented)
   identifier?: Identifier;
+  // (undocumented)
+  mediaClient: MediaClient;
 }
 
-export declare const withMediaClient: WithMediaClientFunction;
+// @public (undocumented)
+export const withMediaClient: WithMediaClientFunction;
 
-export declare interface WithMediaClientConfig {
+// @public (undocumented)
+export interface WithMediaClientConfig {
+  // (undocumented)
   mediaClientConfig: MediaClientConfig;
 }
 
-export declare type WithMediaClientConfigProps<
-  P extends WithMediaClient
-> = Omit<P, 'mediaClient'> & WithMediaClientConfig;
+// @public (undocumented)
+export type WithMediaClientConfigProps<P extends WithMediaClient> = Omit<
+  P,
+  'mediaClient'
+> &
+  WithMediaClientConfig;
 
-export declare type WithMediaClientFunction = <P extends WithMediaClient>(
+// @public (undocumented)
+export type WithMediaClientFunction = <P extends WithMediaClient>(
   Component: React_2.ComponentType<P>,
   featureFlags?: MediaFeatureFlags,
 ) => React_2.ComponentType<WithMediaClientConfigProps<P>>;
 
-export {};
+// (No @packageDocumentation comment for this package)
 ```
+
+<!--SECTION END: Main Entry Types-->