@aws-amplify/storage 6.0.17-unstable.e316a2e.0 → 6.0.17

package/src/providers/s3/apis/server/getProperties.ts

@@ -5,15 +5,16 @@ import {
 	AmplifyServer,
 	getAmplifyServerContext,
 } from '@aws-amplify/core/internals/adapter-core';
+
 import { GetPropertiesInput, GetPropertiesOutput } from '../../types';
 import { getProperties as getPropertiesInternal } from '../internal/getProperties';
 
 export const getProperties = (
 	contextSpec: AmplifyServer.ContextSpec,
-	input: GetPropertiesInput
+	input: GetPropertiesInput,
 ): Promise<GetPropertiesOutput> => {
 	return getPropertiesInternal(
 		getAmplifyServerContext(contextSpec).amplify,
-		input
+		input,
 	);
 };

package/src/providers/s3/apis/server/getUrl.ts

@@ -5,12 +5,13 @@ import {
 	AmplifyServer,
 	getAmplifyServerContext,
 } from '@aws-amplify/core/internals/adapter-core';
+
 import { GetUrlInput, GetUrlOutput } from '../../types';
 import { getUrl as getUrlInternal } from '../internal/getUrl';
 
 export const getUrl = async (
 	contextSpec: AmplifyServer.ContextSpec,
-	input: GetUrlInput
+	input: GetUrlInput,
 ): Promise<GetUrlOutput> => {
 	return getUrlInternal(getAmplifyServerContext(contextSpec).amplify, input);
 };

package/src/providers/s3/apis/server/list.ts

@@ -5,15 +5,18 @@ import {
 	AmplifyServer,
 	getAmplifyServerContext,
 } from '@aws-amplify/core/internals/adapter-core';
+
 import {
 	ListAllInput,
-	ListPaginateInput,
 	ListAllOutput,
+	ListPaginateInput,
 	ListPaginateOutput,
+	S3Exception,
 } from '../../types';
 import { list as listInternal } from '../internal/list';
+import { StorageValidationErrorCode } from '../../../../errors/types/validation';
 
-type ListApi = {
+interface ListApi {
 	/**
 	 * Lists bucket objects with pagination.
 	 * @param {ListPaginateInput} The input object
@@ -24,7 +27,7 @@ type ListApi = {
 	 */
 	(
 		contextSpec: AmplifyServer.ContextSpec,
-		input?: ListPaginateInput
+		input?: ListPaginateInput,
 	): Promise<ListPaginateOutput>;
 	/**
 	 * Lists all bucket objects.
@@ -35,16 +38,16 @@ type ListApi = {
 	 */
 	(
 		contextSpec: AmplifyServer.ContextSpec,
-		input?: ListAllInput
+		input?: ListAllInput,
 	): Promise<ListAllOutput>;
-};
+}
 
 export const list: ListApi = (
 	contextSpec: AmplifyServer.ContextSpec,
-	input?: ListAllInput | ListPaginateInput
+	input?: ListAllInput | ListPaginateInput,
 ): Promise<ListAllOutput | ListPaginateOutput> => {
 	return listInternal(
 		getAmplifyServerContext(contextSpec).amplify,
-		input ?? {}
+		input ?? {},
 	);
 };

package/src/providers/s3/apis/server/remove.ts

@@ -5,12 +5,13 @@ import {
 	AmplifyServer,
 	getAmplifyServerContext,
 } from '@aws-amplify/core/internals/adapter-core';
+
 import { RemoveInput, RemoveOutput } from '../../types';
 import { remove as removeInternal } from '../internal/remove';
 
 export const remove = (
 	contextSpec: AmplifyServer.ContextSpec,
-	input: RemoveInput
+	input: RemoveInput,
 ): Promise<RemoveOutput> => {
 	return removeInternal(getAmplifyServerContext(contextSpec).amplify, input);
 };

package/src/providers/s3/apis/uploadData/byteLength.ts

@@ -25,6 +25,7 @@ export const byteLength = (input?: any): number | undefined => {
 		// handles browser File object
 		return input.size;
 	}
+
 	// TODO: support Node.js stream size when Node.js runtime is supported out-of-box.
 	return undefined;
 };

package/src/providers/s3/apis/uploadData/index.ts

