@atlaskit/media-client 24.0.1 → 24.0.3

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

@@ -0,0 +1,10 @@
+import { Subscription } from 'rxjs/Subscription';
+import { MediaSubscribable } from './types';
+import { FileState } from '@atlaskit/media-state';
+/**
+ * This is a helper to transform the first value emitted by an MediaSubscribable into a Promise.
+ *
+ * @param mediaSubscribable a given MediaSubscribable<MediaSubscribableItem>
+ * @param subscription a default Subscription (this parameter exists for testing purpose)
+ */
+export declare const toPromise: (mediaSubscribable: MediaSubscribable, subscription?: Subscription) => Promise<FileState>;

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

@@ -0,0 +1,17 @@
+import { FileState } from '@atlaskit/media-state';
+export type MediaSubscription = {
+    unsubscribe: () => void;
+};
+type PartialObserver = {
+    next?: (value: FileState) => void;
+    error?: (err: any) => void;
+    complete?: () => void;
+};
+export type NextObserver = PartialObserver & Required<Pick<PartialObserver, 'next'>>;
+export type ErrorObserver = PartialObserver & Required<Pick<PartialObserver, 'error'>>;
+export type CompletionObserver = PartialObserver & Required<Pick<PartialObserver, 'complete'>>;
+export type MediaObserver = NextObserver | ErrorObserver | CompletionObserver | ((value: FileState) => void);
+export type MediaSubscribable = {
+    subscribe(observer?: MediaObserver): MediaSubscription;
+};
+export {};

package/dist/types-ts4.5/utils/mobileUpload/error.d.ts

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

package/dist/types-ts4.5/utils/mobileUpload/helpers.d.ts

@@ -0,0 +1,8 @@
+import Dataloader from 'dataloader';
+import { ReplaySubject } from 'rxjs/ReplaySubject';
+import { Interpreter } from 'xstate';
+import { FileState } from '@atlaskit/media-state';
+import { DataloaderKey, DataloaderResult } from '../createFileDataLoader';
+import { StateMachineContext, StateMachineEvent, StateMachineTypestate } from './stateMachine/types';
+export declare const createMobileFileStateSubject: (service: Interpreter<StateMachineContext, any, StateMachineEvent, StateMachineTypestate>) => ReplaySubject<FileState>;
+export declare const createMobileDownloadFileStream: (dataloader: Dataloader<DataloaderKey, DataloaderResult>, id: string, collectionName?: string, occurrenceKey?: string) => ReplaySubject<FileState>;

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

@@ -0,0 +1,5 @@
+export { isMobileUploadError, MobileUploadError } from './error';
+export { createServicesCache } from './servicesCache';
+export { createMobileUploadService, createMobileUploadStateMachine, } from './stateMachine';
+export { createMobileFileStateSubject } from './helpers';
+export type { StateMachineContext, StateMachineSchema, StateMachineEvent, StateMachineTypestate, } from './stateMachine/types';

package/dist/types-ts4.5/utils/mobileUpload/servicesCache.d.ts

@@ -0,0 +1,4 @@
+import { LRUMap } from 'lru_map';
+import { Interpreter } from 'xstate';
+import { StateMachineContext, StateMachineEvent, StateMachineTypestate } from './stateMachine/types';
+export declare function createServicesCache(): LRUMap<string, Interpreter<StateMachineContext, any, StateMachineEvent, StateMachineTypestate>>;

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

@@ -0,0 +1,7 @@
+import DataLoader from 'dataloader';
+import { Interpreter, StateMachine } from 'xstate';
+import { UploadingFileState } from '@atlaskit/media-state';
+import { DataloaderKey, DataloaderResult } from '../../createFileDataLoader';
+import { StateMachineContext, StateMachineEvent, StateMachineSchema, StateMachineTypestate } from './types';
+export declare const createMobileUploadStateMachine: (dataloader: DataLoader<DataloaderKey, DataloaderResult>, initialState: UploadingFileState, collectionName?: string) => StateMachine<StateMachineContext, any, StateMachineEvent, StateMachineTypestate>;
+export declare function createMobileUploadService(machine: StateMachine<StateMachineContext, StateMachineSchema, StateMachineEvent, StateMachineTypestate>): Interpreter<StateMachineContext, StateMachineSchema, StateMachineEvent, StateMachineTypestate>;

package/dist/types-ts4.5/utils/mobileUpload/stateMachine/states/error.d.ts

@@ -0,0 +1,3 @@
+import { StateNodeConfig } from 'xstate';
+import { StateMachineContext, StateMachineSchema, StateMachineEvent } from '../types';
+export declare const machineErrorState: StateNodeConfig<StateMachineContext, StateMachineSchema, StateMachineEvent>;

package/dist/types-ts4.5/utils/mobileUpload/stateMachine/states/processed.d.ts

@@ -0,0 +1,3 @@
+import { StateNodeConfig } from 'xstate';
+import { StateMachineContext, StateMachineSchema, StateMachineEvent } from '../types';
+export declare const machineProcessedState: StateNodeConfig<StateMachineContext, StateMachineSchema, StateMachineEvent>;

package/dist/types-ts4.5/utils/mobileUpload/stateMachine/states/processing.d.ts

@@ -0,0 +1,3 @@
+import { StateNodeConfig } from 'xstate';
+import { ProcessingStateMachineSchema, StateMachineContext, StateMachineEvent } from '../types';
+export declare const machineProcessingState: StateNodeConfig<StateMachineContext, ProcessingStateMachineSchema, StateMachineEvent>;

package/dist/types-ts4.5/utils/mobileUpload/stateMachine/states/processingFailed.d.ts

@@ -0,0 +1,3 @@
+import { StateNodeConfig } from 'xstate';
+import { StateMachineContext, StateMachineSchema, StateMachineEvent } from '../types';
+export declare const machineProcessingFailedState: StateNodeConfig<StateMachineContext, StateMachineSchema, StateMachineEvent>;

package/dist/types-ts4.5/utils/mobileUpload/stateMachine/states/uploading.d.ts

@@ -0,0 +1,3 @@
+import { StateNodeConfig } from 'xstate';
+import { StateMachineContext, StateMachineSchema, StateMachineEvent } from '../types';
+export declare const machineUploadingState: StateNodeConfig<StateMachineContext, StateMachineSchema, StateMachineEvent>;

package/dist/types-ts4.5/utils/mobileUpload/stateMachine/types.d.ts

@@ -0,0 +1,69 @@
+import { StateSchema } from 'xstate';
+import { FileState, UploadingFileState, ProcessingFileState, ProcessedFileState, ErrorFileState, ProcessingFailedState } from '@atlaskit/media-state';
+export type StateMachineContext = {
+    currentFileState: FileState;
+};
+export type StateMachineEvent = {
+    type: 'UPLOAD_PROGRESS';
+    progress: number;
+} | {
+    type: 'UPLOAD_END';
+} | {
+    type: 'UPLOAD_ERROR';
+    message: string;
+} | {
+    type: 'REMOTE_FILESTATE_FETCH';
+} | {
+    type: 'REMOTE_FILESTATE_BYPASS';
+} | {
+    type: 'REMOTE_FILESTATE_RESULT';
+    fileState: FileState;
+} | {
+    type: 'REMOTE_FILESTATE_PROCESSED';
+} | {
+    type: 'REMOTE_FILESTATE_PROCESSING_FAILED';
+} | {
+    type: 'REMOTE_FILESTATE_ERROR';
+};
+export type ProcessingStateMachineSchema = StateSchema<StateMachineContext> & {
+    states: {
+        loading: StateSchema<StateMachineContext>;
+        fetchingRemoteFileStates: StateSchema<StateMachineContext>;
+        idle: StateSchema<StateMachineContext>;
+    };
+};
+export type StateMachineSchema = StateSchema<StateMachineContext> & {
+    states: {
+        uploading: StateSchema<StateMachineContext>;
+        processing: ProcessingStateMachineSchema;
+        processed: StateSchema<StateMachineContext>;
+        processingFailed: StateSchema<StateMachineContext>;
+        error: StateSchema<StateMachineContext>;
+    };
+};
+export type StateMachineTypestate = {
+    value: 'uploading';
+    context: {
+        currentFileState: UploadingFileState;
+    };
+} | {
+    value: 'processing';
+    context: {
+        currentFileState: ProcessingFileState;
+    };
+} | {
+    value: 'processed';
+    context: {
+        currentFileState: ProcessedFileState;
+    };
+} | {
+    value: 'processingFailed';
+    context: {
+        currentFileState: ProcessingFailedState;
+    };
+} | {
+    value: 'error';
+    context: {
+        currentFileState: ErrorFileState;
+    };
+};

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