@@ -1,11 +1,12 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-import { UploadDataInput, UploadDataOutput, S3Exception } from '../../types';
+import { S3Exception, UploadDataInput, UploadDataOutput } from '../../types';
 import { createUploadTask } from '../../utils';
 import { assertValidationError } from '../../../../errors/utils/assertValidationError';
 import { StorageValidationErrorCode } from '../../../../errors/types/validation';
 import { DEFAULT_PART_SIZE, MAX_OBJECT_SIZE } from '../../utils/constants';
+
 import { byteLength } from './byteLength';
 import { putObjectJob } from './putObjectJob';
 import { getMultipartUploadHandlers } from './multipart';
@@ -64,11 +65,12 @@ export const uploadData = (input: UploadDataInput): UploadDataOutput => {
 	const dataByteLength = byteLength(data);
 	assertValidationError(
 		dataByteLength === undefined || dataByteLength <= MAX_OBJECT_SIZE,
-		StorageValidationErrorCode.ObjectIsTooLarge
+		StorageValidationErrorCode.ObjectIsTooLarge,
 	);
 
 	if (dataByteLength && dataByteLength <= DEFAULT_PART_SIZE) {
 		const abortController = new AbortController();
+
 		return createUploadTask({
 			isMultipartUpload: false,
 			job: putObjectJob(input, abortController.signal, dataByteLength),
@@ -79,6 +81,7 @@ export const uploadData = (input: UploadDataInput): UploadDataOutput => {
 	} else {
 		const { multipartUploadJob, onPause, onResume, onCancel } =
 			getMultipartUploadHandlers(input, dataByteLength);
+
 		return createUploadTask({
 			isMultipartUpload: true,
 			job: multipartUploadJob,

package/src/providers/s3/apis/uploadData/multipart/calculatePartSize.ts

@@ -13,5 +13,6 @@ export const calculatePartSize = (totalSize?: number): number => {
 		partSize *= 2;
 		partsCount = Math.ceil(totalSize / partSize);
 	}
+
 	return partSize;
 };

package/src/providers/s3/apis/uploadData/multipart/getDataChunker.ts

@@ -7,17 +7,18 @@ import {
 	validationErrorMap,
 } from '../../../../../errors/types/validation';
 import { StorageError } from '../../../../../errors/StorageError';
+
 import { calculatePartSize } from './calculatePartSize';
 
-export type PartToUpload = {
+export interface PartToUpload {
 	partNumber: number;
 	data: Blob | ArrayBuffer | string;
 	size: number;
-};
+}
 
 export const getDataChunker = (
 	data: StorageUploadDataPayload,
-	totalSize?: number
+	totalSize?: number,
 ): Generator<PartToUpload, void, undefined> => {
 	const partSize = calculatePartSize(totalSize);
 
@@ -29,6 +30,7 @@ export const getDataChunker = (
 		return helper(data, 0, data.byteLength, partSize);
 	} else if (typeof data === 'string') {
 		const blob = new Blob([data]);
+
 		return getDataChunker(blob, blob.size);
 	} else {
 		throw new StorageError({
@@ -42,7 +44,7 @@ const helper = function* (
 	buffer: ArrayBuffer | Blob,
 	byteOffset: number,
 	byteLength: number,
-	partSize: number
+	partSize: number,
 ): Generator<PartToUpload, void, undefined> {
 	let partNumber = 1;
 	let startByte = byteOffset;

package/src/providers/s3/apis/uploadData/multipart/initialUpload.ts

@@ -3,17 +3,18 @@
 
 import { StorageAccessLevel } from '@aws-amplify/core';
 
+import { ResolvedS3Config } from '../../../types/options';
+import { StorageUploadDataPayload } from '../../../../../types';
+import { Part, createMultipartUpload } from '../../../utils/client';
+import { logger } from '../../../../../utils';
+
 import {
 	cacheMultipartUpload,
 	findCachedUploadParts,
 	getUploadsCacheKey,
 } from './uploadCache';
-import { ResolvedS3Config } from '../../../types/options';
-import { StorageUploadDataPayload } from '../../../../../types';
-import { Part, createMultipartUpload } from '../../../utils/client';
-import { logger } from '../../../../../utils';
 
-type LoadOrCreateMultipartUploadOptions = {
+interface LoadOrCreateMultipartUploadOptions {
 	s3Config: ResolvedS3Config;
 	data: StorageUploadDataPayload;
 	bucket: string;
@@ -26,12 +27,12 @@ type LoadOrCreateMultipartUploadOptions = {
 	metadata?: Record<string, string>;
 	size?: number;
 	abortSignal?: AbortSignal;
-};
+}
 
-type LoadOrCreateMultipartUploadResult = {
+interface LoadOrCreateMultipartUploadResult {
 	uploadId: string;
 	cachedParts: Part[];
-};
+}
 
 /**
  * Load the in-progress multipart upload from local storage or async storage(RN) if it exists, or create a new multipart
@@ -103,10 +104,11 @@ export const loadOrCreateMultipartUpload = async ({
 				ContentDisposition: contentDisposition,
 				ContentEncoding: contentEncoding,
 				Metadata: metadata,
-			}
+			},
 		);
 		if (size === undefined) {
 			logger.debug('uploaded data size cannot be determined, skipping cache.');
+
 			return {
 				uploadId: UploadId!,
 				cachedParts: [],
@@ -126,6 +128,7 @@ export const loadOrCreateMultipartUpload = async ({
 			key,
 			fileName: data instanceof File ? data.name : '',
 		});
+
 		return {
 			uploadId: UploadId!,
 			cachedParts: [],

package/src/providers/s3/apis/uploadData/multipart/progressTracker.ts

@@ -3,10 +3,10 @@
 
 import { TransferProgressEvent } from '../../../../../types';
 
-type ConcurrentUploadsProgressTrackerOptions = {
+interface ConcurrentUploadsProgressTrackerOptions {
 	size?: number;
-	onProgress?: (event: TransferProgressEvent) => void;
-};
+	onProgress?(event: TransferProgressEvent): void;
+}
 
 /**
  * Track the progress from multiple concurrent uploads, and invoke the onProgress callback.
@@ -22,13 +22,14 @@ export const getConcurrentUploadsProgressTracker = ({
 	const getTransferredBytes = () =>
 		transferredBytesPerListener.reduce(
 			(acc, transferredBytes) => acc + transferredBytes,
-			0
+			0,
 		);
 
 	return {
 		getOnProgressListener: () => {
 			transferredBytesPerListener.push(0);
 			const listenerIndex = transferredBytesPerListener.length - 1;
+
 			return (event: TransferProgressEvent) => {
 				const { transferredBytes } = event;
 				transferredBytesPerListener[listenerIndex] = transferredBytes;

package/src/providers/s3/apis/uploadData/multipart/uploadCache.ts

@@ -2,9 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import {
-	defaultStorage,
 	KeyValueStorageInterface,
 	StorageAccessLevel,
+	defaultStorage,
 } from '@aws-amplify/core';
 
 import { UPLOADS_STORAGE_KEY } from '../../../utils/constants';
@@ -14,12 +14,12 @@ import { logger } from '../../../../../utils';
 
 const ONE_HOUR = 1000 * 60 * 60;
 
-type FindCachedUploadPartsOptions = {
+interface FindCachedUploadPartsOptions {
 	cacheKey: string;
 	s3Config: ResolvedS3Config;
 	bucket: string;
 	finalKey: string;
-};
+}
 
 /**
  * Find the cached multipart upload id and get the parts that have been uploaded
@@ -47,7 +47,7 @@ export const findCachedUploadParts = async ({
 
 	await defaultStorage.setItem(
 		UPLOADS_STORAGE_KEY,
-		JSON.stringify(cachedUploads)
+		JSON.stringify(cachedUploads),
 	);
 
 	try {
@@ -56,6 +56,7 @@ export const findCachedUploadParts = async ({
 			Key: finalKey,
 			UploadId: cachedUpload.uploadId,
 		});
+
 		return {
 			parts: Parts,
 			uploadId: cachedUpload.uploadId,
@@ -63,38 +64,40 @@ export const findCachedUploadParts = async ({
 	} catch (e) {
 		logger.debug('failed to list cached parts, removing cached upload.');
 		await removeCachedUpload(cacheKey);
+
 		return null;
 	}
 };
 
-type FileMetadata = {
+interface FileMetadata {
 	bucket: string;
 	fileName: string;
 	key: string;
 	uploadId: string;
 	// Unix timestamp in ms
 	lastTouched: number;
-};
+}
 
 const listCachedUploadTasks = async (
-	kvStorage: KeyValueStorageInterface
+	kvStorage: KeyValueStorageInterface,
 ): Promise<Record<string, FileMetadata>> => {
 	try {
 		return JSON.parse((await kvStorage.getItem(UPLOADS_STORAGE_KEY)) ?? '{}');
 	} catch (e) {
 		logger.debug('failed to parse cached uploads record.');
+
 		return {};
 	}
 };
 
-type UploadsCacheKeyOptions = {
+interface UploadsCacheKeyOptions {
 	size: number;
 	contentType?: string;
 	bucket: string;
 	accessLevel: StorageAccessLevel;
 	key: string;
 	file?: File;
-};
+}
 
 /**
  * Get the cache key of a multipart upload. Data source cached by different: size, content type, bucket, access level,
@@ -122,7 +125,7 @@ export const getUploadsCacheKey = ({
 
 export const cacheMultipartUpload = async (
 	cacheKey: string,
-	fileMetadata: Omit<FileMetadata, 'lastTouched'>
+	fileMetadata: Omit<FileMetadata, 'lastTouched'>,
 ): Promise<void> => {
 	const cachedUploads = await listCachedUploadTasks(defaultStorage);
 	cachedUploads[cacheKey] = {
@@ -131,7 +134,7 @@ export const cacheMultipartUpload = async (
 	};
 	await defaultStorage.setItem(
 		UPLOADS_STORAGE_KEY,
-		JSON.stringify(cachedUploads)
+		JSON.stringify(cachedUploads),
 	);
 };
 
@@ -140,6 +143,6 @@ export const removeCachedUpload = async (cacheKey: string): Promise<void> => {
 	delete cachedUploads[cacheKey];
 	await defaultStorage.setItem(
 		UPLOADS_STORAGE_KEY,
-		JSON.stringify(cachedUploads)
+		JSON.stringify(cachedUploads),
 	);
 };

package/src/providers/s3/apis/uploadData/multipart/uploadHandlers.ts

@@ -4,7 +4,6 @@
 import { Amplify, StorageAccessLevel } from '@aws-amplify/core';
 import { StorageAction } from '@aws-amplify/core/internals/utils';
 
-import { getDataChunker } from './getDataChunker';
 import { UploadDataInput } from '../../../types';
 import { resolveS3ConfigAndInput } from '../../../utils';
 import { Item as S3Item } from '../../../types/outputs';
@@ -12,11 +11,7 @@ import {
 	DEFAULT_ACCESS_LEVEL,
 	DEFAULT_QUEUE_SIZE,
 } from '../../../utils/constants';
-import { loadOrCreateMultipartUpload } from './initialUpload';
 import { ResolvedS3Config } from '../../../types/options';
-import { getConcurrentUploadsProgressTracker } from './progressTracker';
-import { getUploadsCacheKey, removeCachedUpload } from './uploadCache';
-import { uploadPartExecutor } from './uploadPartExecutor';
 import { StorageError } from '../../../../../errors/StorageError';
 import { CanceledError } from '../../../../../errors/CanceledError';
 import {
@@ -28,6 +23,12 @@ import {
 import { getStorageUserAgentValue } from '../../../utils/userAgent';
 import { logger } from '../../../../../utils';
 
+import { uploadPartExecutor } from './uploadPartExecutor';
+import { getUploadsCacheKey, removeCachedUpload } from './uploadCache';
+import { getConcurrentUploadsProgressTracker } from './progressTracker';
+import { loadOrCreateMultipartUpload } from './initialUpload';
+import { getDataChunker } from './getDataChunker';
+
 /**
  * Create closure hiding the multipart upload implementation details and expose the upload job and control functions(
  * onPause, onResume, onCancel).
@@ -36,7 +37,7 @@ import { logger } from '../../../../../utils';
  */
 export const getMultipartUploadHandlers = (
 	{ options: uploadDataOptions, key, data }: UploadDataInput,
-	size?: number
+	size?: number,
 ) => {
 	let resolveCallback: ((value: S3Item) => void) | undefined;
 	let rejectCallback: ((reason?: any) => void) | undefined;
@@ -46,24 +47,25 @@ export const getMultipartUploadHandlers = (
 				completedParts: Part[];
 		  }
 		| undefined;
-	let s3Config: ResolvedS3Config | undefined;
+	let resolvedS3Config: ResolvedS3Config | undefined;
 	let abortController: AbortController | undefined;
-	let bucket: string | undefined;
-	let keyPrefix: string | undefined;
+	let resolvedBucket: string | undefined;
+	let resolvedKeyPrefix: string | undefined;
 	let uploadCacheKey: string | undefined;
 	// Special flag that differentiates HTTP requests abort error caused by pause() from ones caused by cancel().
 	// The former one should NOT cause the upload job to throw, but cancels any pending HTTP requests.
 	// This should be replaced by a special abort reason. However,the support of this API is lagged behind.
-	let isAbortSignalFromPause: boolean = false;
+	let isAbortSignalFromPause = false;
 
 	const startUpload = async (): Promise<S3Item> => {
 		const resolvedS3Options = await resolveS3ConfigAndInput(
 			Amplify,
-			uploadDataOptions
+			uploadDataOptions,
 		);
-		s3Config = resolvedS3Options.s3Config;
-		bucket = resolvedS3Options.bucket;
-		keyPrefix = resolvedS3Options.keyPrefix;
+
+		resolvedS3Config = resolvedS3Options.s3Config;
+		resolvedBucket = resolvedS3Options.bucket;
+		resolvedKeyPrefix = resolvedS3Options.keyPrefix;
 
 		abortController = new AbortController();
 		isAbortSignalFromPause = false;
@@ -79,10 +81,10 @@ export const getMultipartUploadHandlers = (
 
 		if (!inProgressUpload) {
 			const { uploadId, cachedParts } = await loadOrCreateMultipartUpload({
-				s3Config,
+				s3Config: resolvedS3Config,
 				accessLevel: resolveAccessLevel(accessLevel),
-				bucket,
-				keyPrefix,
+				bucket: resolvedBucket,
+				keyPrefix: resolvedKeyPrefix,
 				key,
 				contentType,
 				contentDisposition,
@@ -98,21 +100,21 @@ export const getMultipartUploadHandlers = (
 			};
 		}
 
-		const finalKey = keyPrefix + key;
+		const finalKey = resolvedKeyPrefix + key;
 		uploadCacheKey = size
 			? getUploadsCacheKey({
 					file: data instanceof File ? data : undefined,
 					accessLevel: resolveAccessLevel(uploadDataOptions?.accessLevel),
 					contentType: uploadDataOptions?.contentType,
-					bucket: bucket!,
+					bucket: resolvedBucket!,
 					size,
 					key,
-			  })
+				})
 			: undefined;
 
 		const dataChunker = getDataChunker(data, size);
 		const completedPartNumberSet = new Set<number>(
-			inProgressUpload.completedParts.map(({ PartNumber }) => PartNumber!)
+			inProgressUpload.completedParts.map(({ PartNumber }) => PartNumber!),
 		);
 		const onPartUploadCompletion = (partNumber: number, eTag: string) => {
 			inProgressUpload?.completedParts.push({
@@ -132,15 +134,15 @@ export const getMultipartUploadHandlers = (
 				uploadPartExecutor({
 					dataChunkerGenerator: dataChunker,
 					completedPartNumberSet,
-					s3Config,
+					s3Config: resolvedS3Config,
 					abortSignal: abortController.signal,
-					bucket,
+					bucket: resolvedBucket,
 					finalKey,
 					uploadId: inProgressUpload.uploadId,
 					onPartUploadCompletion,
 					onProgress: concurrentUploadsProgressTracker.getOnProgressListener(),
 					isObjectLockEnabled: resolvedS3Options.isObjectLockEnabled,
-				})
+				}),
 			);
 		}
 
@@ -148,27 +150,30 @@ export const getMultipartUploadHandlers = (
 
 		const { ETag: eTag } = await completeMultipartUpload(
 			{
-				...s3Config,
+				...resolvedS3Config,
 				abortSignal: abortController.signal,
 				userAgentValue: getStorageUserAgentValue(StorageAction.UploadData),
 			},
 			{
-				Bucket: bucket,
+				Bucket: resolvedBucket,
 				Key: finalKey,
 				UploadId: inProgressUpload.uploadId,
 				MultipartUpload: {
 					Parts: inProgressUpload.completedParts.sort(
-						(partA, partB) => partA.PartNumber! - partB.PartNumber!
+						(partA, partB) => partA.PartNumber! - partB.PartNumber!,
 					),
 				},
-			}
+			},
 		);
 
 		if (size) {
-			const { ContentLength: uploadedObjectSize } = await headObject(s3Config, {
-				Bucket: bucket,
-				Key: finalKey,
-			});
+			const { ContentLength: uploadedObjectSize } = await headObject(
+				resolvedS3Config,
+				{
+					Bucket: resolvedBucket,
+					Key: finalKey,
+				},
+			);
 			if (uploadedObjectSize && uploadedObjectSize !== size) {
 				throw new StorageError({
 					name: 'Error',
@@ -225,9 +230,9 @@ export const getMultipartUploadHandlers = (
 				await removeCachedUpload(uploadCacheKey);
 			}
 			// 3. clear multipart upload on server side.
-			await abortMultipartUpload(s3Config!, {
-				Bucket: bucket,
-				Key: keyPrefix! + key,
+			await abortMultipartUpload(resolvedS3Config!, {
+				Bucket: resolvedBucket,
+				Key: resolvedKeyPrefix! + key,
 				UploadId: inProgressUpload?.uploadId,
 			});
 		};
@@ -238,9 +243,10 @@ export const getMultipartUploadHandlers = (
 		rejectCallback!(
 			// Internal error that should not be exposed to the users. They should use isCancelError() to check if
 			// the error is caused by cancel().
-			new CanceledError(message ? { message } : undefined)
+			new CanceledError(message ? { message } : undefined),
 		);
 	};
+
 	return {
 		multipartUploadJob,
 		onPause,

package/src/providers/s3/apis/uploadData/multipart/uploadPartExecutor.ts

@@ -1,14 +1,15 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-import { PartToUpload } from './getDataChunker';
 import { TransferProgressEvent } from '../../../../../types';
 import { ResolvedS3Config } from '../../../types/options';
 import { calculateContentMd5 } from '../../../utils';
 import { uploadPart } from '../../../utils/client';
 import { logger } from '../../../../../utils';
 
-type UploadPartExecutorOptions = {
+import { PartToUpload } from './getDataChunker';
+
+interface UploadPartExecutorOptions {
 	dataChunkerGenerator: Generator<PartToUpload, void, undefined>;
 	completedPartNumberSet: Set<number>;
 	s3Config: ResolvedS3Config;
@@ -17,9 +18,9 @@ type UploadPartExecutorOptions = {
 	finalKey: string;
 	uploadId: string;
 	isObjectLockEnabled?: boolean;
-	onPartUploadCompletion: (partNumber: number, eTag: string) => void;
-	onProgress?: (event: TransferProgressEvent) => void;
-};
+	onPartUploadCompletion(partNumber: number, eTag: string): void;
+	onProgress?(event: TransferProgressEvent): void;
+}
 
 export const uploadPartExecutor = async ({
 	dataChunkerGenerator,
@@ -68,7 +69,7 @@ export const uploadPartExecutor = async ({
 					ContentMD5: isObjectLockEnabled
 						? await calculateContentMd5(data)
 						: undefined,
-				}
+				},
 			);
 			transferredBytes += size;
 			// eTag will always be set even the S3 model interface marks it as optional.

package/src/providers/s3/apis/uploadData/putObjectJob.ts

@@ -19,7 +19,7 @@ export const putObjectJob =
 	(
 		{ options: uploadDataOptions, key, data }: UploadDataInput,
 		abortSignal: AbortSignal,
-		totalLength?: number
+		totalLength?: number,
 	) =>
 	async (): Promise<S3Item> => {
 		const { bucket, keyPrefix, s3Config, isObjectLockEnabled } =
@@ -52,7 +52,7 @@ export const putObjectJob =
 				ContentMD5: isObjectLockEnabled
 					? await calculateContentMd5(data)
 					: undefined,
-			}
+			},
 		);
 
 		return {

package/src/providers/s3/types/inputs.ts

@@ -3,23 +3,23 @@
 
 import {
 	StorageCopyInput,
+	StorageDownloadDataInput,
 	StorageGetPropertiesInput,
 	StorageGetUrlInput,
 	StorageListInput,
 	StorageRemoveInput,
-	StorageDownloadDataInput,
 	StorageUploadDataInput,
 } from '../../../types';
 import {
+	CopyDestinationOptions,
+	CopySourceOptions,
+	DownloadDataOptions,
 	GetPropertiesOptions,
 	GetUrlOptions,
 	ListAllOptions,
 	ListPaginateOptions,
 	RemoveOptions,
-	DownloadDataOptions,
 	UploadDataOptions,
-	CopyDestinationOptions,
-	CopySourceOptions,
 } from '../types';
 
 // TODO: support use accelerate endpoint option