@@ -0,0 +1,5 @@
+import { FileState } from '@atlaskit/media-state';
+import { MediaType } from '../models/media';
+export declare const overrideMediaTypeIfUnknown: (fileState: FileState, mediaType?: MediaType) => {
+    mediaType?: MediaType | undefined;
+};

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

@@ -0,0 +1,12 @@
+import { BaseMediaClientError } from '../../models/errors';
+import { PollingErrorReason, PollingErrorAttributes } from './types';
+export declare class PollingError extends BaseMediaClientError<PollingErrorAttributes> {
+    readonly reason: PollingErrorReason;
+    readonly attempts: number;
+    constructor(reason: PollingErrorReason, attempts: number);
+    get attributes(): {
+        reason: "pollingMaxAttemptsExceeded";
+        attempts: number;
+    };
+}
+export declare function isPollingError(err?: Error): err is PollingError;

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

@@ -0,0 +1,33 @@
+import { Executor } from './types';
+export interface PollingOptions {
+    poll_intervalMs: number;
+    poll_maxAttempts: number;
+    poll_backoffFactor: number;
+    poll_maxIntervalMs: number;
+}
+export declare const defaultPollingOptions: PollingOptions;
+/**
+ * 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;
+    constructor(options?: Partial<PollingOptions>);
+    execute(executor: Executor): Promise<void>;
+    private fail;
+    getIntervalMsForIteration(iteration: number): number;
+    next(): void;
+    cancel(): void;
+}

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

@@ -0,0 +1,7 @@
+export type Executor = () => Promise<void>;
+export type PollingErrorReason = 'pollingMaxAttemptsExceeded';
+export type PollingErrorAttributes = {
+    readonly reason: PollingErrorReason;
+    readonly attempts: number;
+    readonly innerError?: Error;
+};

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

@@ -0,0 +1,20 @@
+import { BaseMediaClientError } from '../../models/errors';
+import { RequestErrorReason, RequestErrorMetadata, RequestErrorAttributes } from './types';
+export declare class RequestError extends BaseMediaClientError<RequestErrorAttributes> {
+    readonly reason: RequestErrorReason;
+    readonly metadata?: RequestErrorMetadata | undefined;
+    readonly innerError?: Error | undefined;
+    constructor(reason: RequestErrorReason, metadata?: RequestErrorMetadata | undefined, innerError?: Error | undefined);
+    get attributes(): {
+        reason: RequestErrorReason;
+        method: import("./types").RequestMethod | undefined;
+        endpoint: string | undefined;
+        mediaRegion: string | undefined;
+        mediaEnv: string | undefined;
+        attempts: number | undefined;
+        clientExhaustedRetries: boolean | undefined;
+        statusCode: number | undefined;
+        innerError: Error | undefined;
+    };
+}
+export declare function isRequestError(err: Error): err is RequestError;

package/dist/types-ts4.5/utils/request/helpers.d.ts

@@ -0,0 +1,46 @@
+import { Auth } from '@atlaskit/media-core';
+import { MediaTraceContext } from '@atlaskit/media-common';
+import { RequestError } from './errors';
+import { CreateUrlOptions, RequestErrorReason, RequestErrorMetadata, RequestHeaders, RequestMetadata, RetryOptions } from './types';
+export declare function clientTimeoutPromise(timeout: number): Promise<Response>;
+export declare function waitPromise(timeout: number): Promise<void>;
+export declare function isAbortedRequestError(err: any): boolean;
+export declare function isFetchNetworkError(err: any): err is TypeError;
+export declare function isRateLimitedError(error: Error | undefined): boolean;
+export declare const ZipkinHeaderKeys: {
+    traceId: string;
+    spanId: string;
+    parentSpanId: string;
+    sampled: string;
+    flags: string;
+};
+export declare function mapAuthToRequestHeaders(auth?: Auth): RequestHeaders;
+export declare function createUrl(url: string, { params, auth }: CreateUrlOptions): string;
+export declare function extendHeaders(headers?: RequestHeaders, auth?: Auth, traceContext?: Required<MediaTraceContext>): RequestHeaders | undefined;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+export declare function createMapResponseToJson(metadata: RequestMetadata): (response: Response) => Promise<any>;
+export declare function createMapResponseToBlob(metadata: RequestMetadata): (response: Response) => Promise<Blob>;
+export declare const DEFAULT_RETRY_OPTIONS: RetryOptions;
+export declare function cloneRequestError(error: RequestError, extraMetadata: Partial<RequestErrorMetadata>): RequestError;
+export declare function fetchRetry(functionToRetry: () => Promise<Response>, metadata: RequestMetadata, overwriteOptions?: Partial<RetryOptions>): Promise<Response>;
+export declare function createRequestErrorReason(statusCode: number): RequestErrorReason;
+export declare function createRequestErrorFromResponse(metadata: RequestErrorMetadata, response: Response): RequestError;
+export declare function createProcessFetchResponse(metadata: RequestMetadata): (response: Response) => Response;
+export declare function extractMediaHeaders(response: Response): {
+    mediaRegion: string;
+    mediaEnv: string;
+};

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

@@ -0,0 +1,5 @@
+import { RequestOptions } from './types';
+export type { RequestErrorReason, RequestErrorMetadata, RequestErrorAttributes, } from './types';
+export { RequestError, isRequestError } from './errors';
+export { isRateLimitedError, createRequestErrorReason } from './helpers';
+export declare function request(url: string, options?: RequestOptions, controller?: AbortController): Promise<Response>;

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

@@ -0,0 +1,46 @@
+import { Auth } from '@atlaskit/media-core';
+import type { MediaTraceContext } from '@atlaskit/media-common';
+export type RequestMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
+export type RequestParams = {
+    [key: string]: any;
+};
+export type RequestHeaders = {
+    [key: string]: string;
+};
+export type RetryOptions = {
+    readonly startTimeoutInMs: number;
+    readonly maxAttempts: number;
+    readonly factor: number;
+};
+export type ClientOptions = {
+    readonly retryOptions?: Partial<RetryOptions>;
+    readonly clientTimeout?: number;
+};
+export type RequestMetadata = {
+    readonly method?: RequestMethod;
+    readonly endpoint?: string;
+    readonly mediaRegion?: string;
+    readonly mediaEnv?: string;
+    readonly traceContext?: MediaTraceContext;
+};
+export type RequestOptions = RequestMetadata & {
+    readonly auth?: Auth;
+    readonly traceContext?: Required<MediaTraceContext>;
+    readonly params?: RequestParams;
+    readonly headers?: RequestHeaders;
+    readonly body?: any;
+    readonly clientOptions?: ClientOptions;
+};
+export type CreateUrlOptions = {
+    readonly params?: RequestParams;
+    readonly auth?: Auth;
+};
+export type RequestErrorReason = 'clientOffline' | 'clientAbortedRequest' | 'clientTimeoutRequest' | 'serverInvalidBody' | 'serverBadRequest' | 'serverUnauthorized' | 'serverForbidden' | 'serverNotFound' | 'serverRateLimited' | 'serverInternalError' | 'serverBadGateway' | 'serverUnexpectedError';
+export type RequestErrorMetadata = RequestMetadata & {
+    readonly attempts?: number;
+    readonly clientExhaustedRetries?: boolean;
+    readonly statusCode?: number;
+};
+export type RequestErrorAttributes = RequestErrorMetadata & {
+    readonly reason: RequestErrorReason;
+};

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

@@ -0,0 +1,2 @@
+import { MediaSubscription } from './mediaSubscribable';
+export declare const safeUnsubscribe: (subscription: MediaSubscription) => void;

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

@@ -0,0 +1,2 @@
+export declare const resolveTimeout: <T>(timeout: number, resolveWith: T) => Promise<T>;
+export declare const rejectTimeout: (timeout: number, rejectWith: Error) => Promise<undefined>;

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

@@ -0,0 +1,14 @@
+import { FilePreview } from '@atlaskit/media-state';
+import { MediaType } from '../models/media';
+/**
+ * Async helper determining if we should fetch remote fileStates from the backend:
+ * - we poll the backend for all supported documents,
+ * - we poll the backend is mimeType isn't natively supported by the browser,
+ * - we poll the backend if we don't have a local preview available.
+ * - we poll the backend if we have a video with which we can't extract dimensions,
+ *
+ * Polling the backend periodically refreshes the cached fileState until the file is processed.
+ * Polling is needed for the use cases above to properly render the file in our components.
+ *
+ */
+export declare function shouldFetchRemoteFileStates(mediaType: MediaType, mimeType: string, preview?: FilePreview | Promise<FilePreview>): Promise<boolean>;

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

@@ -0,0 +1,17 @@
+export declare const isMediaBlobUrl: (url: string) => boolean;
+export interface MediaBlobUrlAttrs {
+    id: string;
+    contextId: string;
+    collection?: string;
+    size?: number;
+    name?: string;
+    mimeType?: string;
+    width?: number;
+    height?: number;
+    alt?: string;
+}
+export declare const getAttrsFromUrl: (blobUrl: string) => MediaBlobUrlAttrs | undefined;
+export declare const objectToQueryString: (json: {
+    [key: string]: string | number | boolean | null | undefined;
+}) => string;
+export declare const addFileAttrsToUrl: (url: string, fileAttrs: MediaBlobUrlAttrs) => string;

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

@@ -0,0 +1,33 @@
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaskit/media-client",
-  "version": "24.0.1",
+  "version": "24.0.3",
   "description": "Media API Web Client Library",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
@@ -67,7 +67,7 @@
     "@atlaskit/media-core": "^34.1.0",
     "@atlaskit/media-state": "^1.0.0",
     "@atlaskit/ssr": "*",
-    "@atlaskit/tokens": "^1.25.0",
+    "@atlaskit/tokens": "^1.28.0",
     "@atlassian/atlassian-frontend-prettier-config-1.0.1": "npm:@atlassian/atlassian-frontend-prettier-config@1.0.1",
     "@emotion/react": "^11.7.1",
     "@types/deep-equal": "^1.0.1",

package/report.api.md

@@ -448,7 +448,7 @@ export interface GetFileOptions {
 // @public (undocumented)
 export const getFileStreamsCache: () => StreamsCache<FileState>;
 
-// @public (undocumented)
+// @public @deprecated (undocumented)
 export const getMediaClient: (
   mediaClientConfig: MediaClientConfig,
 ) => MediaClient;
@@ -1517,7 +1517,7 @@ export interface UploadFileResult {
 
 export { UploadingFileState };
 
-// @public (undocumented)
+// @public @deprecated (undocumented)
 export interface WithMediaClient {
   // (undocumented)
   identifier?: Identifier;
@@ -1525,23 +1525,23 @@ export interface WithMediaClient {
   mediaClient: MediaClient;
 }
 
-// @public (undocumented)
+// @public @deprecated (undocumented)
 export const withMediaClient: WithMediaClientFunction;
 
-// @public (undocumented)
+// @public @deprecated (undocumented)
 export interface WithMediaClientConfig {
   // (undocumented)
   mediaClientConfig: MediaClientConfig;
 }
 
-// @public (undocumented)
+// @public @deprecated (undocumented)
 export type WithMediaClientConfigProps<P extends WithMediaClient> = Omit<
   P,
   'mediaClient'
 > &
   WithMediaClientConfig;
 
-// @public (undocumented)
+// @public @deprecated (undocumented)
 export type WithMediaClientFunction = <P extends WithMediaClient>(
   Component: React_2.ComponentType<P>,
 ) => React_2.ComponentType<WithMediaClientConfigProps<P>>;